Пример #1
0
 def __init__(self, account_id):
     prefs = Preferences.objects.get()
     ad_account_id = 'act_%s' % account_id
     FacebookAdsApi.init(access_token=prefs.facebook_access_token)
     fields = [
         'account_id',
         'account_name',
         'cost_per_total_action',
         'impressions',
         'total_action_value',
         'spend',
     ]
     now = timezone.now()
     last_day = calendar.monthrange(now.year, now.month)[1]
     params = {
         'time_range': {
             'since': now.strftime('%Y-%m-01'),
             'until': now.strftime('%Y-%m-') + '%s' % last_day
         },
         'filtering': [],
         'level': 'account',
         'breakdowns': [],
     }
     try:
         self.data = AdAccount(ad_account_id).get_insights(fields=fields,
                                                           params=params)[0]
     except:
         self.data = None
Пример #2
0
def reset_thread_state(**kwargs):
    '''
    Called to reset static variables for example the API instance after we are
    done with one request to prevent them from unintentionally lingering between
    requests.
    '''
    FacebookAdsApi.set_default_api(None)
Пример #3
0
 def __init__(self, post):
     self.ad_account_id = "act_" + post["fb_ad_account"]
     self.post = post
     FacebookAdsApi.init(app_id=app_id,
                         app_secret=app_secret,
                         access_token=post["access_token"],
                         api_version="v3.0")
Пример #4
0
def data(request):
    print(request)
    # environmental variables for facebook auth
    app_id = os.environ['APP_ID']
    app_secret = os.environ['APP_SECRET']
    access_token = os.environ['ACCESS_TOKEN']
    FacebookAdsApi.init(app_id, app_secret, access_token)

    campaign_id = request.GET['campaign-id']

    def get_campaign_stats(campaign):
        campaign = Campaign(campaign)
        params = {
            'data_preset':
            'lifetime',
            'fields': [
                Insights.Field.impressions,
                Insights.Field.unique_clicks,
                Insights.Field.reach,
                Insights.Field.cpm,
                Insights.Field.spend,
            ]
        }
        data_set = campaign.get_insights(params=params)
        return data_set[0]

    data_set = get_campaign_stats(campaign_id)
    data_set['cpm'] = str(data_set['cpm'])[:4]
    context = {
        'data_set': data_set,
        'name': 'Campaign Breakdown',
    }
    print(data_set)
    return render(request, 'campaigns_data/data.html', context)
Пример #5
0
def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    name = req.params.get('name')
    if not name:
        try:
            req_body = req.get_json()
        except ValueError:
            pass
        else:
            name = req_body.get('name')

    token = 'EAAatqMY9YeQBAKo2WiunzO8xaxA0YwqQXfflxCLKuZAZA75i44dndFAYrXP1wwiaDnNElMPy28HalSgz52vI8qkSyW45u8C96o8MZA0hPQU8SA9ZCOhFKoySma4HZAtMR7JLZB262BEY6jDMIEPaKe2P4tTIsdllZBsrmWPyJjCh3of5Tl1hXRZBMG8kZBtM6ViNapBVpbrHw0tSqVPcwe9a9'
    FacebookAdsApi.init(access_token=token)

    params = {
        'q': name,
        'limit': 10000000,
        'locate': 'pt_br',
        'type': 'adinterest',
    }

    name = TargetingSearch.search(params=params)

    if name:
        return func.HttpResponse(f"Hello {name}!")
    else:
        return func.HttpResponse(
            "Please pass a name on the query string or in the request body",
            status_code=400)
Пример #6
0
def campaigns_with_insights(start, end):
    response = []
    try:
        my_session = FacebookSession(my_app_id, my_app_secret, my_access_token)
        my_api = FacebookAdsApi(my_session)
        FacebookAdsApi.set_default_api(my_api)
        me = objects.AdUser(fbid='me')
        my_accounts = list(me.get_ad_accounts())
        my_account = my_accounts[0]
        fields = [
            AdsInsights.Field.clicks, AdsInsights.Field.spend,
            AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks,
            AdsInsights.Field.cost_per_unique_click,
            AdsInsights.Field.cost_per_inline_link_click
        ]

        params = {
            'time_range': {
                'since': start,
                'until': end
            },
            'effective_status': ["ACTIVE"]
        }
        campaigns = my_account.get_campaigns(
            params=params, fields=[Campaign.Field.name, Campaign.Field.status])
        headers = [
            "Name",
            'Cost',
            "Impressions",
            "Clicks",
            "Unique Clicks",
            "Cost per unique click",
        ]
        for i in campaigns:
            try:
                campaign = Campaign(i['id'])
                campaign_data = campaign.get_insights(params=params,
                                                      fields=fields)
                campaign_dict = {
                    'id':
                    i['id'],
                    'name':
                    i['name'],
                    'Cost':
                    campaign_data[0]['spend'],
                    "Clicks":
                    campaign_data[0]['clicks'],
                    "Unique_Clicks":
                    campaign_data[0]['unique_clicks'],
                    "Cost_per_unique_click":
                    campaign_data[0]['cost_per_unique_click'],
                    "Impressions":
                    campaign_data[0]['impressions']
                }
                response.append(campaign_dict)
            except:
                pass
    except:
        pass
    return {'headers': headers, 'rows': response}
Пример #7
0
def data(request):
    print(request)
    # environmental variables for facebook auth
    app_id = os.environ['APP_ID']
    app_secret = os.environ['APP_SECRET']
    access_token = os.environ['ACCESS_TOKEN']
    FacebookAdsApi.init(app_id, app_secret, access_token)

    campaign_id = request.GET['campaign-id']

    def get_campaign_stats(campaign):
        campaign = Campaign(campaign)
        params = {
            'data_preset': 'lifetime',
            'fields': [
                Insights.Field.impressions,
                Insights.Field.unique_clicks,
                Insights.Field.reach,
                Insights.Field.cpm,
                Insights.Field.spend,
            ]
        }
        data_set = campaign.get_insights(params=params)
        return data_set[0]

    data_set = get_campaign_stats(campaign_id)
    data_set['cpm'] = str(data_set['cpm'])[:4]
    context = {
        'data_set': data_set,
        'name': 'Campaign Breakdown',
    }
    print(data_set)
    return render(request, 'campaigns_data/data.html', context)
Пример #8
0
    def auth(cls):
        """
            Prepare for Ads API calls and return a tuple with act_id
            and page_id. page_id can be None but act_id is always set.
        """
        config = cls.load_config()

        if cls._is_authenticated:
            return config['act_id'], config.get('page_id', None)

        if config['app_id'] and config['app_secret'] \
           and config['act_id'] and config['access_token']:

            FacebookAdsApi.init(
                config['app_id'],
                config['app_secret'],
                config['access_token'],
                config['act_id'],
            )

            cls._is_authenticated = True

            return config['act_id'], config.get('page_id', None)

        else:
            required_fields = set(
                ('app_id', 'app_secret', 'act_id', 'access_token'))

            missing_fields = required_fields - set(config.keys())
            raise FacebookError(
                '\n\tFile config.json needs to have the following fields: {}\n'
                '\tMissing fields: {}\n'.format(
                    ', '.join(required_fields),
                    ', '.join(missing_fields),
                ))
Пример #9
0
		def __init__(self, my_access_token, my_account_id, my_app_id = 'XXXXXXX', my_app_secret='XXXXXXXXXX'):
				self.my_app_id = my_app_id
				self.my_app_secret = my_app_secret
				self.my_access_token = my_access_token
				self.my_account_id = my_account_id
				FacebookAdsApi.init(self.my_app_id, self.my_app_secret, self.my_access_token)
				self.api = FacebookAdsApi.get_default_api()
Пример #10
0
def getFacebookAPI(token, act_id, secret):
    token, act_id, secret
    if secret != '-':
        api = FacebookAdsApi.init(access_token=token, app_secret=secret)
    else:
        api = FacebookAdsApi.init(access_token=token)

    return api
Пример #11
0
def get_insights(insight_id=None,
                 timerange=None,
                 fields=None,
                 action_breakdown=False,
                 service=None):
    if service:
        FacebookAdsApi.init(service["app_id"], service["app_secret"],
                            service["access_token"])

    if not timerange:
        today = datetime.datetime.now()
        timerange = {
            "since": (today - datetime.timedelta(days=7)).strftime("%Y-%m-%d"),
            "until": today.strftime("%Y-%m-%d")
        }
    if not fields:
        fields = ("call_to_action_clicks,canvas_avg_view_percent," +
                  "impressions,social_clicks,website_clicks,ctr").split(",")

    params = {
        'time_range': timerange,
    }

    if action_breakdown:
        params['action_breakdown'] = 'action_type'
    else:
        params['time_increment'] = '1'
    cdata = None
    if insight_id.startswith("account/"):
        cdata = get_account_insights(insight_id[8:], fields, params)
    if insight_id.startswith("campaign/"):
        cdata = get_campaign_insights(insight_id[9:], fields, params)
    if insight_id.startswith("adset/"):
        cdata = get_adset_insights(insight_id[6:], fields, params)
    if insight_id.startswith("ad/"):
        cdata = get_ad_insights(insight_id[3:], fields, params)

    if not cdata:
        return {}

    data = None
    if action_breakdown:
        data = {}
        dt = cdata[0]
        for f in fields:
            name = ID_TO_NAME.get(f, f)
            data[name] = dt[f]
    else:
        data = []
        for f in fields:
            v = []
            for cd in cdata:
                date = cd["date_start"]
                v.append([date, cd[f]])
            name = ID_TO_NAME.get(f, f)
            data.append({'name': name, 'values': v})

    return data
Пример #12
0
def api_boot(credentials):
    """Function initializing the API connection to Facebook Ads API."""

    application_id = credentials['facebook_ads']['app_id']
    secret = credentials['facebook_ads']['app_secret']
    token = credentials['facebook_ads']['access_token']

    FacebookAdsApi.init(application_id, secret, token)
    print("Facebook Ads API connection successfully initialized.")
Пример #13
0
def download_data():
    """Initializes the FacebookAdsAPI, retrieves the ad accounts and downloads the data"""
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    FacebookAdsApi.init(config.app_id(), config.app_secret(),
                        config.access_token())
    ad_accounts = _get_ad_accounts()
    download_data_sets(ad_accounts)
Пример #14
0
def get_ad_account():

    if secret != '-':
        FacebookAdsApi.init(access_token=token,
                            app_secret=secret,
                            api_version='v4.0')
    else:
        FacebookAdsApi.init(access_token=token, api_version='v4.0')
    account = AdAccount('act_' + act_id)
    return account
Пример #15
0
def facebook_get_service(config):
    '''
    Connects to Facebook Ads platform
    '''
    session = FacebookSession(config['app_id'], config['app_secret'],
                              config['access_token'])
    api = FacebookAdsApi(session)
    FacebookAdsApi.set_default_api(api)
    FacebookAdsApi.init(config['app_id'], config['app_secret'],
                        config['access_token'])
Пример #16
0
    def getfacebookApi(self):
        if self.secret != '-':
            self.api = FacebookAdsApi.init(access_token=self.token,
                                           app_secret=self.secret,
                                           api_version='v3.2')
        else:
            self.api = FacebookAdsApi.init(access_token=self.token,
                                           api_version='v3.2')

        self.account = AdAccount('act_' + act_id)
Пример #17
0
    def _deco(*args, **kwargs):
        access_token = None
        try:
            body = json.loads(args[3].decode())
            access_token = body.get('access_token')
        except Exception as ex:
            access_token = conf.facebook.access_token

        finally:
            FacebookAdsApi.init(conf.facebook.app_id, conf.facebook.app_secret, access_token)
            func(*args, **kwargs)
Пример #18
0
    def init(cls, app_id=None, app_secret=None, access_token=None,
             account_id=None, api_version=None, pool_maxsize=10, max_retries=0):
        # connection pool size is +1 because there also is the main thread that can also issue a request
        session = FacebookSession(app_id, app_secret, access_token,
                                  pool_maxsize+1, max_retries)
        api = cls(session, api_version=api_version, threadpool_size=pool_maxsize)
        cls.set_default_api(api)
        # TODO: how to avoid this hack?
        FacebookAdsApi.set_default_api(api)

        if account_id:
            cls.set_default_account_id(account_id)
Пример #19
0
def insights(start, end):
    response = {}
    try:
        my_session = FacebookSession(my_app_id, my_app_secret, my_access_token)
        my_api = FacebookAdsApi(my_session)
        FacebookAdsApi.set_default_api(my_api)
        me = objects.AdUser(fbid='me')
        my_accounts = list(me.get_ad_accounts())
        my_account = my_accounts[0]
        fields = [
            AdsInsights.Field.clicks, AdsInsights.Field.spend,
            AdsInsights.Field.impressions, AdsInsights.Field.unique_clicks,
            AdsInsights.Field.cost_per_unique_click,
            AdsInsights.Field.cost_per_inline_link_click
        ]

        params = {
            'time_range': {
                'since': start,
                'until': end
            },
        }
        temp = my_account.get_insights(params=params, fields=fields)

        try:
            cost_per_click = float(temp[0]['spend']) / float(temp[0]['clicks'])
        except:
            cost_per_click = 0

        response = [{
            'field': 'Impressions',
            'value': temp[0]['impressions']
        }, {
            'field': 'Cost',
            'value': temp[0]['spend']
        }, {
            'field': 'Clicks',
            'value': temp[0]['clicks']
        }, {
            'field': 'Unique Clicks',
            'value': temp[0]['unique_clicks']
        }, {
            'field': 'Cost per unique click',
            'value': temp[0]['cost_per_unique_click']
        }, {
            'field': 'Cost per Click',
            'value': cost_per_click
        }]
    except:
        pass

    return response
Пример #20
0
def index(request):
    #Initialize a new Session and instanciate an Api object
    my_app_id = '1672585882991034'
    my_app_secret = '38c9b5fba3cf14297b1da57832c45057'
    my_access_token = 'CAAXxNT9peboBAG7SNVFXKOm8NillZAQxQLWXIf2N1PZArEpKZCpMTYZCZAGLZBYq0Gdzq7E1l90I7GlIBN2lLpON37JZBzwuADu7iJk7QByBYyeHAsUr62TTiS9wOBkd9JezaZCZCZB6MnSizo5VftYYVnt5rjQ1gDmTgALKIoPxPZC560jJij88hsvXFu64xaiDjnWTFWqSZAiIPwZDZD' 
    FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)

    #Add after FacebookAdsApi.init
    me = AdUser(fbid='me')
    my_account = me.get_ad_accounts()[0]
    print my_account

    return HttpResponse('Hello from Python!')
Пример #21
0
def crawlDemographics(output_file_path, sleep_time):
    country = 'US'
    destination_file_path = '%s%s/' % (output_file_path, country)

    verifyDir(destination_file_path)
    print destination_file_path

    log_file = open('%slog_all.txt' % (destination_file_path), 'w')
    exception_log_file = open(
        '%sexception_log_all.txt' % (destination_file_path), 'w')

    if secret != '-':
        FacebookAdsApi.init(access_token=token,
                            app_secret=secret,
                            api_version='v3.1')
    else:
        FacebookAdsApi.init(access_token=token, api_version='v3.1')
    account = AdAccount('act_' + act_id)

    count_total_requests = 0
    count_interest_ids = 0
    count_exceptions = 0
    count_sequenced_exceptions = 0

    cur_time = getCurrentTime()
    log_file.write('Execution initialized: %s \n' % cur_time)
    count_interest_ids += 1

    #first element of the following list indicates to the crawler to collect the demographics for the US only whereas second and third one are
    # the interests related to the new york times and washington post, respectively.
    list_of_interests = ['all_%s' % cur_time, '6003058819532', '6003096798132']
    for interest_id in list_of_interests:
        #         interest_id =  'all_%s' % cur_time
        #         crawlInterest(interest_id, destination_file_path, account, log_file, exception_log_file, sleep_time)
        count_total_requests, count_sequenced_exceptions, count_exceptions = crawlInterest(
            interest_id, destination_file_path, account, log_file,
            exception_log_file, count_total_requests,
            count_sequenced_exceptions, count_exceptions, sleep_time)
        if count_sequenced_exceptions == MAXIMUM_EXCEPTIONS:
            log_file.write('******** Sequenced exceptions == %d **********\n' %
                           MAXIMUM_EXCEPTIONS)
            log_file.write('******** Going to terminate **********\n')
            break

    log_file.write('total of interest ids: %d \n' % count_interest_ids)
    log_file.write('total of requests: %d \n' % count_total_requests)
    log_file.write('total of exceptions: %d \n' % count_exceptions)
    log_file.write('Execution finalized: %s \n' % getCurrentTime())

    # # safe exit
    log_file.close()
Пример #22
0
        def request_new_fb_pixel():
            from facebookads.api import FacebookAdsApi
            from facebookads.objects import AdsPixel, AdUser

            FacebookAdsApi.init(
                app.config['FB_MY_APP_ID'],
                app.config['FB_MY_APP_SECRET'],
                app.config['FB_MY_ACCESS_TOKEN']
            )

            me = AdUser(fbid='me')
            account = me.get_ad_accounts()[0]
            pixel = account.get_ads_pixels([AdsPixel.Field.code])
            return pixel.get_id(), pixel['code'].decode("utf-8")
Пример #23
0
def download_data():
    """Initializes the FacebookAdsAPI, retrieves the ad accounts and downloads the data"""
    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    FacebookAdsApi.init(config.app_id(),
                        config.app_secret(),
                        config.access_token())
    ad_accounts = _get_ad_accounts()
    target_accounts = list(filter(None, config.target_accounts().split(',')))
    if len(target_accounts) > 0:
        logging.info('the app can see %s accounts but the configuration specified only %s target accounts: %s', len(ad_accounts), len(target_accounts), ', '.join(target_accounts))
        ad_accounts = [ad_account for ad_account in ad_accounts if ad_account['account_id'] in config.target_accounts()]
        logging.info('after filtering %s accounts will be downloaded: %s', len(target_accounts), ', '.join(target_accounts))
    download_data_sets(ad_accounts)
Пример #24
0
def webhook(request):
    print(request.method)
    print(request.GET)
    print(request.POST)
    print(request.body)

    challenge = request.GET.get("hub.challenge", "")
    token = request.GET.get("hub.verify_token", "")
    mode = request.GET.get('hub.mode', "")
    msg = 'you are an error!'
    if token == 'abc1234':
        return HttpResponse(challenge)

    leadgen_id = '0007'
    page = None
    try:
        body_unicode = request.body.decode('utf-8')
        body = json.loads(body_unicode)
        entry = body['entry'][0]['changes'][0]['value']

        ad_id = entry['ad_id']
        form_id = entry['form_id']
        leadgen_id = entry['leadgen_id']
        created_time = entry['created_time']
        page_id = entry['page_id']
        adgroup_id = entry['adgroup_id']

        # TODO FB recognize LeadGen
        my_app_id = settings.FB_APP_ID
        my_app_secret = settings.FB_APP_SECRET
        my_access_token = settings.FB_APP_ACCESS_TOKEN

        FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
        fields = []
        params = {}

        page = models.Page.objects.get(page_id=page_id)
        fb_lead = Lead(leadgen_id).api_get(
            fields=fields,
            params=params,
        )
        lead = models.Lead.create_from_fb_lead(fb_lead, page)
        msg = 'lead saved!'
    except Exception as e:
        models.Lead.objects.create(leadgen_id=leadgen_id, page=page)
        print('%s (%s)' % (str(e), type(e)))

        msg = 'lead did not saved :('

    return HttpResponse(msg)
Пример #25
0
        def request_new_fb_pixel():
            from facebookads.api import FacebookAdsApi
            from facebookads.objects import AdsPixel, AdUser

            FacebookAdsApi.init(
                app.config['FB_MY_APP_ID'],
                app.config['FB_MY_APP_SECRET'],
                app.config['FB_MY_ACCESS_TOKEN']
            )

            me = AdUser(fbid='me')
            account = me.get_ad_accounts()[0]
            pixel = account.get_ads_pixels([AdsPixel.Field.code])
            return pixel.get_id(), pixel['code'].decode("utf-8")
Пример #26
0
def get_fb_data(AccountId):
    FacebookAdsApi.init(facebookConfig.Configs['App_id'],
                        facebookConfig.Configs['App_secret'],
                        facebookConfig.Configs['Access_token'])

    my_account = AdAccount(facebookConfig.Accounts[AccountId])

    # Grab insight info for all ads in the adaccount

    #Ever this function will get data from yesterday
    #If somebody wants to change the range of date, is necessary to change the param 'date_preset'
    #You can change the level of your request. example: ad, adset or campaign
    '''
    I dont recommend change the param date_preset because the data comes cumulative, not good for me.
    The data from yesterday is better and trustworthy . I suggest to compare with reports from your Business manager facebook
    '''
    data = my_account.get_insights(
        params={
            'date_preset': 'yesterday',
            'level': 'ad'
        },
        fields=[
            AdsInsights.Field.account_id,
            AdsInsights.Field.account_name,
            #AdsInsights.Field.campaign_id,
            AdsInsights.Field.campaign_name,
            AdsInsights.Field.ad_name,
            AdsInsights.Field.ad_id,
            AdsInsights.Field.adset_id,
            AdsInsights.Field.adset_name,
            AdsInsights.Field.cost_per_outbound_click,
            AdsInsights.Field.outbound_clicks,
            AdsInsights.Field.spend,
            AdsInsights.Field.clicks,
            AdsInsights.Field.inline_link_clicks,
            AdsInsights.Field.inline_link_click_ctr,
            AdsInsights.Field.cpm,
            AdsInsights.Field.ctr,
            AdsInsights.Field.reach,
            AdsInsights.Field.frequency,
            AdsInsights.Field.impressions
        ])

    dataNormalize = normalize.dumps_data(data)

    df = normalize.change_types(dataNormalize)

    return df
    def search(cls, params=None, api=None):
        api = api or FacebookAdsApi.get_default_api()
        if not api:
            raise FacebookBadObjectError(
                "An Api instance must be provided as an argument or set as "
                "the default Api in FacebookAdsApi.", )

        params = {} if not params else params.copy()
        response = api.call(
            FacebookAdsApi.HTTP_METHOD_GET,
            "/".join(
                (FacebookSession.GRAPH, FacebookAdsApi.API_VERSION, 'search')),
            params,
        ).json()

        ret_val = []
        if response:
            keys = response['data']
            # The response object can be either a dictionary of dictionaries
            # or a dictionary of lists.
            if isinstance(keys, list):
                for item in keys:
                    search_obj = TargetingSearch()
                    search_obj.update(item)
                    ret_val.append(search_obj)
            elif isinstance(keys, dict):
                for item in keys:
                    search_obj = TargetingSearch()
                    search_obj.update(keys[item])
                    if keys[item]:
                        ret_val.append(search_obj)
        return ret_val
Пример #28
0
def create_video(request):
    FacebookAdsApi.init(account_id=settings.FACEBOOK_MAIN_AD_ACCOUNT,
                        access_token=settings.FACEBOOK_TEST_TOKEN)
    ad_video = AdAccount(
        fbid=settings.FACEBOOK_MAIN_AD_ACCOUNT
    ).create_ad_video(
        params={
            AdVideo.Field.slideshow_spec: {
                'images_urls': [
                    'https://www.downtownrochestermn.com/_files/images/sbs15tkssblue[1].png',
                    'http://d3sdoylwcs36el.cloudfront.net/VEN-virtual-enterprise-network-business-opportunities-small-fish_id799929_size485.jpg',
                    'https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQmvDxaUoi9wsAm2H0qvdaCn8ISnkqOPSBDojx7WznZLoAMhvW_mjI7Pw'
                ]
            }
        })
    return JsonResponse(ad_video.export_all_data(), safe=False)
Пример #29
0
 def test_fb(self):
     try:
         config_file = open('./autogen_docs_config.json')
     except IOError:
         print("No config file found, skipping docs tests")
         exit()
     config = json.load(config_file)
     my_app_id = config['app_id']
     my_app_secret = config['app_secret']
     my_access_token = config['access_token']
     FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
     self.assertIsNotNone(FacebookAdsApi.API_VERSION)
     me = objects.AdUser(fbid='me')
     my_accounts = list(me.get_ad_accounts())
     self.assertGreater(len(my_accounts), 0, '账号数大于0个')
     config_file.close()
Пример #30
0
def get_fb_accounts(request):	
	FacebookAccount.objects.all().delete()
	try:
		fb_acc = SocialAccount.objects.get(user_id = request.user.id,provider='facebook')
		fb_tok = SocialToken.objects.get(account=fb_acc)
	except:
		return HttpResponse("error connecting Social Accounts")
	
	#setting the user information
	my_app_id = '1604519246476149'
	my_app_secret = '5a93aee73f1d2856dd542f53e268e483'
	my_access_token = fb_tok.token
	
	#gets the ad accounts in a single, pre-existing facebook account
	FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
	me = objects.AdUser(fbid='me')
	my_accounts = list(me.get_ad_accounts())

	#does it have ad accounts
	if len(my_accounts) == 0:
		return HttpResponse("no Ad Accounts Exist")
	
	#important note, facebook allows us to only check upto 25
	#accounts, we did the privacy note now just need to check if we can
	#increase the amount
	index = 0
	
	for current_account in my_accounts:
		if index == 25:
			break
		
		index = index + 1
		
		fields=[
			AdAccount.Field.account_id,
			AdAccount.Field.name
			]
		
		current_account.remote_read(fields=fields)
		if AdAccount.Field.name == "":
			pass
		account_model = FacebookAccount()
		account_model.account_name = str(current_account[AdAccount.Field.name])
		account_model.account_id = str(current_account[AdAccount.Field.account_id])
		#account_model.report = report_model
		if not account_model.account_name == "":
			account_model.save()
Пример #31
0
def auth(access_token=None):
    if sys.__stdin__.isatty():
        access_token = access_token or config['access_token']
        FacebookAdsApi.init(
            config['app_id'],
            config['app_secret'],
            access_token
        )
    else:
        raise FacebookError(
            "\n\n"
            "## (/ o_o)/ ~  _|___|_ \n"
            "## bootstrap.auth() should only be used in Python's interactive "
            "shell. Try: python -i facebookads/bootstrap.py\n"
            "## Or try using FacebookAdsApi.init()"
            "\n"
        )
Пример #32
0
def get_fb_accounts(request):
    FacebookAccount.objects.all().delete()
    try:
        fb_acc = SocialAccount.objects.get(user_id=request.user.id,
                                           provider='facebook')
        fb_tok = SocialToken.objects.get(account=fb_acc)
    except:
        return HttpResponse("error connecting Social Accounts")

    #setting the user information
    my_app_id = ''
    my_app_secret = ''
    my_access_token = fb_tok.token

    #gets the ad accounts in a single, pre-existing facebook account
    FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
    me = objects.AdUser(fbid='me')
    my_accounts = list(me.get_ad_accounts())

    #does it have ad accounts
    if len(my_accounts) == 0:
        return HttpResponse("no Ad Accounts Exist")

    #important note, facebook allows us to only check upto 25
    #accounts, we did the privacy note now just need to check if we can
    #increase the amount
    index = 0

    for current_account in my_accounts:
        if index == 25:
            break

        index = index + 1

        fields = [AdAccount.Field.account_id, AdAccount.Field.name]

        current_account.remote_read(fields=fields)
        if AdAccount.Field.name == "":
            pass
        account_model = FacebookAccount()
        account_model.account_name = str(current_account[AdAccount.Field.name])
        account_model.account_id = str(
            current_account[AdAccount.Field.account_id])
        #account_model.report = report_model
        if not account_model.account_name == "":
            account_model.save()
Пример #33
0
def auth(access_token=None):
    if sys.__stdin__.isatty():
        access_token = access_token or config['access_token']
        FacebookAdsApi.init(
            config['app_id'],
            config['app_secret'],
            access_token,
            config['act_id'],
        )
    else:
        raise FacebookError(
            "\n\n"
            "## (/ o_o)/ ~  _|___|_ \n"
            "## bootstrap.auth() should only be used in Python's interactive "
            "shell. Try: python -i facebookads/bootstrap.py\n"
            "## Or try using FacebookAdsApi.init()"
            "\n")
Пример #34
0
def hello_world(formId):
    # Facebook app keys
    my_app_id = '<YOUR_FB_APP_ID>'
    my_app_secret = '<YOUR_FB_APP_SECRET>'
    my_access_token = '<YOUR_FB_APP_ACCESS_TOKEN>'

    FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)

    if formId != None:
        form = LeadgenForm(formId)
        leads = form.get_leads()
        email = leads[0]['field_data'][0]['values'][0]
        name = leads[0]['field_data'][1]['values'][0]

        result = add_list_member(email,name);
        return 'Hello,formId:  {0}, {1}!'.format(formId,result)
    return 'hello Fb world'
Пример #35
0
    def setUp(self):
        fbads_session = FacebookSession(
            settings.SAMPLE_TEST['APP_ID'],
            settings.SAMPLE_TEST['APP_SECRET'],
            settings.SAMPLE_TEST['TOKEN'],
        )
        fbads_api = FacebookAdsApi(fbads_session)
        FacebookAdsApi.set_default_api(fbads_api)
        self.account_id = settings.SAMPLE_TEST['ACCOUNT_ID']
        self.page_id = settings.SAMPLE_TEST['PAGE_ID']
        self.form_id = '436706799859690'  # For Lead Ads
        image_files = [
            "adimage0.png", "adimage1.jpg", "adimage2.jpg", "adimage3.jpg"
        ]

        self.images = map(
            lambda image_path: os.path.abspath(
                os.path.join(os.path.dirname(__file__), image_path)),
            image_files)
        self.app_info = {
            "app_name": "DiDiAds",
            "appstore_link":
            "https://play.google.com/store/apps/details?id=com.facebook.se.apac.example.liyuhk.didiadsa",
            "app_deep_link": "example://detail/1234",
            "fbapplication_id": "743337925789686",
            "fbpage_id": "1426815194312958",
            "fboffsitepixel_id": "null"
        }
        self.basic_targeting = {
            "geo_locations": {
                "countries": ["US"]
            },
        }

        self.mobile_targeting = {
            "geo_locations": {
                "countries": ["US"]
            },
            "user_os": ["Android"],
            "device_platforms": ["mobile"],
            "publisher_platforms": ["facebook"],
            "facebook_positions": ["feed"],
        }
        # Base custom audience id that can be used for creating LALs etc.
        self.ca_id = "6034234313285"
Пример #36
0
def facebookMain(fbCred, emails_list):
    act_id = fbCred['fb_user_id']
    user_access_token = fbCred['user_token']
    # user_access_token = 'CAAHsB1lutXABADNT3ppqATXZBdUwlfgEViIVlaHl5A14CpZBzoCvWi3qycaVdZAtLPnVFH5QY7EKY1UWYuYzvJptzrFaNcE8OXIOOYVo1hX33h8Ml2M9n5yyd7UJ3PHwOtixi6VgJNJY7sZAYY6b4CwqwCwZAjXir8aKAzmu6GMWZAutDKdSQ482SnawqJRIA7XVgR3K7HGIx1ZA4rOEFra'
    # Login
    FacebookAdsApi.init(my_app_id, my_app_secret, user_access_token)
    ad_account = AdAccount(act_id)

    ### use this to login as yourself (if loged in on this computer)
    # me = AdUser(fbid='me')
    # my_account = me.get_ad_accounts()[0]

    # Push emails to 3Targeting default list
    audiences_list = getCustomAudiences(ad_account)
    my_audiences = findAudienceByName(AUDIENCE_DEFAULT_NAME, audiences_list)
    if my_audiences:
        retVal = LoadCustomAudience(my_audiences[0], f=emails_list, datatype='email')
    else:
        retVal = CreateCustomAudience(ad_account, AUDIENCE_DEFAULT_NAME, description=AUDIENCE_DEFAULT_DESCRIPTION, f=emails_list, datatype='email')
    return retVal
 def get_by_ids(cls, ids, params=None, fields=None, api=None):
     api = api or FacebookAdsApi.get_default_api()
     params = dict(params or {})
     cls._assign_fields_to_params(fields, params)
     params["ids"] = ",".join(map(str, ids))
     response = api.call("GET", ["/"], params=params)
     result = []
     for fbid, data in response.json().items():
         obj = cls(fbid, api=api)
         obj._set_data(data)
         result.append(obj)
     return result
 def generate_record(self):
     my_app_id = '881513028613192'
     my_app_secret = '4252ecaa9b6b11ed5d72ddb8fc2528db'
     my_access_token = 'CAAMhuz7vdEgBAPSuWuBSoCjsV0P45Y3KrqU7y5blqHVyM3XshUN9Dr3ZBNJWZCGJljogD6ZC2XSbqXT4D7I6PVH7isy4EBDqb1U3lB005yIM65ov4fCYUKz3J42kxMfwZBpVZABqBM5vOjZApE6ZC9PvOkRnc7mwZBMFZBnVXBiy37LgJJP2RQrZACpTac2s9INasZD'
     FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
     
     campaign = Campaign('6029907036952')
     campaign.remote_read(fields=[
         Campaign.Field.name,
         Campaign.Field.effective_status,
         Campaign.Field.objective,
     ])
     params = {
         'date_preset': 'last_30_days',
     }
     insights = campaign.get_insights(params=params)
     
     self.write({'name': campaign['name']})
     self.write({'result': insights[0]['actions'][0]['value']})
     self.write({'reach': insights[0]['reach']})
     self.write({'cost': insights[0]['cost_per_total_action']})
     self.write({'amount_spent': insights[0]['spend']})
Пример #39
0
    def auth(cls):
        """
            Prepare for Ads API calls and return a tuple with act_id
            and page_id. page_id can be None but act_id is always set.
        """
        config = cls.load_config()

        if cls._is_authenticated:
            return config['act_id'], config.get('page_id', None)

        if config['app_id'] and config['app_secret'] \
           and config['act_id'] and config['access_token']:

            FacebookAdsApi.init(
                config['app_id'],
                config['app_secret'],
                config['access_token'],
                config['act_id'],
            )

            cls._is_authenticated = True

            return config['act_id'], config.get('page_id', None)

        else:
            required_fields = set(
                ('app_id', 'app_secret', 'act_id', 'access_token')
            )

            missing_fields = required_fields - set(config.keys())
            raise FacebookError(
                '\n\tFile config.json needs to have the following fields: {}\n'
                '\tMissing fields: {}\n'.format(
                    ', '.join(required_fields),
                    ', '.join(missing_fields),
                )
            )
    def __init__(self, fbid=None, parent_id=None, api=None):
        """Initializes a CRUD object.
        Args:
            fbid (optional): The id of the object ont the Graph.
            parent_id (optional): The id of the object's parent.
            api (optional): An api object which all calls will go through. If
                an api object is not specified, api calls will revert to going
                through the default api.
        """
        super(AbstractCrudObject, self).__init__()

        self._api = api or FacebookAdsApi.get_default_api()
        self._changes = {}
        self._parent_id = parent_id
        self._data['id'] = fbid
        self._include_summary = True
    def __init__(self, fbid=None, parent_id=None, api=None):
        """Initializes a CRUD object.
        Args:
            fbid (optional): The id of the object ont the Graph.
            parent_id (optional): The id of the object's parent.
            api (optional): An api object which all calls will go through. If
                an api object is not specified, api calls will revert to going
                through the default api.
        """
        super(AbstractCrudObject, self).__init__()

        self._api = api or FacebookAdsApi.get_default_api()
        self._changes = {}
        if (parent_id is not None):
            warning_message = "parent_id as a parameter of constructor is " \
                  "being deprecated."
            logging.warning(warning_message)
        self._parent_id = parent_id
        self._data['id'] = fbid
        self._include_summary = True
Пример #42
0
    def remote_create_from_zip(cls, filename, parent_id, api=None):
        api = api or FacebookAdsApi.get_default_api()
        open_file = open(filename, 'rb')
        response = api.call(
            'POST',
            (parent_id, cls.get_endpoint()),
            files={filename: open_file},
        )
        open_file.close()

        data = response.json()

        objs = []
        for image_filename in data['images']:
            image = cls(parent_id=parent_id)
            image.update(data['images'][image_filename])
            image[cls.Field.id] = '%s:%s' % (
                parent_id[4:],
                data['images'][image_filename][cls.Field.hash],
            )
            objs.append(image)

        return objs
    def search(cls, params=None, api=None):
        api = api or FacebookAdsApi.get_default_api()
        if not api:
            raise FacebookBadObjectError(
                "An Api instance must be provided as an argument or set as "
                "the default Api in FacebookAdsApi.",
            )

        params = {} if not params else params.copy()
        response = api.call(
            FacebookAdsApi.HTTP_METHOD_GET,
            "/".join((
                FacebookSession.GRAPH,
                FacebookAdsApi.API_VERSION,
                'search'
            )),
            params,
        ).json()

        ret_val = []
        if response:
            keys = response['data']
            # The response object can be either a dictionary of dictionaries
            # or a dictionary of lists.
            if isinstance(keys, list):
                for item in keys:
                    search_obj = TargetingSearch()
                    search_obj.update(item)
                    ret_val.append(search_obj)
            elif isinstance(keys, dict):
                for item in keys:
                    search_obj = TargetingSearch()
                    search_obj.update(keys[item])
                    if keys[item]:
                        ret_val.append(search_obj)
        return ret_val
Пример #44
0
repo_dir = os.path.join(this_dir, os.pardir)
sys.path.insert(1, repo_dir)

from facebookads.objects import AdAccount, AsyncJob
from facebookads.api import FacebookAdsApi
import time
import os
import json

this_dir = os.path.dirname(__file__)
config_filename = os.path.join(this_dir, 'config.json')
config_file = open(config_filename)
config = json.load(config_file)
config_file.close()

api = FacebookAdsApi.init(access_token=config['access_token'])
account_id = config['act_id']

account = AdAccount(account_id)

# Both Insights and Reportstats
i_async_job = account.get_insights(params={'level': 'ad'}, async=True)

# Insights
while True:
    job = i_async_job.remote_read()
    print("Percent done: " + str(job[AsyncJob.Field.async_percent_completion]))
    time.sleep(1)
    if job:
        # print "Done!"
        break
from __future__ import print_function
from __future__ import unicode_literals
from facebookads.objects import TargetingSearch
from facebookads.api import FacebookAdsApi
from facebookads.exceptions import *

config_file = open('./examples/docs/config.json')
config = json.load(config_file)
config_file.close()

ad_account_id = config['account_id']
access_token = config['access_token']
app_id = config['app_id']
app_secret = config['app_secret']

FacebookAdsApi.init(app_id, app_secret, access_token)

# _DOC open [SEARCH_GEOLOCATION_WITH_COUNTRY]
from facebookads.objects import TargetingSearch
params = {
    'q': 'un',
    'type': 'adgeolocation',
    'location_types': ['country'],
}

resp = TargetingSearch.search(params=params)
print(resp)
# _DOC close [SEARCH_GEOLOCATION_WITH_COUNTRY]

# _DOC open [SEARCH_GEOLOCATION_WITH_REGION]
from facebookads.objects import TargetingSearch
Пример #46
0
def month_fb_data(request, account_model):

	try:
		fb_acc = SocialAccount.objects.get(user_id = request.user.id,provider='facebook')
		fb_tok = SocialToken.objects.get(account=fb_acc)
	except:
		return HttpResponse("error connecting Social Accounts")
	
	#setting the user information
	my_app_id = '1604519246476149'
	my_app_secret = '5a93aee73f1d2856dd542f53e268e483'
	my_access_token = fb_tok.token
	
	#gets the ad accounts in a single, pre-existing facebook account
	FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
	me = objects.AdUser(fbid='me')
	my_accounts = list(me.get_ad_accounts())

	#does it have ad accounts
	if len(my_accounts) == 0:
		return HttpResponse("no Ad Accounts Exist")
	
	#important note, facebook allows us to only check upto 25
	#accounts, we did the privacy note now just need to check if we can
	#increase the amount
	index = 0
	
	for current_account in my_accounts:
		if index == 25:
			break
		
		index = index + 1
		
		fields=[
			AdAccount.Field.account_id,
			AdAccount.Field.name
			]
		
		current_account.remote_read(fields=fields)
		
		if account_model.account_name == str(current_account[AdAccount.Field.name]):
			break
		
	ad_campaigns = current_account.get_ad_campaigns()
				
	for current_campaign in ad_campaigns:
		
		fields=[
			AdCampaign.Field.name,
    		AdCampaign.Field.status,
    		AdCampaign.Field.id]
				
		params = {
			'date_preset': 'last_30_days'
		}	
		
		try:
			current_campaign.remote_read(fields=fields, params=params)
		except:
			pass
			
		fields = {    			
    		'impressions',
    		'clicks',
		'spend'
    	}
		try:
			data = str(current_campaign.get_insights(fields=fields,params=params))
		except:
			pass
		data = '['+data[12:]
		try:
			ast.literal_eval(data)
			json_string = json.dumps(data)
			parsed_data = json.loads(data)				
		except:
			continue
			
		campaign_model = FacebookCampaign()
		campaign_model.name = str(current_campaign[AdCampaign.Field.name])
		campaign_model.campaign_id = str(current_campaign[AdCampaign.Field.id])
		campaign_model.status = str(current_campaign[AdCampaign.Field.status])
		campaign_model.clicks = int(parsed_data[0]['clicks'])
		campaign_model.impressions = int(parsed_data[0]['impressions'])
		campaign_model.cost = float(parsed_data[0]['spend'])
		if not campaign_model.impressions == 0:
			campaign_model.CTR = round(campaign_model.clicks * 100/campaign_model.impressions,2)
			campaign_model.CPM = round(campaign_model.cost * 1000 / campaign_model.impressions,2)
		if not campaign_model.clicks == 0:
			campaign_model.CPC = round(campaign_model.cost/campaign_model.clicks,2)
		campaign_model.account = account_model
		campaign_model.save()	
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

from facebookads import test_config

page_id = test_config.page_id

# _DOC oncall [pruno]
# _DOC open [PAGE_GET_LOCATIONS]
# _DOC vars [page_id]
from facebookads.api import FacebookAdsApi

response = FacebookAdsApi.get_default_api().call(
    'GET',
    ('/{}/locations'.format(page_id),),
    {
        'fields': 'location',
    }).json()

for location in response['data']:
    print("{},{}\n".format(
        location['location']['latitude'],
        location['location']['longitude'],
    ))
# _DOC close [PAGE_GET_LOCATIONS]
 def get_parent_id(self):
     """Returns the object's parent's id."""
     return self._parent_id or FacebookAdsApi.get_default_account_id()
# of this software is subject to the Facebook Developer Principles and
# Policies [http://developers.facebook.com/policy/]. This copyright notice
# shall be included in all copies or substantial portions of the software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

from facebookads import test_config

page_id = test_config.page_id

# _DOC oncall [pruno]
# _DOC open [PAGE_CHECK_LOCATIONS]
# _DOC vars [page_id]
from facebookads.api import FacebookAdsApi

response = FacebookAdsApi.get_default_api().call(
    'GET',
    ('/{}/locations'.format(page_id),),
    {
        'limit': 1,
    }).json()

has_locations = len(response['data']) > 0
# _DOC close [PAGE_CHECK_LOCATIONS]
Пример #50
0
this_dir = os.path.dirname(__file__)
config_filename = os.path.join(this_dir, os.pardir, os.pardir, 'config.json')

import sys
sys.path.insert(1, os.path.join(this_dir, os.pardir, os.pardir))

config_file = open(config_filename)
config = json.load(config_file)
config_file.close()

from facebookads.api import FacebookAdsApi
from facebookads.objects import ProductCatalog, Product

FacebookAdsApi.init(
    config['app_id'],
    config['app_secret'],
    config['access_token'],
)

if __name__ == '__main__':
    catalog_id = '<INSERT_YOUR_CATALOG_ID_HERE>'
    catalog = ProductCatalog(catalog_id)

    items = []
    for line in sys.stdin.readlines():
        if line.endswith('\n'):
            items.append(line[:-1].split(','))
        else:
            items.append(line.split(','))

    for item in items:
from facebookads.adobjects.user import User
from facebookads.adobjects.page import Page
from facebookads.adobjects.pagepost import PagePost
from facebookads.adobjects.adaccount import AdAccount
from facebookads.adobjects.campaign import Campaign
from facebookads.adobjects.adset import AdSet
from facebookads.adobjects.adcreative import AdCreative
from facebookads.adobjects.ad import Ad
from facebookads.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<ID>'
FacebookAdsApi.init(access_token=access_token)

# User get
fields = [
]
params = {
}
user = User(id).get(
  fields=fields,
  params=params,
)
print 'user', user
user_id = user.get_id()
print 'user_id:', user_id, '\n'

# Get page access token and page_id
# Policies [http://developers.facebook.com/policy/]. This copyright notice
# shall be included in all copies or substantial portions of the software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

from facebookads.adobjects.adset import AdSet
from facebookads.adobjects.adsinsights import AdsInsights
from facebookads.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<ID>'
FacebookAdsApi.init(access_token=access_token)

fields = [
  'impressions',
]
params = {
  'breakdown': 'publisher_platform',
}
print AdSet(id).get_insights(
  fields=fields,
  params=params,
)
from facebookads.api import FacebookAdsApi
from facebookads.objects import AdUser, Campaign, AdAccount, AdSet
from facebookads import FacebookSession, FacebookAdsApi, objects
import os

my_app_id = os.environ['APP_ID']
my_app_secret = os.environ['APP_SECRET']
my_access_token = 'CAAN4vFUE2ZAgBAHaZA6dmP6v4eIxOcV8TtA2crGjLG47ZCEllpjUSUlGFGDIFCX0KQrWBw8OGY9I7vi087ekgpaoldSyaya3HtIJgzC7oR2GQnpE8TfWi8uAB7LqtjMGqtgmvzFXZBTytZCkMDVm9WTC9vBqQZAuxVpj10yyQZC0WigZBaxvKfvG' #Your user access token
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)

"""
17
University of Louisville
id num: act_1006561952727232
18
Ruffino Canada
id num: act_999404050109689
19
Damp Rid
id num: act_946663412050420
20
Stoli Canada
id num: act_971018509614910
21
Beau tea Bar
id num: act_916124548437640
22
Pop Crush
id num: act_933960369987391
23
Ravage
Пример #54
0
def get_report(request):
	
	Campaign.objects.all().delete()
	Account.objects.all().delete()
	
	#check if user is authenticated
	if not request.user.is_authenticated():
		return render(request, 'account/login.html')	

	#setting the user information
	my_app_id = '1604519246476149'
	my_app_secret = '5a93aee73f1d2856dd542f53e268e483'
	current_user = SocialAccount.objects.get(user=request.user, provider='facebook')
	current_token = SocialToken.objects.get(account=current_user)
	my_access_token = current_token.token
  
	FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
	me = objects.AdUser(fbid='me')
	my_accounts = list(me.get_ad_accounts())
  
	if len(my_accounts) == 0:
		return HttpResponse("no Ad Accounts Exist")
	index = 0
  	
	for current_account in my_accounts:
		if index == 5:
			break
		index = index + 1
		
		current_account.remote_read(fields=[
				AdAccount.Field.account_id,
				AdAccount.Field.name,
				AdAccount.Field.amount_spent,
		])
		
		account_model = Account()
		account_model.account_name = str(current_account[AdAccount.Field.name])
		account_model.account_id = str(current_account[AdAccount.Field.account_id])
		account_model.account_cost = str(float(current_account[AdAccount.Field.amount_spent])/100)
		account_model.save()
		
		ad_campaigns = current_account.get_ad_campaigns()
				
		for current_campaign in ad_campaigns:
		
			current_campaign.remote_read(fields=[
			AdCampaign.Field.name,
    			AdCampaign.Field.status,
    			AdCampaign.Field.id,
    		])
			fields = {    			
    			'impressions',
    			'clicks',
    			'cpc'
    		}
			data = str(current_campaign.get_insights(fields=fields))
			data = '['+data[12:]
			try:
				ast.literal_eval(data)
				json_string = json.dumps(data)
				parsed_data = json.loads(data)				
			except:
				continue
			
			campaign_model = Campaign()
			campaign_model.name = str(current_campaign[AdCampaign.Field.name])
			campaign_model.campaign_id = str(current_campaign[AdCampaign.Field.id])
			campaign_model.status = str(current_campaign[AdCampaign.Field.status])
			campaign_model.clicks = int(parsed_data[0]['clicks'])
			campaign_model.cpc = float(parsed_data[0]['cpc'])
			campaign_model.impressions = int(parsed_data[0]['impressions'])
			campaign_model.account = account_model
			campaign_model.save()
	
	return HttpResponse("Good Humes")