Passo a passo: Aplicativo Web da API Bing Ads em Python

Este tutorial explora como começar a executar um aplicativo Web do Microsoft Advertising usando o SDK Python do Bing Ads, o IDE de Código do Visual Studio e a estrutura da Web do Django .

Este tutorial não explora vários detalhes sobre o Django em si, como trabalhar com modelos de dados e criar uma interface administrativa. Para orientação sobre esses aspectos, consulte a documentação do Django. Para obter mais detalhes sobre como trabalhar com o Django no terminal VS Code, editor e depurador, consulte Usar o Django no Visual Studio Code. Este tutorial pega muito emprestado das instruções de instalação em Usar o Django no Visual Studio Code.

Visão geral do aplicativo Web de exemplo

No final deste tutorial, terá uma aplicação Web em execução http://localhost que irá autenticar as suas credenciais de utilizador do Microsoft Advertising e apresentar as suas informações de utilizador e contas. Em seguida, pode adicionar vários utilizadores da aplicação Web, que podem permitir o acesso à sua aplicação para utilizar as respetivas credenciais do Microsoft Advertising. Esta aplicação Web fornece um mapeamento um-para-um de um utilizador da aplicação Web, por exemplo, ContosoUser para um utilizador do Microsoft Advertising. Para obter informações sobre como modificar o modelo de dados, consulte a documentação do Django para obter mais informações. Se o utilizador da aplicação Web permitir o acesso às contas do Microsoft Advertising com uma conta Microsoft, é armazenado um token de atualização na base de dados SQL Lite no servidor Web.

Pré-requisitos

Você precisará ter o Visual Studio Code instalado para seguir este tutorial. Para executar o aplicativo Web Django, você pode usar Visual Studio Community ou Visual Studio Professional, no entanto, as etapas de configuração serão diferentes das deste tutorial.

Você precisará ter o Python 3 instalado a partir do python.org; normalmente usa o botão Download Python 3.7.0 que aparece primeiro na página (ou qualquer que seja a versão mais recente). No Windows, certifique-se de que a localização do seu interpretador Python está incluída na variável de ambiente PATH. Pode verificar isto ao executar path a linha de comandos. Se a pasta do interpretador Python não estiver incluída, abra as Definições do Windows, procure "environment", selecione Editar variáveis de ambiente para a sua conta e, em seguida, edite a variável Path para incluir essa pasta.

Você precisará instalar o SDK do Python do Bing Ads e este tutorial o guiará pela instalação.

Você precisará da estrutura web do Django instalada para implantar o aplicativo localmente, e este tutorial irá orientá-lo através da instalação.

Precisa de, pelo menos, um utilizador com as credenciais do Microsoft Advertising e um token de programador.

Terá de registar uma aplicação e anotar o ID de cliente (ID de aplicação registado) e o segredo do cliente (palavra-passe registada). Terá de registar uma aplicação Web (não nativa) para este exemplo. Ser-lhe-á pedido para registar um ou mais URLs de redirecionamento, e para este tutorial deverá registar-se http://localhost/callback. Em vez disso, você deve usar https quando implantado em um servidor de produção. Para obter mais detalhes sobre como registrar um aplicativo e o fluxo de concessão do código de autorização, consulte Autenticação com OAuth.

Este tutorial foi desenvolvido no Windows. Embora o Windows não seja necessário para executar a amostra, alguns dos passos abaixo variam consoante utilizar outro sistema operativo, por exemplo, Linux ou MacOS.

Criar um ambiente de projeto para o Django

Nesta seção você cria um ambiente virtual no qual o Django está instalado. Usar um ambiente virtual evita instalar o Django em um ambiente Python global e oferece controle exato sobre as bibliotecas usadas em um aplicativo.

No sistema de arquivos, crie uma pasta de projeto para este tutorial, como hello_django.
Na pasta, abra o hello_django Powershell ou seu shell de script favorito e use o seguinte comando para criar um ambiente virtual nomeado env com base no seu intérprete atual:
```
py -3 -m venv env
```
Abra a pasta do hello_django projeto no VS Code executando code .o , ou executando o VS Code e usando o comando File>Open Folder .
No Código VS, abra a Paleta de Comandos (Exibir>Paleta de Comandos ou Ctrl+Shift+P). Em seguida, selecione o comando Python: Select Interpreter .
O comando apresenta uma lista de intérpretes disponíveis que o VS Code pode localizar automaticamente. A sua lista irá variar; se você não vir o intérprete desejado, consulte Configurando ambientes Python. Na lista, selecione o ambiente virtual na pasta do projeto que começa com ./env ou .\env:
Execute Terminal: Novo Terminal (Ctrl+Shift+ ` ) a partir da Paleta de Comandos, que cria um terminal e ativa automaticamente o ambiente virtual executando seu script de ativação.

Nota

No Windows, se o tipo de terminal predefinido for PowerShell, poderá ver um erro que indica que não é possível executar activate.ps1 porque a execução de scripts está desativada no sistema. O erro deve fornecer um link para informações sobre como permitir scripts. Caso contrário, use Terminal: Selecione Default Shell para definir seu padrão preferido.

O ambiente selecionado aparece no canto inferior esquerdo da barra de status do VS Code. Observe o indicador (venv) que informa que você está usando um ambiente virtual:
Instale o Django no ambiente virtual via pip no Terminal VS Code:
```
python -m pip install django
```
Instale o SDK Python do Bing Ads no ambiente virtual via pip no Terminal VS Code:
```
python -m pip install bingads
```

Agora você tem um ambiente virtual autônomo pronto para escrever código do Django e do Microsoft Advertising.

Criar e executar um aplicativo Django

Na terminologia do Django, um "projeto Django" é composto por vários arquivos de configuração no nível do site, juntamente com um ou mais "aplicativos" que você implanta em um host da Web para criar um aplicativo Web completo. Um projeto Django pode conter vários aplicativos, cada um dos quais normalmente tem uma função independente no projeto, e o mesmo aplicativo pode estar em vários projetos Django. Um aplicativo, por sua vez, é apenas um pacote Python que segue certas convenções que Django espera.

Para criar um aplicativo Django, então, é necessário primeiro criar o projeto Django para servir como contêiner para o aplicativo e, em seguida, criar o próprio aplicativo. Para ambos os fins, você usa o utilitário administrativo Django, django-adminque é instalado quando você instala o pacote Django.

Criar o projeto Django

No VS Code Terminal onde seu ambiente virtual está ativado, execute o seguinte comando:
```
django-admin startproject web_project .
```
Este startproject comando assume (usando no final) que a pasta atual é a pasta do . projeto e cria o seguinte dentro dela:
- manage.py: O utilitário administrativo de linha de comando Django para o projeto. Execute comandos administrativos para o projeto usando python manage.py <command> [options]o .
- Uma subpasta denominada web_project, que contém os seguintes ficheiros:
  - __init__.py: um ficheiro vazio que indica ao Python que esta pasta é um pacote Python.
  - wsgi.py: um ponto de entrada para servidores Web compatíveis com WSGI para servir o seu projeto. Normalmente, você deixa esse arquivo como está, pois ele fornece os ganchos para servidores Web de produção.
  - settings.py: contém configurações para o projeto Django, que você modifica no decorrer do desenvolvimento de um aplicativo web.
  - urls.py: contém um índice para o projeto Django, que você também modifica no decorrer do desenvolvimento.
Para verificar o projeto Django, certifique-se de que seu ambiente virtual está ativado, em seguida, inicie o servidor de desenvolvimento do Django usando o comando python manage.py runserver. O servidor é executado na porta padrão 8000, e você vê a saída como a seguinte na janela de saída do terminal VS Code:
```
Performing system checks...

System check identified no issues (0 silenced).

You have 15 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
October 18, 2018 - 05:38:23
Django version 2.1.2, using settings 'web_project.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
```
Quando você executa o servidor pela primeira vez, ele cria um banco de dados SQLite padrão no arquivo db.sqlite3, que geralmente é destinado para fins de desenvolvimento, mas pode ser usado na produção para aplicativos Web de baixo volume. Além disso, o servidor web embutido do Django destina-se apenas para fins de desenvolvimento local. Quando você implanta em um host da web, no entanto, o Django usa o servidor web do host. O wsgi.py módulo no projeto Django cuida de se conectar aos servidores de produção.

Se quiser usar uma porta diferente da 8000 padrão, basta especificar o número da porta na linha de comando, como python manage.py runserver 5000.
Ctrl+click o http://127.0.0.1:8000/ URL na janela de saída do terminal VS Code para abrir o browser predefinido para esse endereço. Se o Django estiver instalado corretamente e o projeto for válido, você verá a página padrão mostrada abaixo. A janela VS Code Output também mostra o log do servidor.
Quando terminar, feche a janela do navegador e pare o servidor no VS Code usando Ctrl+C como indicado na janela de saída do terminal VS Code.

Criar uma aplicação Django para o Microsoft Advertising

No VS Code Terminal com seu ambiente virtual ativado, execute o comando do utilitário administrativo na pasta do startapp projeto (onde manage.py reside):
```
python manage.py startapp app
```
O comando cria uma pasta chamada app que contém vários arquivos de código e uma subpasta. Destes, você trabalha views.py com freqüência (que contém as funções que definem páginas em seu aplicativo Web) e models.py (que contém classes que definem seus objetos de dados). A migrations pasta é usada pelo utilitário administrativo do Django para gerenciar versões do banco de dados, conforme discutido mais adiante neste tutorial. Há também os arquivos apps.py (configuração do aplicativo), admin.py (para criar uma interface administrativa) e tests.py (para testes de unidade), que não são abordados aqui.

Adicione app/settings.py o seguinte código e defina os seus próprios valores CLIENT_ID, CLIENT_SECRET, DEVELOPER_TOKEN e AMBIENTE .

"""
Bing Ads API settings
Edit with your credentials.
"""

REDIRECTION_URI = "http://localhost:8000/callback"
CLIENT_ID = "ClientIdGoesHere" # Your registered App ID
CLIENT_SECRET="ClientSecretGoesHere" # Your registered App Password
DEVELOPER_TOKEN = "DeveloperTokenGoesHere" # Your production developer token
ENVIRONMENT = 'production'
API_VERSION=13

Dentro app/settings.py , adicione app à lista de aplicações instaladas.

    INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app',
]

No VS Code Terminal crie as app/static/app pastas e app/templates/app :

(env) PS C:\dev\hello_django> mkdir app/static/app
(env) PS C:\dev\hello_django> mkdir app/templates/app

Dentro das pastas, app/static/app crie um novo ficheiro com o nome site.css e adicione os seguintes conteúdos.

.message {
    font-weight: 600;
    color: blue;
}

.message_list th,td {
    text-align: left;
    padding-right: 15px;
}

.navbar {
    background-color: lightslategray;
    font-size: 1em;
    font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
    color: white;
    padding: 8px 5px 8px 5px;
}

.navbar a {
    text-decoration: none;
    color: inherit;
}

.navbar-brand {
    font-size: 1.2em;
    font-weight: 600;
}

.navbar-item {
    font-variant: small-caps;
    margin-left: 30px;
}

.body-content {
    padding: 5px;
    font-family:'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}

input[name=message] {
    width: 80%;
}

Dentro da app/templates/app pasta, crie um ficheiro, index.html com os conteúdos abaixo.

{% extends "app/layout.html" %}
{% block content %}
{% if errors %}
<div class="jumbotron">
    <section id="errors">
        <h1>Errors occurred in your last request to Bing Ads API.</h1>
        <table class="message_list">
            <tr>
                <th>Code</th>
                <th>ErrorCode</th>
                <th>Message</th>
            </tr>
            {% for error in errors %}
            <tr>
                <td>{{ error.Code }}</td> 
                <td>{{ error.ErrorCode }}</td> 
                <td>{{ error.Message }}</td> 
            </tr>
            {% endfor %}
        </table> 
    </section>
</div>
{% endif %}
{% if user.is_authenticated  %}
{% if bingadsuser  %}
<div class="jumbotron">
    <section id="enabled">
        <h1>Your credentials have access to Microsoft Advertising.</h1>
        <table class="message_list">
            <tr>
                <th>Id</th>
                <th>UserName</th>
                <th>First Name</th>
                <th>Last Name</th>
            </tr>
            <tr>
                <td>{{ bingadsuser.Id }}</td> 
                <td>{{ bingadsuser.UserName }}</td> 
                <td>{{ bingadsuser.Name.FirstName }}</td> 
                <td>{{ bingadsuser.Name.LastName }}</td> 
            </tr>
        </table>  
    </section>
</div>
<div class="jumbotron">
    <section id="revoke">
        <p class="lead">Click here to revoke access for this app to your Microsoft Advertising accounts. You will then be able to login with a different Microsoft Advertising user. </p>
        <form id="revokeForm" action="/revoke" method="post" class="navbar-left">
            {% csrf_token %}
            <p><a href="javascript:document.getElementById('revokeForm').submit()" class="btn btn-primary btn-large">Delete Refresh Token</a></p>
        </form>
    </section>
</div>
<div class="jumbotron">
    <section id="accounts">        
        <h1>Account Details</h1>
        <table class="message_list">
            <thead>
            <tr>
                <th>Id</th>
                <th>Name</th> 
            </tr>
            </thead>
            <tbody>
            {% for account in accounts %}
            <tr>
                <td>{{ account.Id }}</td>
                <td>{{ account.Name }}</td> 
            </tr>
            {% endfor %}
            </tbody>
        </table> 
    </section>
</div>
{% else  %}
<div class="jumbotron">
    <section id="enable">
        <h1>Enable Microsoft Advertising Access</h1>
        <p class="lead">
            You are logged into the Django web application, but not yet signed in with your Microsoft Advertising credentials. 
            You can sign in with Microsoft Advertising credentials below.
        </p>
    </section>
</div>
<div>
    <div class="col-md-6">
        <section id="socialLoginForm">
            <h1>Microsoft Account Login</h1>
            <p class="lead">
                Click here to authenticate your Microsoft Account. 
                If you don't have Microsoft Advertising credentials, you can go to the 
                <a href="https://ads.microsoft.com/customer/Signup.aspx">Microsoft Advertising Sign Up</a> page.
            </p>
            <p><a href="/callback" class="btn btn-primary btn-large">Authenticate Microsoft Account &raquo;</a></p>
        </section>
    </div>    
</div>
{% endif %}
{% else %}
<div class="jumbotron">
    <div class="col-md-6">
        <section id="socialLoginForm">
            <h1>Microsoft Advertising Example Web Application</h1>
            <p class="lead">
                Before you can provide your Microsoft Advertising user credentials and access Microsoft Advertising data, 
                you must <a href="{% url 'login' %}">login</a> to the Django web application.
            </p>
            <p class="lead">Use your site's Django admin portal to add web app users.</p>
            <p><a href="/admin" class="btn btn-primary btn-large">Django Admin &raquo;</a></p>
        </section>
    </div>    
</div>
{% endif %}
<div>
    <div class="col-md-4">
        <h2>Get Started Using Python with Bing Ads API</h2>
        <p>The Bing Ads Python Software Development Kit (SDK) simplifies workflows such as OAuth authentication and report file parsing.</p>
        <p><a class="btn btn-default" href="https://learn.microsoft.com/advertising/guides/get-started-python">Learn more &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Django</h2>
        <p>Django is a free web framework for building Web sites and Web applications using HTML, CSS and JavaScript.</p>
        <p><a class="btn btn-default" href="https://www.djangoproject.com/">Learn more &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Microsoft Azure</h2>
        <p>You can publish your web app to Microsoft Azure. Find out how you can host your application with a free trial today.</p>
        <p><a class="btn btn-default" href="https://azure.microsoft.com">Learn more &raquo;</a></p>
    </div>
</div>
{% endblock %}
{% block scripts %}
{% load static %}
<link rel="stylesheet" type="text/css" href="{% static 'app/site.css' %}"/>
{% endblock %}

Dentro da app/templates/app pasta, crie um ficheiro, layout.html com os conteúdos abaixo.

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ title }} - My Django Application</title>
    {% load static %}
    <link rel="stylesheet" type="text/css" href="{% static 'app/site.css' %}"/>
    <script src="{% static 'app/scripts/modernizr-2.6.2.js' %}"></script>
</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="container">
            <div class="navbar-header">
                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                <a href="/" class="navbar-brand">Microsoft Advertising App via Django</a>
            </div>
            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li><a href="{% url 'home' %}">Home</a></li>
                </ul>
                {% include 'app/loginpartial.html' %}
            </div>
        </div>
    </div>
    <div class="container body-content">
{% block content %}{% endblock %}
        <hr/>
        <footer>
            <p>&copy; {{ year }} - My Django Application</p>
        </footer>
    </div>
{% block scripts %}{% endblock %}
</body>
</html>

Dentro da app/templates/app pasta, crie um ficheiro, login.html com os conteúdos abaixo.

{% extends "app/layout.html" %}
{% block content %}
<h2>{{ title }}</h2>
<div class="row">
    <div class="col-md-8">
        <section id="loginForm">
            <form action="." method="post" class="form-horizontal">
                {% csrf_token %}
                <h4>Use a local account to log in.</h4>
                <hr />
                <div class="form-group">
                    <label for="id_username" class="col-md-2 control-label">User name</label>
                    <div class="col-md-10">
                        {{ form.username }}
                    </div>
                </div>
                <div class="form-group">
                    <label for="id_password" class="col-md-2 control-label">Password</label>
                    <div class="col-md-10">
                        {{ form.password }}
                    </div>
                </div>
                <div class="form-group">
                    <div class="col-md-offset-2 col-md-10">
                        <input type="hidden" name="next" value="/" />
                        <input type="submit" value="Log in" class="btn btn-default" />
                    </div>
                </div>
                {% if form.errors %}
                <p class="validation-summary-errors">Please enter a correct user name and password.</p>
                {% endif %}
            </form>
        </section>
    </div>
</div>
{% endblock %}
{% block scripts %}
{% load static %}
<link rel="stylesheet" type="text/css" href="{% static 'app/site.css' %}"/>
{% endblock %}

Dentro da app/templates/app pasta, crie um ficheiro, loginpartial.html com os conteúdos abaixo.

{% if user.is_authenticated  %}
<form id="logoutForm" action="/applogout" method="post" class="navbar-right">
    {% csrf_token %}
    <ul class="nav navbar-nav navbar-right">
        <li><span class="navbar-brand">Hello {{ user.username }}!</span></li>
        <li><a href="javascript:document.getElementById('logoutForm').submit()">Log off</a></li>
    </ul>
</form>
{% else %}
<ul class="nav navbar-nav navbar-right">
    <li><a href="{% url 'login' %}">Log in</a></li>
</ul>
{% endif %}

Dentro da app pasta, crie um ficheiro, forms.py com os conteúdos abaixo.

from django import forms
from django.contrib.auth.forms import AuthenticationForm
from django.utils.translation import ugettext_lazy as _

class BootstrapAuthenticationForm(AuthenticationForm):
    """Authentication form which uses boostrap CSS."""
    username = forms.CharField(max_length=254,
                               widget=forms.TextInput({
                                   'class': 'form-control',
                                   'placeholder': 'User name'}))
    password = forms.CharField(label=_("Password"),
                               widget=forms.PasswordInput({
                                   'class': 'form-control',
                                   'placeholder':'Password'}))

Modifique app/models.py para corresponder ao código a seguir.

from django.db import models
from django.contrib.auth.models import User

# In this web app a Microsoft Advertising user maps a Django web user to a refresh token.

class BingAdsUser(models.Model):
    user = models.OneToOneField(User, on_delete=models.PROTECT)
    refresh_token = models.CharField(max_length=200)

    # def __unicode__(self):              # __unicode__ on Python 2
    #     return self.refresh_token
    def __str__(self):              # __str__ on Python 3
        return self.refresh_token

Modifique app/views.py para corresponder ao código a seguir.

from django.http import HttpRequest, HttpResponse
from django.shortcuts import render
from django.template.loader import get_template, render_to_string
from web_project import settings
from datetime import datetime
from django.shortcuts import redirect
from django.contrib.auth import authenticate, login, logout, get_user_model
from django.contrib.auth.models import User
from app.models import BingAdsUser
from bingads import *

# import logging
# logging.basicConfig(level=logging.INFO)
# logging.getLogger('suds.client').setLevel(logging.DEBUG)
# logging.getLogger('suds.transport').setLevel(logging.DEBUG)

authorization_data = AuthorizationData(
    account_id=None, 
    customer_id=None, 
    developer_token=None, 
    authentication=None)

customer_service=None

def home(request):
    """
    If an authenticated user returns to this page after logging in, the appropriate 
    context is provided to index.html for rendering the page. 
    """
    assert isinstance(request, HttpRequest)

    # If the Django user has a refresh token stored, 
    # try to use it to get Microsoft Advertising data.
    if user_has_refresh_token(request.user.username):
        return redirect('/callback')
    else:
        return render(
            request,
            'app/index.html'
        )

def callback(request):
    """Handles OAuth authorization, either via callback or direct refresh request."""
    assert isinstance(request, HttpRequest)

    authentication = OAuthWebAuthCodeGrant(
        client_id=settings.CLIENT_ID,
        client_secret=settings.CLIENT_SECRET, 
        redirection_uri=settings.REDIRECTION_URI,
        env=settings.ENVIRONMENT)

    return authorize_bing_ads_user(request, authentication)

def authorize_bing_ads_user(request, authentication):
    assert isinstance(request, HttpRequest)

    global customer_service
    bingadsuser = None

    try:
        Users = get_user_model()
        user = User.objects.get(username=request.user.username)
    except User.DoesNotExist:
        return render(
            request,
            'app/index.html'
        )

    try:
        bingadsuser = user.bingadsuser
    except BingAdsUser.DoesNotExist:
        bingadsuser = BingAdsUser()
        bingadsuser.user = user
        pass

    try:
        # If we have a refresh token let's refresh the access token.
        if(bingadsuser is not None and bingadsuser.refresh_token != ""):
            authentication.request_oauth_tokens_by_refresh_token(bingadsuser.refresh_token)
            bingadsuser.refresh_token = authentication.oauth_tokens.refresh_token

        # If the current HTTP request is a callback from the Microsoft Account authorization server,
        # use the current request url containing authorization code to request new access and refresh tokens.
        elif (request.GET.get('code') is not None):
            authentication.request_oauth_tokens_by_response_uri(response_uri = request.get_full_path()) 
            bingadsuser.refresh_token = authentication.oauth_tokens.refresh_token
    except OAuthTokenRequestException:
        bingadsuser.refresh_token = ""  

    user.save()
    bingadsuser.save()

    # If there is no refresh token saved and no callback from the authorization server, 
    # then connect to the authorization server and request user consent.
    if (bingadsuser.refresh_token == ""):
        return redirect(authentication.get_authorization_endpoint())

    set_session_data(request, authentication)

    # At this point even if the user has valid Django web application credentials, 
    # we don't know whether they have access to Microsoft Advertising.
    # Let's test to see if they can call Bing Ads API service operations. 

    bing_ads_user = None
    accounts=[]
    errors=[]

    try:
        bing_ads_user = get_user(None)
        accounts = search_accounts_by_user_id(bing_ads_user.Id)['AdvertiserAccount']
    except WebFault as ex:
        errors=get_webfault_errors(ex)
        pass

    context = {
        'bingadsuser': bing_ads_user,
        'accounts': accounts,
        'errors': errors,
    }
    return render(
        request,
        'app/index.html',
        context
    )

def revoke(request):
    """Deletes the refresh token for the user authenticated in the current session."""
    assert isinstance(request, HttpRequest)

    try:
        Users = get_user_model()
        user = User.objects.get(username=request.user.username)
        bingadsuser = user.bingadsuser
        if(bingadsuser is not None):
            bingadsuser.refresh_token = ""
            bingadsuser.save()
    except User.DoesNotExist:
        pass
    except BingAdsUser.DoesNotExist:
        pass

    clear_session_data(request)

    return render(
        request,
        'app/index.html'
    )

def user_has_active_session(request):
    try:
        return True if request.session['is_authenticated'] else False 
    except KeyError:
        return False

def user_has_refresh_token(username):
    try:
        Users = get_user_model()
        user = User.objects.get(username=username)
        bingadsuser = user.bingadsuser
        if(bingadsuser is not None and bingadsuser.refresh_token != ""):
            return True
    except User.DoesNotExist:
        return False
    except BingAdsUser.DoesNotExist:
        return False

def set_session_data(request, authentication):
    global authorization_data
    global customer_service

    try:
        request.session['is_authenticated'] = True

        authorization_data.authentication = authentication
        authorization_data.developer_token = settings.DEVELOPER_TOKEN

        customer_service = ServiceClient(
            service='CustomerManagementService', 
            version=settings.API_VERSION,
            authorization_data=authorization_data,
            environment=settings.ENVIRONMENT
        )

    except KeyError:
        pass
    return None   

def clear_session_data(request):
    global authorization_data
    global customer_service

    request.session['is_authenticated'] = False

    authorization_data = AuthorizationData(account_id=None, customer_id=None, developer_token=None, authentication=None)
    customer_service = None

def applogout(request):
    logout(request)
    clear_session_data(request)
    return redirect('/')

def get_user(user_id):
    ''' 
    Gets a Microsoft Advertising User object by the specified user ID.

    :param user_id: The Microsoft Advertising user identifier.
    :type user_id: long
    :return: The Microsoft Advertising user.
    :rtype: User
    '''
    global customer_service

    return customer_service.GetUser(UserId = user_id).User

def search_accounts_by_user_id(user_id):
    ''' 
    Search for account details by UserId.

    :param user_id: The Microsoft Advertising user identifier.
    :type user_id: long
    :return: List of accounts that the user can manage.
    :rtype: Dictionary of AdvertiserAccount
    '''

    predicates={
        'Predicate': [
            {
                'Field': 'UserId',
                'Operator': 'Equals',
                'Value': user_id,
            },
        ]
    }

    accounts=[]

    page_index = 0
    PAGE_SIZE=100
    found_last_page = False

    while (not found_last_page):
        paging=set_elements_to_none(customer_service.factory.create('ns5:Paging'))
        paging.Index=page_index
        paging.Size=PAGE_SIZE
        search_accounts_response = customer_service.SearchAccounts(
            PageInfo=paging,
            Predicates=predicates
        )

        if search_accounts_response is not None and hasattr(search_accounts_response, 'AdvertiserAccount'):
            accounts.extend(search_accounts_response['AdvertiserAccount'])
            found_last_page = PAGE_SIZE > len(search_accounts_response['AdvertiserAccount'])
            page_index += 1
        else:
            found_last_page=True

    return {
        'AdvertiserAccount': accounts
    }

def set_elements_to_none(suds_object):
    for (element) in suds_object:
        suds_object.__setitem__(element[0], None)
    return suds_object

def get_webfault_errors(ex):
    errors=[]

    if not hasattr(ex.fault, "detail"):
        raise Exception("Unknown WebFault")

    error_attribute_sets = (
        ["ApiFault", "OperationErrors", "OperationError"],
        ["AdApiFaultDetail", "Errors", "AdApiError"],
        ["ApiFaultDetail", "BatchErrors", "BatchError"],
        ["ApiFaultDetail", "OperationErrors", "OperationError"],
        ["EditorialApiFaultDetail", "BatchErrors", "BatchError"],
        ["EditorialApiFaultDetail", "EditorialErrors", "EditorialError"],
        ["EditorialApiFaultDetail", "OperationErrors", "OperationError"],
    )

    for error_attribute_set in error_attribute_sets:
        errors = get_api_errors(ex.fault.detail, error_attribute_set)
        if errors is not None:
            return errors

    return None

def get_api_errors(error_detail, error_attribute_set):
    api_errors = error_detail
    for field in error_attribute_set:
        api_errors = getattr(api_errors, field, None)
    if api_errors is None:
        return None

    errors=[]
    if type(api_errors) == list:
        for api_error in api_errors:
            errors.append(api_error)
    else:
        errors.append(api_errors)
    return errors

Substitua o conteúdo de web_project/urls.py pelo conteúdo abaixo. O urls.py arquivo é onde você especifica padrões para rotear URLs diferentes para suas exibições apropriadas. Por exemplo, o código abaixo mapeia a URL raiz do aplicativo ("") para a home função que você acabou de adicionar a app/views.py:

from django.contrib import admin
from django.urls import path
from app import views as app_views
from django.contrib.auth import views as auth_views
from datetime import datetime
from django.conf.urls import include, url
from app.forms import BootstrapAuthenticationForm
from django.contrib.auth.views import HttpResponseRedirect

from django.contrib import admin
admin.autodiscover()

urlpatterns = [
    url(r'^applogout', app_views.applogout, name='applogout'),
    url(r'^callback', app_views.callback, name='callback'),
    url(r'^revoke', app_views.revoke, name='revoke'),
    url(r'^$', app_views.home, name='home'),
    url(r'^login/$',
        auth_views.LoginView.as_view(
            template_name='app/login.html', 
            authentication_form=BootstrapAuthenticationForm,
            extra_context= {
                'title':'Log in',
                'year':datetime.now().year,
            }
        ),
        name='login'),
    url(r'^logout$',
        auth_views.LogoutView.as_view(),
        {
            'next_page': '/',
        },
        name='logout'),

    url(r'^admin/', admin.site.urls),
]

Salve todos os arquivos modificados com Ctrl+K So .
Execute python manage.py makemigrations para gerar scripts na pasta de migrações que migram o banco de dados de seu estado atual para o novo estado.
Execute python manage.py migrate para aplicar os scripts ao banco de dados real. Os scripts de migração registam de forma eficaz todas as alterações incrementais efetuadas aos seus modelos de dados (models.py) ao longo do tempo. Ao aplicar as migrações, o Django atualiza o banco de dados para corresponder aos seus modelos. Como cada alteração incremental tem seu próprio script, o Django pode migrar automaticamente qualquer versão anterior de um banco de dados (incluindo um novo banco de dados) para a versão atual. Como resultado, você precisa se preocupar apenas com seus modelos no models.py, nunca com o esquema de banco de dados subjacente ou os scripts de migração. Você deixa o Django fazer essa parte!
Crie uma conta de superusuário no aplicativo abrindo um Terminal no VS Code para seu ambiente virtual, em seguida, executando o comando python manage.py createsuperuser --username=<username> --email=<email>, substituindo <username> e <email>, claro, com suas informações pessoais. Quando você executa o comando, Django solicita que você insira e confirme sua senha.

Importante

Lembre-se da combinação de nome de utilizador e palavra-passe. Estas são as credenciais que utiliza para efetuar a autenticação no portal de administração da aplicação Web.
No VS Code Terminal, novamente com o ambiente virtual ativado, execute o servidor de desenvolvimento e python manage.py runserver abra um navegador para http://127.0.0.1:8000/ ver uma página que renderiza "Olá, Django".
No navegador da Web, vá para http://127.0.0.1:8000/admin/ e crie um novo usuário da Web do Django em Usuários. Isto é diferente das suas credenciais de utilizador do Microsoft Advertising, para que vários utilizadores do Microsoft Advertising possam iniciar sessão na sua aplicação separadamente.
Inicie sessão com o novo utilizador (não com o superadministrador) e deverá ver a opção para se autenticar com uma conta Microsoft.
Depois de clicar em Autenticar Conta Microsoft , ser-lhe-á pedido para conceder as suas próprias permissões de aplicação Web para gerir as suas contas do Microsoft Advertising. Se o utilizador der o seu consentimento e tiver acesso a contas do Microsoft Advertising, deverá ser redirecionado para uma vista de nomes e IDs da sua conta.

Comentários

Esta página foi útil?

Última atualização a 2026-09-11