def get_accounts(result_queue, b_id, app_id):
try:
retry_count = 0
while True:
try:
logger.debug('b_id:{} begin'.format(b_id))
n = 0
facebook_app = facebook_apps.get(app_id)
api = FacebookAdsApi.init(facebook_app.app_id,
facebook_app.app_secret,
facebook_app.access_token)
Business(fbid='me', api=api)
at = Business(b_id).get_client_ad_accounts(
params={'limit': 1000})
flag = True
while flag:
for account in at:
b_a = {'BusinessId': b_id}
a_id = account['account_id']
b_a['AccountId'] = str(a_id)
result_queue.put(b_a)
n += 1
flag = at.load_next_page()
logger.debug('b_id:{} len at:{}'.format(b_id, n))
return
except ConnectionError:
if retry_count < MAX_RETRIES:
time.sleep(SLEEP_TIME)
continue
else:
raise
except Exception, ex:
logger.error('get_accounts error,ex:{}'.format(ex))
def get_product_catalog_by_business_id(
self,
business_id
):
"""
Retrieves product catalogs that belong to the specified business.
"""
business = Business(business_id)
catalogs = business.get_product_catalogs()
return catalogs
def __init__(self,task_data):
super(Accounts).__init__()
self.database = DatabaseOperation()
my_app_id = task_data.app_id
my_app_secret = task_data.app_secret
my_access_token = task_data.access_token
business_id = task_data.business_id
# Start the connection to the facebook API
FacebookAdsApi.init(my_app_id, my_app_secret, my_access_token)
# Create a business object for the business account
business = Business(business_id)
# Get all ad accounts on the business account
accounts = business.get_owned_ad_accounts(
fields=[
AdAccount.Field.account_id ,
AdAccount.Field.account_status ,
AdAccount.Field.name ,
AdAccount.Field.age ,
AdAccount.Field.amount_spent ,
AdAccount.Field.business ,
AdAccount.Field.business_city ,
AdAccount.Field.business_country_code ,
AdAccount.Field.business_name ,
AdAccount.Field.business_state ,
AdAccount.Field.business_street ,
AdAccount.Field.business_street2 ,
AdAccount.Field.business_zip
]
)
# To keep track of rows added to file
rows = 0
#Iterate through the adaccounts
for account in accounts:
# Write all ad info to the file, and increment the number of rows that will display
#Construct the params of time
id_account = self.database.select('account', 'account_id',account[AdAccount.Field.account_id])
if len(id_account) == 0:
value = {
'fb_id':account[AdAccount.Field.id],
'account_id':account[AdAccount.Field.account_id],
'name':account[AdAccount.Field.name],
'account_status':account[AdAccount.Field.account_status],
'age':account[AdAccount.Field.age],
'amount_spent':account[AdAccount.Field.amount_spent]
}
rows = rows + 1
self.database.insert('account',value)
print(str(rows) + " rows added ")
def get_business_users_all(api):
try:
bs = Business(fbid='me',
api=api).get_business_users(params={'limit': 1000})
business_ids = list()
flag = True
while flag:
for business in bs:
b_id = business['business']['id']
business_ids.append(str(b_id))
flag = bs.load_next_page()
return business_ids
except Exception:
raise
def get_agencies(self):
"""Returns a list of businesses associated with the ads pixel"""
response = self.get_api_assured().call(
'GET',
(self.get_id_assured(), 'shared_agencies'),
).json()
ret_val = []
if response:
keys = response['data']
for item in keys:
search_obj = Business()
search_obj.update(item)
ret_val.append(search_obj)
return ret_val
def get_agencies(self):
"""Returns a list of businesses associated with the ads pixel"""
response = self.get_api_assured().call(
'GET',
(self.get_id_assured(), 'shared_agencies'),
).json()
ret_val = []
if response:
keys = response['data']
for item in keys:
search_obj = Business()
search_obj.update(item)
ret_val.append(search_obj)
return ret_val
def test_create_adaccount(self):
with warnings.catch_warnings(record=True) as warning:
self.mock_response.status_code = StatusCode.SUCCESS
self.mock_response._content = str.encode(
'{"' + str(FieldName.ID) + '":"' + str(TestValue.ACCOUNT_ID) +
'", "success": "true"}')
self.mock_request.return_value = self.mock_response
fields = []
params = {
FieldName.AD_ACCOUNT_CREATED_FROM_BM_FLAG:
TestValue.AD_ACCOUNT_CREATED_FROM_BM_FLAG,
FieldName.CURRENCY: TestValue.CURRENCY,
FieldName.INVOICE: TestValue.INVOICE,
FieldName.NAME: TestValue.NAME,
FieldName.TIMEZONE_ID: TestValue.TIMEZONE_ID,
}
account = Business(TestValue.BUSINESS_ID).create_ad_account(
fields,
params,
)
self.assertEqual(len(warning), 0)
self.assertTrue(isinstance(account, AdAccount))
self.assertEqual(account[FieldName.ID], TestValue.ACCOUNT_ID)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(api=self._api, fbid=parent_id).create_owned_domain(
fields, params, batch, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(api=self._api,
fbid=parent_id).create_ad_account_creation_request(
fields, params, batch, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(api=self._api,
fbid=parent_id).create_offline_conversion_data_set(
fields, params, batch, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(api=self._api, fbid=parent_id).create_system_user(
fields, params, batch, success, failure, pending)
def test_runs_correctly(self):
biz_id_1 = random.gen_string_id()
biz_id_2 = random.gen_string_id()
page_id_1 = random.gen_string_id()
page_id_2 = random.gen_string_id()
page_id_3 = random.gen_string_id()
page_id_4 = random.gen_string_id()
businesses = [Business(fbid=biz_id_1), Business(fbid=biz_id_2)]
client_pages = [Page(fbid=page_id_1), Page(fbid=page_id_2)]
owned_pages = [Page(fbid=page_id_3), Page(fbid=page_id_4)]
job_scope = JobScope(
ad_account_id='0',
sweep_id=self.sweep_id,
entity_type=Entity.Scope,
entity_id=self.scope_id,
report_type=ReportType.import_pages,
report_variant=Entity.Page,
tokens=['token'],
)
with SweepRunningFlag(job_scope.sweep_id), mock.patch.object(
FacebookRequest, 'execute',
return_value=businesses) as gp, mock.patch.object(
Business, 'get_client_pages',
return_value=client_pages), mock.patch.object(
Business, 'get_owned_pages',
return_value=owned_pages), mock.patch.object(
report_job_status_task, 'delay') as status_task:
collect_pages_from_business_task(job_scope, JobContext())
assert gp.called
assert status_task.called
# it was called many times, but we care about the last time only
pp, kk = status_task.call_args
assert not kk
assert pp == (JobStatus.Done, job_scope)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(
api=self._api,
fbid=parent_id).create_third_party_measurement_report_dataset(
fields, params, batch, success, failure, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(
api=self._api,
fbid=parent_id).create_sent_inprogress_on_behalf_request(
fields, params, batch, success, failure, pending)
def api_create(self,
parent_id,
fields=None,
params=None,
batch=None,
success=None,
failure=None,
pending=False):
from facebook_business.adobjects.business import Business
return Business(
api=self._api,
fbid=parent_id).create_collaborative_ads_collaboration_request(
fields, params, batch, success, failure, pending)
def test_create_adaccount_with_wrong_params(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 = []
params = {
'invoice': 0,
'timezone_id': 'abc',
}
with self.assertRaises(FacebookRequestError):
account = Business(TestValue.BUSINESS_ID).create_ad_account(
fields,
params,
)
self.assertEqual(len(warning), 2)
self.assertTrue(issubclass(warning[-1].category, UserWarning))
# 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 facebook_business.adobjects.business import Business
from facebook_business.adobjects.productcatalog import ProductCatalog
from facebook_business.api import FacebookAdsApi
access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<BUSINESS_ID>'
FacebookAdsApi.init(access_token=access_token)
fields = [
]
params = {
'name': 'Test Catalog',
}
print Business(id).create_owned_product_catalog(
fields=fields,
params=params,
)
def get_data_from_api(start_date,end_date):
Campaign_ID = []
Page_ID = []
Amount_Spent = []
# Page_Name = []
campaigns_all = {"Campaign_id":[],
"Page_id":[],
"Amount_spent":[],
}
page_id = None
pixel_id = None
access_token = 'EAAUbBhxccoEBALbQCDsVMLzwdZBZAZBXApZA0t1Qy3GtjZALfs89EMFhH62f5Kp7FWvshYRTrur41B14vICAgTf1TOba8qx7SBPejdqR4gZBqZCGDo0l0WvsmzubUKKqHncpyqhSpUqcO7O0WJsB1PnSZAMY7t7awukDuIYwrisTYwZDZD'
bussiness_account_id = '1517651558352959'
app_secret = '7a3ad485c97dbf45ee83562bc0dcb570'
app_id = '1437087943127681'
start_time = datetime.datetime.now()
FacebookAdsApi.init(app_id, app_secret, access_token)
business = Business(bussiness_account_id)
# Get all ad accounts on the business account
my_ad_account =business.get_owned_ad_accounts(fields=[AdAccount.Field.id])
# fields = [
# 'name',
# 'objective',
# # 'spend',
# ]
# params = {
# 'time_range':{'since':start_date,'until':end_date},
# # 'date_preset':'yesterday',
# 'effective_status': ['ACTIVE','PAUSED'],
# }
# Iterate through the adaccounts
for account in my_ad_account:
print(len(my_ad_account))
# i = 0
# Create an addaccount object from the adaccount id to make it possible to get insights
tempaccount = AdAccount(account[AdAccount.Field.id])
# campaigns_iter = tempaccount.get_campaigns(fields = fields, params = params)
# CAMPAIGN_UPDATE_BATCH_LIMIT = 5
# for campaigns in generate_batches(campaigns_iter,CAMPAIGN_UPDATE_BATCH_LIMIT):
# api_batch = api.new_batch()
# for i, campaign in enumerate(campaigns_iter):
# adset = AdAccount(campaign[Campaign.Field.id]).get_ad_sets(
# fields=['id', 'name', 'promoted_object'],
# params = {})
# print(adset)
# api_batch.execute()
# spend_val.append(campaign[Campaign.Field.id])
# print(campaign, i)
# print(spend_val)
# print(set(spend_val))
# Grab insight info for all ads in the adaccount
account_data = tempaccount.get_insights(params={
# 'time_increment':'1',
'time_range':{'since':start_date, 'until':end_date},
'level':'campaign',
},
fields=[
AdsInsights.Field.campaign_id,
AdsInsights.Field.campaign_name,
AdsInsights.Field.spend,
]
)
for campaign in account_data:
try:
#Check if you reached 75% of the limit, if yes then back-off for 5 minutes (put this chunk in your 'for ad is ads' loop, every 100-200 iterations)
# if (check_limit(bussiness_account_id,access_token)>75):
# print('75% Rate Limit Reached. Cooling Time 5 Minutes.')
# logging.debug('75% Rate Limit Reached. Cooling Time 5 Minutes.')
# time.sleep(300)
#ID OF Campaign
# if campaign!=[]:
# print(campaign)
# print(len(account_data))
campaign_id = campaign[AdsInsights.Field.campaign_id]
campaign_spent_val = campaign[AdsInsights.Field.spend]
# print(campaign_spent_val)
my_camp = Campaign(campaign_id)
print(my_camp)
#Campaign Insights Object
# campaign_spent_obj = my_camp.get_insights(params={}, fields=[AdsInsights.Field.spend])
# campaign_spent = campaign_spent_obj[Campaign.Field.spend]
# print(campaign_spent_obj)
#Campaign Spend value
# campaigns_all["Amount_spent"].append(campaign_spent_val)
#AdSet Object
adset = AdAccount(my_camp[Campaign.Field.id]).get_ad_sets(
fields=['id', 'name', 'promoted_object'],
params = {})
#page and Pixel ID from Adset
if 'page_id' in adset[0][AdSet.Field.promoted_object]:
page_id = adset[0][AdSet.Field.promoted_object][AdPromotedObject.Field.page_id]
campaigns_all["Page_id"].append(page_id)
Page_ID.append(page_id)
# page_req = rq.head('https://facebook.com/'+page_id)
# print(page_req.headers)
# # for page in Page_ID:
# print(Page(page_id).api_get(fields=['name'],params={}))
elif 'pixel_id' in adset[0][AdSet.Field.promoted_object]:
pixel_id = adset[0][AdSet.Field.promoted_object][AdPromotedObject.Field.pixel_id]
campaigns_all["Page_id"].append(pixel_id)
Page_ID.append(pixel_id)
else:
continue
# Add Values to Dictionary
campaigns_all["Campaign_id"].append(campaign_id)
campaigns_all["Amount_spent"].append(campaign_spent_val)
Campaign_ID.append(campaign_id)
Amount_Spent.append(campaign_spent_val)
# print(campaigns_all)
time.sleep(2)
except KeyError as e:
print(e)
continue
except Exception as e:
print(e)
if FacebookRequestError.api_error_code(e) == 17:
print(campaigns_all)
print("Limit Reached")
print("Wait 5 minutes for cooldown")
time.sleep(300)
continue
finally:
end_time = datetime.datetime.now()
diff = end_time - start_time
print(diff)
tuples_of_data = list(zip(Campaign_ID,Page_ID,Amount_Spent))
sum_amount = compare_values(tuples_of_data)
print(sum_amount)
# print(diff.total_seconds())
return campaigns_all,sum_amount
FACEBOOK_TOKEN = os.environ['FACEBOOK_TOKEN']
FACEBOOK_APP_ID = os.environ['FACEBOOK_APP_ID']
FACEBOOK_APP_SECRET = os.environ['FACEBOOK_APP_SECRET']
FACEBOOK_AD_ACCT_ID = os.environ['FACEBOOK_AD_ACCT_ID']
FACEBOOK_BUSINESS_ID = os.environ['FACEBOOK_BUSINESS_ID']
FacebookAdsApi.init(FACEBOOK_APP_ID, FACEBOOK_APP_SECRET, FACEBOOK_TOKEN)
my_account = AdAccount(FACEBOOK_AD_ACCT_ID)
fields = []
params = {
'name': 'Test Catalog',
}
product_catalog = Business(FACEBOOK_BUSINESS_ID).create_owned_product_catalog(
fields=fields, params=params)
print('product_catalog', product_catalog)
fields = ['link']
params = {
'currency': 'USD',
'description': 'first test post',
'name': 'test name 1',
'price': 20,
'image_url':
'https://memeshappen.com/media/created/2018/11/SCOTT-S-OUR-MAN.jpg',
'retailer_id': 'test',
'category': 't-shirt',
'link': 'https://viral-tees-gubr.myshopify.com/products/betawards-8'
}
# 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 facebook_business.adobjects.business import Business
from facebook_business.adobjects.offlineconversiondataset import OfflineConversionDataSet
from facebook_business.api import FacebookAdsApi
access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<ID>'
FacebookAdsApi.init(access_token=access_token)
fields = []
params = {
'name': 'offline_event_set',
'description': 'conversion data used for superbowl campaign',
'data_origin': 'DIRECTLY_FROM_PEOPLE',
}
print Business(id).create_offline_conversion_data_set(
fields=fields,
params=params,
)
def _set_business_account(self):
return Business(self._my_business_account, api=self._api)