def post_fb_page(message):
graph = GraphAPI(config("FB_PYTHON_ACCESSTOKEN", default="TOKKEEEENNNN"))
try:
graph.put_object("PyJobs", "feed", message=message)
except:
pass
return True
def _send(self):
for_voted, email, fb_notification = self._make_template()
# Holmes wants to turn this off, at least for now.
# self._send_email(for_voted, email)
graph = GraphAPI(access_token=settings.FACEBOOK_APP_ACCESS_TOKEN)
graph.put_object(self.user.fb_uid, "notifications", href="", template=fb_notification)
self._mark_as_notified()
def post_to_fb():
if current_user.fb_token:
current_app.logger.debug('User {} already has token: {}'.format(
current_user.username, current_user.fb_token))
user_graph = GraphAPI(current_user.fb_token, version='2.11')
elif request.args.get('code'):
current_app.logger.debug('Fetching Facebook token for user {}'.format(
current_user.username))
current_app.logger.debug(request.args)
result = get_user_from_cookie(
cookies=request.cookies,
app_id=current_app.config['FB_APP_ID'],
app_secret=current_app.config['FB_APP_SECRET'])
if result:
user_graph = GraphAPI(result['access_token'])
else:
flash(
"Ekki tókst að senda póst á Facebook! Ertu búinn að logga þig inn?"
)
return redirect(url_for('admin.news_index'))
else:
current_app.logger.error(
"Not able to send post to Facebook for user {}".format(
current_user.username))
current_app.logger.error(request.args)
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
accounts = user_graph.get_object('me/accounts')
for d in accounts['data']:
if d['id'] == current_app.config['FB_PAGE_ID']:
page_access_token = d['access_token']
break
else:
current_app.logger.error('Not able to find the page_access_token')
current_app.logger.error(accounts)
current_app.logger.error(current_app.config['FB_PAGE_ID'])
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
lnk = session.pop('link', None)
msg = session.pop('body', None)
page_graph = GraphAPI(page_access_token, version='2.11')
page_graph.put_object(parent_object=current_app.config['FB_PAGE_ID'],
connection_name='feed',
message=msg,
link=lnk)
return redirect(url_for('admin.news_index'))
def _send(self):
for_voted, email, fb_notification = self._make_template()
# Holmes wants to turn this off, at least for now.
# self._send_email(for_voted, email)
graph = GraphAPI(access_token=settings.FACEBOOK_APP_ACCESS_TOKEN)
graph.put_object(self.user.fb_uid,
"notifications",
href="",
template=fb_notification)
self._mark_as_notified()
def fb_push(fb_access_token, fb_privacy_setting, message, url):
"""
Post to User's wall with access_token
"""
graph = GraphAPI(fb_access_token)
post_data = create_fb_post_data(message=message,
privacy=fb_privacy_setting,
url=url)
graph.put_object('me', 'feed', **post_data)
def do_graph_action():
try:
graph = GraphAPI(access_token)
graph.put_object('me', send_action, quest=quest_url)
if request:
Metrics.share_to_timeline.record(request, quest=quest_url)
except GraphAPIError as e:
if request:
Metrics.share_to_timeline_error.record(request, quest=quest_url)
client.create_from_exception()
def post_fb_page(message):
token = config("FB_PYTHON_ACCESSTOKEN", default=None)
if token != None:
graph = GraphAPI(token)
try:
graph.put_object("PyJobs", "feed", message=message)
except:
pass
return True
return False
def facebook_post(self, content):
page_access_token = settings.FACEBOOK_PAGE_ACCESS_TOKEN
api = GraphAPI(page_access_token)
# https://developers.facebook.com/docs/graph-api/reference/v2.12/user/feed
api.put_object(
parent_object=settings.FACEBOOK_PAGE_ID,
connection_name="feed",
message=content['message'],
link=content['destination'],
)
def post_to_fb():
if current_user.fb_token:
current_app.logger.debug('User {} already has token: {}'
.format(current_user.username,
current_user.fb_token))
user_graph = GraphAPI(current_user.fb_token, version='2.11')
elif request.args.get('code'):
current_app.logger.debug('Fetching Facebook token for user {}'
.format(current_user.username))
current_app.logger.debug(request.args)
result = get_user_from_cookie(cookies=request.cookies,
app_id=current_app.config['FB_APP_ID'],
app_secret=current_app.config['FB_APP_SECRET'])
if result:
user_graph = GraphAPI(result['access_token'])
else:
flash("Ekki tókst að senda póst á Facebook! Ertu búinn að logga þig inn?")
return redirect(url_for('admin.news_index'))
else:
current_app.logger.error("Not able to send post to Facebook for user {}"
.format(current_user.username))
current_app.logger.error(request.args)
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
accounts = user_graph.get_object('me/accounts')
for d in accounts['data']:
if d['id'] == current_app.config['FB_PAGE_ID']:
page_access_token = d['access_token']
break
else:
current_app.logger.error('Not able to find the page_access_token')
current_app.logger.error(accounts)
current_app.logger.error(current_app.config['FB_PAGE_ID'])
flash("Ekki tókst að senda póst á Facebook!")
return redirect(url_for('admin.news_index'))
lnk = session.pop('link', None)
msg = session.pop('body', None)
page_graph = GraphAPI(page_access_token, version='2.11')
page_graph.put_object(parent_object=current_app.config['FB_PAGE_ID'],
connection_name='feed',
message=msg,
link=lnk)
return redirect(url_for('admin.news_index'))
def do_graph_action():
try:
graph = GraphAPI(access_token)
graph.put_object('me', send_action, post=post)
if action == 'sticker':
Metrics.timeline_sticker.record(request, post=post)
elif action == 'remix':
Metrics.timeline_remix.record(request, post=post)
except GraphAPIError:
if action == 'sticker':
Metrics.timeline_sticker_error.record(request, post=post)
elif action == 'remix':
Metrics.timeline_remix_error.record(request, post=post)
def do_graph_action():
try:
graph = GraphAPI(access_token)
graph.put_object('me', send_action, post=post)
if action == 'sticker':
Metrics.timeline_sticker.record(request, post=post)
elif action == 'remix':
Metrics.timeline_remix.record(request, post=post)
except GraphAPIError:
if action == 'sticker':
Metrics.timeline_sticker_error.record(request, post=post)
elif action == 'remix':
Metrics.timeline_remix_error.record(request, post=post)
def fb_page_push(fb_access_token, fb_page_id, fb_page_access_token,
fb_privacy_setting, message, url):
"""
Post to Facebook Pages with access_token
"""
graph = GraphAPI(fb_access_token)
post_data = create_fb_post_data(message=message,
url=url,
access_token=fb_page_access_token)
if post_data.has_key('link'):
graph.put_object(fb_page_id, 'links', **post_data)
else:
graph.put_object(fb_page_id, 'feed', **post_data)
def post_statuses(unpublished_statuses):
"""Posts all statuses to facebook that need to be posted"""
for post in unpublished_statuses:
msg = post.msg
access_token = post.facebookinfo.access_token
api = GraphAPI(access_token)
api.put_object(parent_object='me', connection_name='feed', message=msg)
post.is_posted = True
db.session.add(post)
db.session.commit()
def edit_post(facebook_api: facebook.GraphAPI, selection: int, message: str) -> None:
"""
Edits the selection and prints the success of the action
Arguments:
facebook_api (object) : facebook api graph
selection (int) : The number of the post the user selected
message (str) : New message of post
Returns:
object - (facebook_api)
"""
facebook_api.put_object(parent_object = selection, connection_name = '', message = message)
print_write_chatbot("Posting has been updated successfully!\n", color = 'green', attrs_color = ["bold"])
def upload_post(facebook_api: facebook.GraphAPI) -> None:
"""
Uploads the post written by the user and prints the success of the action if there are no errors
Arguments:
facebook_api (object) : facebook api graph
"""
user_message = input_user_chat("What would you like to write?: ")
try:
facebook_api.put_object(parent_object = 'me', connection_name = 'feed', message = user_message)
print_write_chatbot("Posting has been updated successfully!\n", color = 'green', attrs_color = ["bold"])
except Exception as err:
write_log(STATUS_FILE, str(err), 'Exception')
print_write_chatbot(f"Error to upload a post {err}", color = "red", attrs_color = ['bold'])
def my_form_post():
status = request.form['status']
print(status)
graph = GraphAPI(FB_ACCESS_TOKEN_PAGE)
profile = graph.get_object("me")
graph.put_object(profile['id'], "feed", message=status)
if g.user:
posts = graph.get_connections(profile["id"], "posts")
img_page = "https://graph.facebook.com/" + profile['id'] +"/picture?type=large"
img_usr = "******" + g.user['id'] +"/picture?type=large"
return render_template(
"index.html", app_id=FB_APP_ID, app_name=FB_APP_NAME, user=g.user, page=profile["name"], img_usr=img_usr, img_page=img_page, posts=posts["data"]
)
# Otherwise, a user is not logged in.
return render_template("login.html", app_id=FB_APP_ID, name=FB_APP_NAME)
def load_fixtures():
pprint.pprint("Load fixtures -----------------")
dir = os.path.dirname(os.path.realpath(__file__))
file = open(dir + '/posts.txt', 'r')
posts = file.readlines()
# pprint.pprint(posts)
users = UserActions.find_all()
for user in users:
if user.access_token is not "":
graph = GraphAPI(user.access_token)
for post in posts:
graph.put_object("me", "feed", message=post)
pprint.pprint("Total user: " + str(len(users)))
def load_fixtures():
pprint.pprint("Load fixtures -----------------")
dir = os.path.dirname(os.path.realpath(__file__))
file = open(dir + '/posts.txt', 'r')
posts = file.readlines()
# pprint.pprint(posts)
users = UserActions.find_all()
for user in users:
if user.access_token is not "":
graph = GraphAPI(user.access_token)
for post in posts:
graph.put_object("me", "feed", message=post)
pprint.pprint("Total user: " + str(len(users)))
def add_entry():
if request.method == 'GET':
fb_groups = get_fb_groups(g.user['access_token'])
return render_template('add_entry.html', user=g.user, app_id=FB_APP_ID, name=FB_APP_NAME, groups=fb_groups)
else:
graph = GraphAPI(g.user['access_token'])
groups = request.form.getlist('group_select')
app.logger.debug("group_select: " + ','.join(groups))
message = request.form.get('group_text', '')
app.logger.debug("group_text: " + message)
for group in groups:
try:
graph.put_object(group, "feed", message=message)
except Exception as error:
app.logger.error(error.message)
else:
cache.delete_memoized(get_fb_groups, g.user['access_token'])
return redirect(url_for('add_entry'))
class FacebookConnector(APIConnector):
"""FacebookConnector is an APIConnector that performs communication with the Facebook API"""
def __init__(self):
self.page_id = '570688683390106'
self.access_token = 'EAACfoaUxqb8BAF5GzCrCWzHQ4RxYhZA7rZC' \
'CtQkuRNpDZCXgsND54YZBgdMddztvPtZAqBymmh' \
'Rf0ibsIrfUHMymH8kq2CT2JNZAVsrss43JHKlUAoS0v' \
'qZBzaB8DVsuYNx1tqAZCXq3a9nyIvzcHFMZBR0PCIYePw3BbJEi' \
'njawZAfCNWM0zf9RjavwfVfY9EZBuIGIuvMP72qcwZDZD'
self.client = GraphAPI(access_token=self.access_token)
def send_message(self, message: str):
"""
Sends a message to the Facebook API
:param message: A text string message to be sent to the Facebook API
:return: None
"""
self.client.put_object(self.page_id, 'feed', message=message)
def handle(self, *args, **options):
print '--> Start Facebook autoposting process'
# Внимание!!! Нельзя публиковать чаще чем 1 раз в 90 минут, иначе Facebook забанит
allow_date = datetime.datetime.now() - datetime.timedelta(minutes=91)
facebook_autoposting = FacebookAutoposting.objects.filter(
(Q(last_posting_at__lt=allow_date)
| Q(last_posting_at__isnull=True))
& Q(access_token_expires_at__gt=datetime.datetime.now(),
is_active=True)).exclude(access_token__isnull=True)
if facebook_autoposting.exists():
for fb_autoposting in facebook_autoposting:
translation.activate(fb_autoposting.language)
print ' --> choose ad for Facebook autoposting #%d' % fb_autoposting.id
# Выбираем одно объявление по заданным параметрам, которое еще ни разу не публиковали
ads = Ad.objects.filter(
deal_type=fb_autoposting.deal_type,
region__id__in=fb_autoposting.region.get_children_ids(),
is_published=True,
status=1,
facebook_autoposting_ads__isnull=True,
has_photos=True,
price_uah__gte=fb_autoposting.min_price).order_by(
'-created')
ad = ads.filter(user__in=User.get_user_ids_with_active_ppk()
).first() or ads.first()
if ad:
print ' --> chosen ad #%d' % ad.pk
graph = GraphAPI(access_token=fb_autoposting.access_token)
try:
object_id = graph.put_object(
parent_object=fb_autoposting.page_id,
connection_name='feed',
link=ad.get_absolute_url(),
message=ad.get_absolute_url(),
published=True)
except GraphAPIError as e:
print ' --> error while posting ad', e
continue
fb_autoposting.last_posting_at = datetime.datetime.now()
fb_autoposting.save()
FacebookAutopostingAd.objects.create(
facebook_autoposting=fb_autoposting,
basead=ad.basead_ptr,
page_id=object_id)
print ' --> success posting to Facebook and mark Ad'
print '<-- Finish Facebook autoposting process'
class FacebookConnector(APIConnector):
"""FacebookConnector is an APIConnector that performs communication with the Facebook API"""
def __init__(self):
self.page_id = '570688683390106'
self.access_token = 'EAACfoaUxqb8BAJyP1bM3mgeYDbUmt0O8' \
'cRaKrBruFG8asGlCOnR32wsFQ5zyrbJYH' \
'mXApuFlJbbu5VDig393ZCh7ZBoiC5thCx' \
'csbci8q4Ws3iqYfc9GNzzv36d2InaEXFD' \
'1FSN66eVZCZCZCMiTqsBZCa8ZBjbfpvqq' \
'luygKanCN7PcwIOOVW5'
self.client = GraphAPI(access_token=self.access_token)
def send_message(self, message: str):
"""
Sends a message to the Facebook API
:param message: A text string message to be sent to the Facebook API
:return: None
"""
self.client.put_object(self.page_id, 'feed', message=message)
def share_web_profile(request, message,
twitter_access_token=None, twitter_access_token_secret=None,
facebook_access_token=None):
if twitter_access_token is not None and twitter_access_token_secret is not None:
try:
Twitter(twitter_access_token, twitter_access_token_secret).tweet(message)
except TwitterDuplicateStatusError as e:
pass
except TwitterError as e:
client.captureException()
if facebook_access_token:
graph = GraphAPI(facebook_access_token)
try:
graph.put_object('me', 'feed', message=message)
except GraphAPIError:
raise InvalidFacebookAccessToken("Invalid Facebook access token, please re-auth with Facebook.")
except IOError:
client.captureException()
class FacebookPage:
def __init__(self, page_id, page_token):
self.page_id = page_id
self.graph = GraphAPI(access_token=page_token, version="3.0")
def post(self, text, link):
self.graph.put_object(self.page_id, "feed", message=text, link=link)
@staticmethod
def generate_post(update: Update) -> (str, str):
short_codename = update.codename.split('_')[0]
link = f"{website}/miui/{short_codename}"
message: str = f"New {update.branch} {update.method} update available for " \
f"{get_full_name(update.codename)} ({short_codename})!\n\n"
message += f"Version: {update.version} | {update.android}\n" \
f"Size: {naturalsize(update.size)}\n"
if update.md5:
message += f"MD5: {update.md5}\n"
message += f"\nFull Update: {update.link}\n"
# incremental update
if update.method == "Recovery":
incremental = get_incremental(update.version)
if incremental:
message += f"\nIncremental Update: {incremental.link}\n"
if update.changelog != "Bug fixes and system optimizations.":
message += f"\nChangelog:\n{update.changelog}\n"
message += f"\n#MIUI_Updates #Xiaomi #MIUI #{get_device_name(update.codename).replace(' ', '')}"
if update.version.startswith("V"):
message += f" #MIUI{update.version.split('V')[1].split('.')[0]}"
message += f" #Android{update.android.split('.')[0]}"
return message, link
def post_updates(self, new_updates: List[Update]):
"""
Send updates to a Telegram chat
:param new_updates: a list of updates
"""
for update in new_updates:
text, link = self.generate_post(update)
self.post(text, link)
def run(self):
print("Add posts to facebook profile")
directory = os.path.dirname(os.path.realpath(__file__))
file = open(directory + '/posts.txt', 'r')
posts = file.readlines()
for user in UserActions.find_all():
if user.access_token is not "":
graph = GraphAPI(user.access_token)
for post in posts:
print(graph.put_object("me", "feed", message=post))
pass
def post(self, request, *args, **kwargs):
p_k = self.kwargs.get('pk')
form = self.form_class(request.POST)
if form.is_valid():
message = form.cleaned_data["message"]
graph = GraphAPI( \
access_token="EAAnaWYZCIV5oBADaPaZAYHl7ovqdV0yKGVtZCWitnYYLagFbiWTstwGC5GKqqHLWL5yiBcMCLyIzeTlQc3J8XEOjNZAx0CC2Ov2p6mpO7yrud8zWkQyFnI9AnmyxRtbbmrzHiLLZB8OWkAT7lldPDPNBej8pgnFZAltsWB9FMVaHewhZCA45zirgRLr5ZCd0yVv100ZAFDloJywZDZD")
objects1 = graph.get_object("me", fields="accounts")
user = graph.get_object("me", fields="id,name")
print(user)
print("pggg")
userid = user['id']
context = {}
dict = {}
# context=0
for page in objects1['accounts']['data']:
# print(page)
page_access_token = page['access_token']
pageid = p_k
pagename = page['name']
pagecategory = page['category']
api = pyfacebook.Api(
app_id="2773352989611930",
app_secret="a5ceb9b7b928c55fd1f7922dc3737a33",
short_token=page_access_token)
print(page_access_token, pageid, pagename, pagecategory)
print(api.get_page_info(page_id=p_k, return_json=True))
print("aaa111")
# def post(self, request, *args, **kwargs):
subgraph = GraphAPI(access_token=page_access_token)
subgraph.put_object(pageid,
"feed",
message=f'{message} {pagename}')
return redirect("pgdtl_view")
def post_to_fb_group(credential: str,
page_id: str,
content: str,
link=None) -> bool:
graph = GraphAPI(access_token=credential)
try:
result = graph.put_object(page_id, 'feed', message=content, link=link)
print(result)
if is_success(result, 'id'):
logging.info(page_id + " " + "successfully posted")
return True
logging.info(page_id + " " + "failed to post")
return False
except Exception as e:
logging.critical(page_id + " " + "failed::" + str(e))
return False
'message': message,
'access_token': access_token,
'link': 'http://connpass.com/event/3785/',
}
graph.put_object(page_id, 'links', **data)
if __name__ == '__main__':
config = ConfigParser.ConfigParser()
config.read('facebooktest.ini')
app_config = config._sections['App']
# アクセストークンを取得
get_access_token(app_config)
graph = GraphAPI(ACCESS_TOKEN)
# Facebook ページのアクセストークンを取得
page_dict = get_page_dict(graph)
# 自分の wall にメッセージを書き込み
data = {
'message': 'python スクリプトから投稿',
'link': 'http://connpass.com/event/3785/',
'privacy': {'value':'SELF'}, # for testing
}
graph.put_object('me', 'links', **data)
# Facebook ページにメッセージを書き込み
put_message(PAGE_ID, page_dict, 'python スクリプトから投稿')
def confirm_post():
"""Sends scheduled post info to Facebook (pages only) and redirects to confirmation page"""
if 'user_id' not in session:
flash("You need to be logged in for that!")
return redirect('/login')
page_id = request.form.get("page_id")
user_id = session["user_id"]
msg = request.form.get("userpost")
scheduled_publish_time = int(request.form.get('publish_timestamp'))
facebook_info = FacebookInfo.query.filter_by(user_id=user_id).one()
facebookinfo_id = facebook_info.facebookinfo_id
time_to_show = request.form.get('time_to_show')
user_id = session["user_id"]
facebook_info = FacebookInfo.query.filter_by(user_id=user_id).first()
access_token = facebook_info.access_token
api = GraphAPI(access_token)
access_token_response = api.get_object(id=page_id, fields='access_token')
page_token = access_token_response['access_token']
page_api = GraphAPI(page_token)
page_api.put_object(parent_object='me',
connection_name='feed',
scheduled_publish_time=scheduled_publish_time,
published=False,
message=msg)
new_post = FacebookPagePost(msg=msg,
post_datetime=scheduled_publish_time,
user_id=session["user_id"],
facebookinfo_id=facebookinfo_id)
db.session.add(new_post)
db.session.commit()
#Add unpublished part here??
# page_response = api.get_connections("me", "accounts")
# pages = page_response["data"]
# published_posts = []
# unpublished_posts = []
# for page in pages:
# current_page_id = str(page['id'])
# post_rsp = api.get_connections(id=current_page_id, connection_name='promotable_posts', fields='is_published,message,id')
# for post in post_rsp['data']:
# print post
# if post['is_published']:
# published_posts.append(post)
# else:
# unpublished_posts.append(post)
unpublished_page_posts = FacebookPagePost.query.filter_by(
is_posted=False, user_id=user_id).all()
return render_template("/confirm_page.html",
time_to_show=time_to_show,
unpublished_page_posts=unpublished_page_posts)
class Facebook(SocialNetwork):
graph = None
my_id = None
base_url = f"https://graph.facebook.com/v{FACEBOOK_API_VERSION}"
def __init__(self, debug=False):
super().__init__(
sn_key=SocialNetworkType.facebook, debug=debug,
)
# load env vars after calling super().__init__(*args, **kwargs)
self.access_token = os.environ.get(FACEBOOK_ACCESS_TOKEN, None)
if self.access_token:
try:
self.graph = GraphAPI(
access_token=self.access_token,
timeout=REQUESTS_TIMEOUT,
version=FACEBOOK_API_VERSION,
)
me = self.graph.get_object("me", fields="id")
self.my_id = me.get("id", None)
if self.debug:
print(f"Initialized")
except Exception as err:
if self.debug:
print("ERROR: could not initialize Facebook! X_X", err)
def search(self, q=None, **kwargs):
"""
https://developers.facebook.com/docs/places/search
example:
search(type=place, q=McDonalds, fields=name,checkins,website)
Deprecated on v8.0 :(
"""
type_ = kwargs.get("type", None)
fields = kwargs.get("fields", None)
center = kwargs.get("center", None)
distance = kwargs.get("distance", None)
if not type_:
return None
if not q and not center:
if self.debug:
print("At least one of `q` or `center` keyword args is required")
return None
url = f"{self.base_url}/search?type={type_}"
if self.debug:
url += "&debug=all"
if q:
url += f"&q={q}"
if center:
url += f"¢er={center}"
if distance:
url += f"&distance={distance}"
if fields:
url += f"&fields={fields}"
url += f"&access_token={self.access_token}"
try:
response = requests.get(url, timeout=REQUESTS_TIMEOUT)
return response.json()
except (requests.HTTPError, Exception):
return None
def get(self, **kwargs):
# type: (Any) -> Optional[Union[Dict[str,Union[bytes,str]], Dict[str, str], Generator[Union[int,str],Any, None]]] # noqa
if not self.my_id or not self.graph:
if self.debug:
print("Could not initialize me :(")
return None
id_ = kwargs.pop("id", None)
ids = kwargs.pop("ids", None)
if not id_ and not ids:
if self.debug:
print("At least one of ``id``, ``ids`` keyword args is required")
return None
if id_:
connection_name = kwargs.pop("connection_name", None)
if connection_name:
get_all = kwargs.pop("get_all", False)
if get_all:
return self.graph.get_all_connections(
id_, connection_name=connection_name, **kwargs
)
return self.graph.get_connections(
id_, connection_name=connection_name, **kwargs
)
return self.graph.get_object(id_, **kwargs)
return self.graph.get_objects(ids, **kwargs)
def post(self, text=None, url=None, media=None, **kwargs):
parent_object = kwargs.get("parent_object", "me")
connection_name = kwargs.get("connection_name", "feed")
response = None
try:
if media:
url = f"{FACEBOOK_GRAPH_URL}/{parent_object}/photos?access_token={self.access_token}"
if os.path.exists(media):
name = os.path.split(media)[-1]
files = {name: open(media, "rb")}
response = requests.post(url, files=files)
else:
local_path = self.download_media(media)
if local_path and os.path.exists(local_path):
name = os.path.split(local_path)[-1]
files = {name: open(local_path, "rb")}
response = requests.post(url, files=files)
os.unlink(local_path)
else:
if url:
response = self.graph.put_object(
parent_object=parent_object,
connection_name=connection_name,
message=text,
link=url,
)
else:
response = self.graph.put_object(
parent_object=parent_object,
connection_name=connection_name,
message=text,
)
if self.debug:
print(response)
return response
except Exception as err:
print("ERROR: could not post stuff on Facebook! X_X", err)
return None
def update(self, **kwargs):
raise NotImplementedError
def delete(self, **kwargs):
raise NotImplementedError
def fetch_metrics(graph_id, metrics, token=None):
"""Fetch Facebook Insights metrics for an object with a given id.
Parameters
----------
graph_id : str
The Facebook ID of a Graph API object.
metrics : iterable of str
The object's metrics to fetch (e.g. 'page_engaged_users').
token: str
A Facebook Graph API access token
Returns
-------
dict
A dictionary of mappings between metric names and instances
of class 'Metric'.
"""
if not metrics:
raise MetricsNotSpecified('Specify metrics you want to fetch.')
batch = []
for metric in metrics:
request_data = {
'method': 'GET',
'relative_url': '{}/insights/{}/'.format(graph_id, metric)
}
batch.append(request_data)
# ##TODON'T##
global graph_api
if token and (token != graph_api.access_token):
graph_api = GraphAPI(access_token=token, version=api_version)
batch_response = graph_api.put_object(
parent_object='/',
connection_name='',
batch=json.dumps(batch),
)
extracted_metrics = {}
for response in batch_response:
body = json.loads(response['body'])
# (nevimov/2016-11-09): Currently facebook-sdk is not
# able to catch errors in responses to batch requests, so
# we have to take care of those ourselves.
if 'error' in body:
raise GraphAPIError(body)
data = body['data']
if not data:
# We need a better middle ground for this but just
# raising exceptions doesn't work when some of a
# set can legitimately be empty
continue
# raise EmptyData
rearranged_values = {}
for datum in data:
name = datum['name']
period = datum['period']
rearranged_values[period] = datum['values']
extracted_metrics[name] = Metric(name, rearranged_values)
return extracted_metrics
async def my_background_task(self):
await self.wait_until_ready()
channel = self.get_channel(CHANNEL_ID) # channel ID goes here
graph = GraphAPI(access_token=os.getenv('FB_TOKEN'))
count = 0
while not self.is_closed():
count += 1
print("Count :", count)
# dd/mm/YY H:M:S
now = datetime.now()
dt_string = now.strftime("%d/%m/%Y %H:%M:%S")
print("date and time =", dt_string)
'''
FORUMS
'''
print("getiing Old Forum Links ... \n")
old_forum_links = get_old_forum_links(course_dict)
# print(old_forum_links)
print("getiing New Forum Posts ... \n")
new_forum_posts = get_new_forum_posts(course_dict, old_forum_links,
session)
# print(new_forum_posts)
'''
ACTIVITY
'''
print("getiing Old Activity Links ... \n")
old_activity_links = get_old_activity_links(course_dict)
# print(old_forum_links)
print("getiing New Activity Posts ... \n")
new_activity_posts = get_new_activity_posts(
course_dict, old_activity_links, session)
# print(new_activity_posts)
## for testing only
for c_name, post_ara in new_forum_posts.items():
if (len(post_ara) == 0):
continue
for p in post_ara:
print(p)
# FACEBOOK GROUP NOTIFICATION
message = "Auto Generated Post.\n Forum Post ( " + c_name + " )\nLink : " + p.link + " \nTeacher: " + p.author + "\nThank You"
graph.put_object(GROUP_ID, 'feed', message=message)
# DISCORD CHANNEL NOTIFICATION
embedVar = discord.Embed(title="Forum Post ( " + c_name +
" ) :rotating_light: ",
description=p.title,
color=0xb331bd)
embedVar.add_field(name="Link :paperclips: ",
value=p.link,
inline=False)
embedVar.add_field(name="Teacher :person_fencing: ",
value="`" + p.author + "`",
inline=False)
await channel.send(embed=embedVar)
await asyncio.sleep(30) ## 30 seconds
for c_name, post_ara in new_activity_posts.items():
if (len(post_ara) == 0):
continue
for p in post_ara:
print(p)
# FACEBOOK GROUP NOTIFICATION
message = "Auto Generated Post.\n Forum Post ( " + c_name + " )\nLink : " + p.link + " \nTeacher: " + p.author + "\nThank You"
graph.put_object(GROUP_ID, 'feed', message=message)
# DISCORD CHANNEL NOTIFICATION
embedVar = discord.Embed(title="New Activity ( " + c_name +
" ) :boom: ",
description=p.title,
color=0xfc9803)
embedVar.add_field(name="Link :paperclips: ",
value=p.link,
inline=False)
await channel.send(embed=embedVar)
await asyncio.sleep(30) ## 30 seconds
await asyncio.sleep(20 * 60) ## check after 20 minutes
