def view_ad(request):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adsets = my_account.get_ad_sets()
adset_id = []
for i in range(len(adsets)):
adset_id.append(adsets[i]["id"])
for adset in adset_id:
ad_set = AdSet(adset)
fields = [
Ad.Field.name,
Ad.Field.id,
]
ad_iter = ad_set.get_ads(fields=fields)
ad_data = []
for ad in ad_iter:
result = {}
result["id"] = ad[Ad.Field.id]
result["name"] = ad[Ad.Field.name]
ad_data.append(result)
context = {'ads': ad_data}
return render(request, 'fbapp/view_ad.html', context)
def create_ad_set(self, accountid, name, dailybudget, campaignid,
optimization_goal, billing_event, bid_amount, targeting,
appinfo):
"""
Step 3: create an ad set in campaign we just created. See
[Ad Set](https://developers.facebook.com/docs/marketing-api/adset)
for further details on the API used here.
"""
pdata = {
AdSet.Field.name: name,
AdSet.Field.optimization_goal: optimization_goal,
AdSet.Field.billing_event: billing_event,
AdSet.Field.bid_amount: bid_amount,
AdSet.Field.daily_budget: dailybudget,
AdSet.Field.campaign_id: campaignid,
AdSet.Field.promoted_object: {
'application_id': appinfo['fbapplication_id'],
'object_store_url': appinfo['appstore_link']
},
AdSet.Field.targeting: targeting,
}
pdata['status'] = AdSet.Status.paused
adset = AdSet(parent_id=accountid)
adset.remote_create(params=pdata)
return adset[AdSet.Field.id]
def create_adset(request, camid):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adset = AdSet(parent_id=my_account.get_id_assured())
adset[AdSet.Field.name] = 'Ad Set created by afnan -' + str(
random.randint(1, 10))
adset[AdSet.Field.promoted_object] = {
'application_id': app_id,
}
adset[AdSet.Field.campaign_id] = camid
adset[AdSet.Field.daily_budget] = 10000
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.impressions
adset[AdSet.Field.bid_amount] = 2
adset[AdSet.Field.status] = 'PAUSED'
adset[AdSet.Field.targeting] = {
Targeting.Field.geo_locations: {
'countries': ['US'],
},
Targeting.Field.publisher_platforms: ['facebook', 'audience_network'],
Targeting.Field.device_platforms: ['mobile'],
Targeting.Field.user_os: [
'IOS',
],
}
adset.remote_create()
result = {"id": adset.get_id()}
return redirect('view-adset')
def connect_audience(campaign_id, audience_id, device_cat):
adset = AdSet(fbid=audience_id, parent_id=f'act_{ad_account}')
params = {
AdSet.Field.name: 'A CPV Ad Set',
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.daily_budget: 500,
AdSet.Field.start_time: int(time.time()),
AdSet.Field.end_time: int(time.time() + 100000),
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.video_views,
AdSet.Field.billing_event: AdSet.BillingEvent.video_views,
AdSet.Field.bid_amount: 100,
AdSet.Field.targeting: {
"geo_locations": {
"countries": ["Ukraine"],
},
"age_min": 18,
"age_max": 65,
"custom_audiences": [{
"id": audience_id
}]
},
Targeting.Field.device_platforms: [device_cat],
}
adset.update(params=params)
return adset
def view_adset(request):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
my_account = AdAccount('act_' + user_id)
adsets = my_account.get_ad_sets()
adset_id = []
for i in range(len(adsets)):
adset_id.append(adsets[i]["id"])
adset_data = []
for id in adset_id:
adset = AdSet(fbid=id)
fields = [
AdSet.Field.name,
AdSet.Field.effective_status,
AdSet.Field.campaign_id,
AdSet.Field.status,
]
adset.remote_read(fields=fields)
result = {}
result["id"] = id
result["name"] = adset[AdSet.Field.name]
result["campid"] = adset[AdSet.Field.campaign_id]
result["status"] = adset[AdSet.Field.status]
result["data_1"] = "ACTIVE"
result["data_2"] = "PAUSED"
adset_data.append(result)
context = {'adsets': adset_data}
return render(request, 'fbapp/view_adset.html', context)
def get_insights_for_ad_set(self,
adset_id,
date_preset=Ad.DatePreset.lifetime,
limit=300):
"""
retrieve performance insight for each adset.
"""
params = {
'date_preset':
date_preset,
'action_attribution_windows': [
AdsInsights.ActionAttributionWindows.value_default,
AdsInsights.ActionAttributionWindows.value_1d_click,
AdsInsights.ActionAttributionWindows.value_7d_click
],
'level':
AdsInsights.Level.adset,
'limit':
limit
}
adset = AdSet(adset_id)
insights = adset.get_insights([
AdsInsights.Field.adset_name, AdsInsights.Field.adset_id,
AdsInsights.Field.cpc, AdsInsights.Field.cpm,
AdsInsights.Field.ctr, AdsInsights.Field.spend,
AdsInsights.Field.clicks, AdsInsights.Field.impressions,
AdsInsights.Field.reach, AdsInsights.Field.actions,
AdsInsights.Field.action_values
], params)
return insights
def update_interest(adset_id=None, adset_params=None):
adset = AdSet(adset_id)
update_response = adset.update(adset_params)
remote_update_response = adset.remote_update(params={
'status': 'PAUSED',
})
return
def create_ad_set(self, campaign_id, budget, targeting_query):
today = timezone.datetime.today()
start_time = str(today + timezone.timedelta(weeks=1))
end_time = str(today + timezone.timedelta(weeks=2))
targeting = self.generate_targeting_spec(targeting_query)
# print(targeting)
# new AdSet instance
adset = AdSet(parent_id=AD_ACCOUNT_ID)
adset.update({
AdSet.Field.name: 'My New Ad Set',
AdSet.Field.campaign_id: campaign_id,
AdSet.Field.daily_budget: budget,
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.reach,
AdSet.Field.bid_amount: 2,
AdSet.Field.targeting: targeting,
AdSet.Field.start_time: start_time,
AdSet.Field.end_time: end_time,
})
result = adset.remote_create(params={
'status': AdSet.Status.paused,
})
# print(result)
return result
def get_ad_id_list(adset_id):
ad_id_list = list()
adset = AdSet(adset_id)
ads = adset.get_ads(fields=[AdSet.Field.id])
for ad in ads:
ad_id_list.append(ad[Ad.Field.id])
return ad_id_list
def get_adset_insights(self, date_preset=None):
adset = AdSet(self.adset_id)
params = {
'date_preset': date_preset,
}
insights = adset.get_insights(params=params,
fields=list(general_insights.values()) +
list(target_insights.values()))
if bool(insights):
spend = insights[0].get(Field.spend)
impressions = insights[0].get(Field.impressions)
self.adset_insights.update({Field.spend: int(spend)})
self.adset_insights.update({Field.impressions: int(impressions)})
try:
insights[0].get(Field.actions)
for act in insights[0].get(Field.actions):
if act["action_type"] in conversion_metrics:
self.adset_insights.update({
conversion_metrics[act["action_type"]]:
int(act["value"])
})
self.adset_insights.update({
'cost_per_' + conversion_metrics[act["action_type"]]:
float(spend) / float(act["value"])
})
except:
pass
finally:
return self.adset_insights
def readInsightsForAdset(self,
adset_id,
params=None,
fields=all_adsinsights_fields):
# query all fields by default
ad_set = AdSet(fbid=adset_id)
return ad_set.get_insights(fields=fields, params=params)
def delete_adset(request, adid):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
adset = AdSet(adid)
adset.remote_delete()
return redirect('view-adset')
def update_adset(request, adsetid, status):
FacebookAdsApi.init(access_token=access_token,
app_id=app_id,
app_secret=app_secret)
adset = AdSet(adsetid)
adset[AdSet.Field.status] = status
adset.remote_update()
return redirect('view-adset')
def run_query_on_fb_adset_obj_conf(self, params, ad_object_id, level):
adset = AdSet(ad_object_id)
if level == LEVELS_POSSIBLE_VALUES[1]:
val_adset = adset.api_get(fields=self.desired_fields,
params=params)
yield val_adset
else:
raise ClickException(
"Adset setup is available at 'adset' level. Received level: " +
self.level)
def fetch_adset_data(self, adset_id):
adset = AdSet(adset_id)
adset_datas = adset.get_insights(fields=[
AdsInsights.Field.adset_id,
AdsInsights.Field.spend,
AdsInsights.Field.impressions,
AdsInsights.Field.reach,
AdsInsights.Field.unique_actions,
AdsInsights.Field.adset_name],
params={
'breakdowns':
['hourly_stats_aggregated_by_audience_time_zone'],
'time_range': self.time_range})
return adset_datas
def update_ad_set_date(request):
if request.method == 'POST':
print('----------------------------------')
access_token=request.headers['token']
received_json_data = json.loads(request.body)
endDate = received_json_data['end_time']
startDate = received_json_data['start_time']
print('-----------' + endDate)
adsetId = request.GET.get('adsetId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
ADSET_ID = adsetId
FacebookAdsApi.init(access_token=access_token)
fields = ['start_time','end_time']
print('><><>>',fields)
params = {
'start_time':startDate,
'end_time':endDate,
}
updateadset= AdSet(ADSET_ID).api_update(
fields=fields,
params=params,
)
print(updateadset)
return Response(updateadset)
else:
return HttpResponse('not found')
def create_adset(c: AdsetConf) -> AdSet:
name = f"vlab-{c.stratum.id}" # TODO: remove vlab prefix
targeting = {**c.stratum.facebook_targeting}
# TODO: document this funkyness - pretends it's runnign at midnight...
midnight = datetime.utcnow().replace(microsecond=0,
second=0,
minute=0,
hour=0)
adset = AdSet()
adset[AdSet.Field.end_time] = midnight + timedelta(hours=c.hours)
adset[AdSet.Field.targeting] = targeting
adset[AdSet.Field.status] = c.status
adset[AdSet.Field.daily_budget] = c.budget
adset[AdSet.Field.name] = name
adset[AdSet.Field.start_time] = datetime.utcnow() + timedelta(minutes=5)
adset[AdSet.Field.campaign_id] = c.campaign["id"]
adset[AdSet.Field.optimization_goal] = c.optimization_goal
adset[AdSet.Field.destination_type] = c.destination_type
adset[AdSet.Field.billing_event] = AdSet.BillingEvent.impressions
adset[AdSet.Field.bid_strategy] = AdSet.BidStrategy.lowest_cost_without_cap
if c.instagram_id:
adset[AdSet.Field.instagram_actor_id] = c.instagram_id
return adset
def update_ad_set_targeting(request):
if request.method == 'POST':
print('----------------------------------')
access_token=request.headers['token']
received_json_data = json.loads(request.body)
latitude = received_json_data['lati']
latitude = float(latitude)
print(latitude)
longitude = received_json_data['long']
longitude = float(longitude)
print(longitude)
adsetId = request.GET.get('adsetId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
ADSET_ID = adsetId
FacebookAdsApi.init(access_token=access_token)
fields = ['targeting']
print(fields)
params = {
'targeting': {'geo_locations':{'custom_locations':[
{
"radius":30,
"latitude":latitude,
"longitude":longitude
}]},},
}
updateadset= AdSet(ADSET_ID).api_update(
fields=fields,
params=params,
)
print(updateadset)
return Response(updateadset)
else:
return HttpResponse('not found')
def main(argv):
k1 = parse_argv(argv)
start_date = k1
print(start_date)
########################
## build output here
########################
fields = [
'campaign_id', 'impressions', 'spend', 'unique_inline_link_clicks'
]
params = {
'time_range': {
'since': str(start_date),
'until': str(start_date)
},
'breakdowns': ['country'],
'level': 'campaign'
# 'time_increment': 1
}
#api calls
output_json = ''
for ad in AdSet(ad_account_id).get_insights(fields=fields, params=params):
data = str(ad).replace('<AdsInsights> ', '')
# remove newlline in json, add after end of line
output_json = output_json + (data.replace("\n", ' ')) + "\n"
# save response to disk
save_to_file(output_json, start_date)
def loadAdsetFromJson(self, jsonFile):
adset = AdSet(parent_id=self.account_id)
config_file = open(jsonFile)
config = json.load(config_file)
config_file.close()
for key in config.keys():
adset[key] = config[key]
return adset
def get_delivery(ids: List[str]) -> List[Dict]:
deliveries = []
for id in ids:
adset = AdSet(id[0]).api_get(fields=["learning_stage_info", "status"])
delivery = adset.get("learning_stage_info")
status = adset.get("status")
if delivery:
delivery = status if delivery.get(
"status") == "SUCCESS" else delivery.get("status")
else:
delivery = status
deliveries.append({
"ad_id": id[1],
"adset_id": id[0],
"Delivery Type": delivery
})
return deliveries
def fetch_adset_data(adset_id):
adset = AdSet(adset_id)
adset_datas = adset.get_insights(
fields=[
AdsInsights.Field.adset_id, AdsInsights.Field.spend,
AdsInsights.Field.impressions, AdsInsights.Field.reach,
AdsInsights.Field.unique_actions, AdsInsights.Field.adset_name
],
params={
'breakdowns': ['hourly_stats_aggregated_by_audience_time_zone'],
'time_range': {
'since': yesterday,
'until': today
}
})
for adset_data in adset_datas:
print(adset_data)
result = {}
result['spend'] = adset_data['spend'] if 'spend' in adset_data else ''
result['impression_count'] = adset_data['impressions'] if\
'impressions' in adset_data else ''
result['reach_count'] = adset_data['reach'] if\
'reach' in adset_data else ''
result['link_click_count'] = adset_data['link_click'] if\
'link_click_count' in adset_data else ''
result['ad_set_id'] = adset_data['adset_id'] if\
'adset_id' in adset_data else ''
result['stat_dt'] = adset_data['date_start']
print(result['stat_dt'])
result['stat_hour'] = \
str(int(adset_data['hourly_stats_aggregated_by_audience_time_zone'][0:2]) + 1)
try:
for actions in adset_data['unique_actions']:
if actions['action_type'] == 'link_click':
result['link_click_count'] = actions['value']
if actions[
'action_type'] == 'offsite_conversion.fb_pixel_purchase':
result['effective_count'] = actions['value']
except Exception as e:
result['effective_count'] = ''
result['link_click_count'] = ''
result['create_time'] =\
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
yield result
def enable_an_on_adsets(self, adsetids):
"""
Method that takes a list of ad set ids and enables the audience network
placement on them. Please note that this method does not perform any
pre-validation check to see whether the ad set passed satisfies the
pre-requisites to have audience network enabled.
Args:
adsetids: List of ad set ids on which you want audience network
enabled. Even if you have just one id, pass it as a list.
Returns:
A list of 'ad set id' vs. 'status' mapping with a further 'message'
node whenever there was a failure to update the audience network.
Returns an empty list when an empty list or non list element is
passed.
status 1 is a success.
status 0 is a failure.
Sample response format:
[
{'<ad_set_id_1>': {'status': 1}},
{'<ad_set_id_2>': {'status': 0, 'message': '<exception_msg>'}},
...
]
"""
results = []
# check if adsets is a list
if type(adsetids) is not list:
return results
# go over the list of adset ids
for adsetid in adsetids:
try:
# read ad set info
adset = AdSet(fbid=adsetid)
adsetobj = adset.remote_read(fields=[AdSet.Field.targeting])
# edit targeting spec info for placements
targetinginfo = copy.deepcopy(adsetobj[AdSet.Field.targeting])
targetinginfo[Targeting.Field.publisher_platforms]. \
append('audience_network')
# update ad set info
adset.update({AdSet.Field.targeting: targetinginfo})
adset.remote_update()
# update result list along with status
results.append({adsetid: {'status': 1}})
except FacebookError as e:
# update result list along with status & message
results.append({adsetid: {'status': 0, 'message': e.message}})
return results
def createAdSet(self, name):
print("**Creating {} Ad Set...**".format(name))
targeting_object = {
Targeting.Field.geo_locations: {
'countries': ['IN'],
}
}
adset = AdSet()
adset['_parent_id'] = self.id
adset.update({
AdSet.Field.name: name,
AdSet.Field.campaign_id: self.campaign_id,
AdSet.Field.lifetime_budget: 80 * 10000,
AdSet.Field.bid_strategy: 'LOWEST_COST_WITHOUT_CAP',
AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
AdSet.Field.optimization_goal: AdSet.OptimizationGoal.reach,
AdSet.Field.targeting: targeting_object,
AdSet.Field.start_time: '2019-02-01 00:00:00',
AdSet.Field.end_time: '2019-02-30 23:59:00',
AdSet.Field.status: AdSet.Status.paused,
})
adset.remote_create()
self.adset_id = str(adset[AdSet.Field.id])
print("**AdSet ID: {}**".format(self.adset_id))
return adset
def make_adset(adset_params):
account_id = adset_params[AdSet.Field.account_id]
new_adset = AdSet(parent_id='act_{}'.format(account_id))
new_adset.update(adset_params)
new_adset.remote_create(params={
'status': 'ACTIVE',
})
return new_adset[AdSet.Field.id]
def __run_adreport(
self,
account_id: str,
fields: Optional[Sequence[str]],
params: Dict[str, Any],
) -> AdReportRun:
async_job = cast(
AdReportRun,
AdSet(account_id).get_insights(fields=fields,
params=params,
is_async=True),
)
while True:
job = cast(AdReportRun, async_job.api_get())
pct: int = job["async_percent_completion"]
status: str = job["async_status"]
job_id = job["id"]
if status in ["Job Skipped", "Job Failed"]:
logger.error(
f"job<{job_id}>({params}): failed with status: {status}")
return async_job
# https://developers.facebook.com/docs/marketing-api/insights/best-practices/#asynchronous
# both fields need to be set to signify completion
if status == "Job Completed" and pct == 100:
job_start_time = datetime.fromtimestamp(job["time_ref"])
job_completion_time = datetime.fromtimestamp(
job["time_completed"])
duration = job_completion_time - job_start_time
logger.info(f"job<{job_id}>: finished in {duration.seconds}s")
return async_job
# "Job Completed" does not mean that the job is done, which mweans that getting here=e
# implies that status == "Job Completed" and pct < 100
if status in [
"Job Not Started",
"Job Started",
"Job Running",
"Job Completed",
]:
logger.info(f"job<{job_id}>: {status}")
time.sleep(2)
continue
def update_adset(source: AdSet, adset: AdSet) -> List[Instruction]:
fields = [
AdSet.Field.end_time,
AdSet.Field.targeting,
AdSet.Field.status,
AdSet.Field.daily_budget,
AdSet.Field.optimization_goal,
]
if _eq(source, adset, fields):
return []
dat = adset.export_all_data()
params = {f: dat[f] for f in fields}
return [Instruction("adset", "update", params, source["id"])]
def adset_status_update(self, adset_id):
try:
adset = AdSet(fbid=adset_id)
adset.update({
AdSet.Field.status: AdSet.Status.active,
})
adset.remote_update()
print("Successfully AdSet updated!")
except Exception as e:
print(e)
def test_get_ad_set_with_wrong_fields(self):
with warnings.catch_warnings(record=True) as warning:
self.mock_response.status_code = StatusCode.ERROR
self.mock_request.return_value = self.mock_response
fields = [
'unexist_field',
]
params = {}
with self.assertRaises(FacebookRequestError):
ad_set = AdSet(TestValue.ADSET_ID).api_get(
fields=fields,
params=params,
)
self.assertEqual(len(warning), 1)
self.assertTrue((issubclass(warning[0].category, UserWarning)))
def get_adset_by_id(request):
if request.method == 'GET':
access_token=request.headers['token']
adsetId = request.GET.get('adsetId')
app_secret = 'db4b3037cd105cfd23b6032aecd2c3ff'
app_id = '263805807945856'
ADSET_ID = adsetId
FacebookAdsApi.init(access_token=access_token)
fields = ['name','start_time','end_time','targeting']
params = {}
ad_set = AdSet(ADSET_ID).api_get(
fields=fields,
params=params,
)
print(ad_set)
return Response(ad_set)
else:
return HttpResponse('not found')