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}
def get_accounts(self):
"""Retrieves and displays a list of all user's ad accounts."""
me = objects.AdUser(fbid="me")
my_accounts = list(me.get_ad_accounts(fields=[
'id',
'name',
'timezone_name',
'amount_spent',
'currency']))
return my_accounts
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
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()
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()
def main():
args = utils.parse_args(REQUIRED_CONFIG_KEYS)
start_date = args.config['start_date']
account_id = args.config['account_id']
access_token = args.config['access_token']
state = State(start_date, args.state)
FacebookAdsApi.init(access_token=access_token)
user = objects.AdUser(fbid='me')
accounts = user.get_ad_accounts()
account = None
for acc in accounts:
if acc['account_id'] == account_id:
account = acc
if not account:
raise Exception("Couldn't find account with id {}".format(account_id))
if args.discover:
do_discover()
elif args.properties:
do_sync(account, args.properties, state)
else:
LOGGER.info("No properties were selected")
class HotspotFacebookAds(object):
user = User.objects.get(username="******")
access_token = "EAAKijrdivowBADr6SJGcYKFfpnc8ZAHJEoYnMPnjJEAyZClbL0vZA62ZAt6MFoQ8ZBokTZCjmH6Xce6Qs9VVeKkFrLm8L6bemKRxtx9Ch0v9loFqNPPXSzrjpMr64LQFKXAPFwMLFTE1CmCTawCXZBK"
ads_api = FacebookAdsApi.init(settings.FACEBOOK_APP_ID,
settings.FACEBOOK_APP_SECRET, access_token)
me = objects.AdUser(fbid='me')
my_accounts = list(me.get_ad_accounts())
def get_total_ad_spending(self,
min_date=datetime.now() - timedelta(weeks=1),
max_date=datetime.now()):
ad_spending = 0
formatted_min_date = self.convert_date(min_date + timedelta(days=1))
formatted_max_date = self.convert_date(max_date)
for account in self.my_accounts:
account_obj = account.get_insights(
params={
"time_range": {
'since': formatted_min_date,
'until': formatted_max_date
}
})
if account_obj:
ad_spending = ad_spending + float(account_obj[0]['spend'])
return ad_spending
def get_emails_for_markets(self,
min_date=datetime.now() - timedelta(weeks=1),
max_date=datetime.now(),
market=None):
user_emails = get_all_new_users_in_markets_emails(min_date, max_date)
submitted_emails = get_new_submitted_emails(min_date, max_date)
print "User Emails: " + str(len(user_emails))
print "Submitted Emails: " + str(len(submitted_emails))
cash_payment_emails = []
all_emails = list(user_emails) + list(submitted_emails) + list(
cash_payment_emails)
return set(all_emails)
def get_users_for_markets(self,
min_date=datetime.now() - timedelta(weeks=1),
max_date=datetime.now(),
market=None):
all_users = get_all_new_users_in_markets(min_date, max_date)
print "Users: " + str(len(all_users))
return all_users
def cost_per_email(self,
min_date=datetime.now() - timedelta(weeks=1),
max_date=datetime.now()):
emails = self.get_emails_for_markets(min_date, max_date)
ad_spending = self.get_total_ad_spending(min_date, max_date)
cost_per_email = ad_spending / len(emails)
print "Spending: " + str(ad_spending)
print "Emails: " + str(len(emails))
print "Cost/Email: " + str(cost_per_email)
def cost_per_user(self,
min_date=datetime.now() - timedelta(weeks=1),
max_date=datetime.now()):
users = self.get_users_for_markets(min_date, max_date)
ad_spending = self.get_total_ad_spending(min_date, max_date)
cost_per_user = ad_spending / len(users)
print "Spending: " + str(ad_spending)
print "Users: " + str(len(users))
print "Cost/User: "******""
def get_last_ten_weeks_users(self):
for i in range(10):
current_date = datetime.now() - timedelta(weeks=i)
previous_date = datetime.now() - timedelta(weeks=i + 1)
self.cost_per_user(previous_date, current_date)
print ""
def convert_date(self, date):
return date.strftime("%Y-%m-%d")
def spent_on_event(self, event):
fields = ['campaign_name', 'campaign_id', 'spend']
params = {"date_preset": "lifetime"}
if event.facebook_campaign_id:
# my_account = objects.AdAccount('act_19596279')
campaign_id = event.facebook_campaign_id
campaign = Campaign(campaign_id)
insights = campaign.get_insights(fields=fields, params=params)
if len(insights) > 0:
return insights[0]['spend']
else:
return None
else:
return None
def update_campaign_ids(self):
fields = ['campaign_name', 'campaign_id', 'spend']
my_account = objects.AdAccount('act_19596279')
campaigns = my_account.get_campaigns()
facebook_event_ids = SponsoredEvent.objects.all().values_list(
'facebook_event_id', flat=True)
for campaign in campaigns:
c = campaign.get_insights(fields=fields)
name = c[0]['campaign_name']
print name
for fb_id in facebook_event_ids:
if fb_id in name:
event = SponsoredEvent.objects.get(facebook_event_id=fb_id)
event.facebook_campaign_id = c[0]['campaign_id']
event.save()
from facebookads.session import FacebookSession
from facebookads.api import FacebookAdsApi
from facebookads import objects
from facebookads.objects import AdUser, AdCampaign
import os
my_app_id = os.environ.get('FB_APP_ID')
my_app_secret = os.environ.get('FB_SECRET_KEY')
my_access_token = os.environ.get('FB_ACCESS_TOKEN')
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[1]
print(">>> Campaign Stats")
for campaign in my_account.get_ad_campaigns(fields=[AdCampaign.Field.name]):
for stat in campaign.get_stats(fields=[
'impressions',
'clicks',
'spent',
'unique_clicks',
'actions',
]):
print(campaign[campaign.Field.name])
for statfield in stat:
print("\t%s:\t\t%s" % (statfield, stat[statfield]))
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")
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 = ''
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 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()
