def yammer_post(self, edit_type, p, org_name):
if p.owner_org is not None:
yammer_poster = yammer_user.Yammer_user().get(c.userobj.id + "." +
p.owner_org)
access_token = yammer_poster.token
groups = yammer_poster.groups
url_base = h.get_site_protocol_and_host()
url = url_base[0] + '://' + url_base[1] + toolkit.url_for(
controller='package', action='read', id=p.name)
yammer = yampy.Yammer(access_token=access_token)
for group_id in groups:
if edit_type == 'deleted':
message = 'The {} dataset has been {} from {}'.format(
p.name, edit_type, org_name)
yammer.messages.create(message,
group_id=group_id,
topics=['Dataset', edit_type])
elif edit_type == 'created':
message = 'The {} dataset has been {} for {}, you can see it here: {}'.format(
p.name, edit_type, org_name, url)
yammer.messages.create(message,
group_id=group_id,
topics=['Dataset', edit_type])
elif edit_type == 'updated':
message = 'The {} dataset has been {} for {}, you can see the updates here: {}'.format(
p.name, edit_type, org_name, url)
yammer.messages.create(message,
group_id=group_id,
topics=['Dataset', edit_type])
def main():
parser = ArgumentParser()
parser.add_argument('--config-file', action='store')
parser.add_argument('--dry-run', action='store_true')
parser.add_argument('--begin-date', action='store', default=None)
parser.add_argument('--last-date', action='store', default=None)
args = parser.parse_args()
config = Config.load(config_file_path=args.config_file)
logging.basicConfig(filename=config.logfile_path(),
format='%(asctime)s %(levelname)s %(message)s')
begin_date, last_date = load_date_range(
config,
parse_date_if(args.begin_date),
parse_date_if(args.last_date),
)
config.set_date_range(begin_date, last_date)
if begin_date > last_date:
logging.info("begin_date {} is later than end_date {}, do nothing")
sys.exit(1)
elif not args.dry_run:
yammer = yampy.Yammer(access_token=config.access_token())
yammer.messages.create(
create_message_body(config).encode(u'utf-8'),
group_id=config.group_id(),
)
append_history(config)
def messages_choice(node, kw):
request = node.bindings['request']
root = request.root
yammer_connectors = list(root.get_connectors(YAMMER_CONNECTOR_ID))
yammer_connector = yammer_connectors[0] if yammer_connectors else None
access_token = yammer_connector.get_access_tokens(get_current()).get('access_token', None) \
if yammer_connector else None
values = []
page = ''
limit = 10
ajax_url = None
if yammer_connector and access_token:
try:
yammer = yampy.Yammer(access_token=access_token)
messages = yammer.client.get('/messages',
threaded=True,
limit=limit)
page = messages['messages'][-1]['id']
values = [(str(e['id']),
html_to_text(e['body']['plain'][:150]) + '...')
for e in messages['messages']]
if messages['meta']['older_available']:
ajax_url = request.resource_url(
root, '@@yammerapi', query={'op': 'find_yammer_messages'})
except Exception as error:
log.warning(error)
return AjaxCheckBoxWidget(
values=values,
url=ajax_url,
limit=limit,
page=page,
multiple=True,
)
def __init__(self, access_token=None):
'''
authenticator = yampy.Authenticator(client_id=MY_CLIENT_ID, client_secret=MY_CLIENT_SECRET)
auth_url = authenticator.authorization_url(redirect_uri=REDIRECT_URI)
print("Debug auth_url: {}".format(auth_url))
auth_url = \
'https://www.yammer.com/dialog/oauth?client_id=2fxbPxiDYwtM40yN3m0fQ&redirect_uri=https%3A%2F%2Fyammerstate.herokuapp.com'
code = "xMK0kj1bGHmCp6gELwX44Q"
access_data = authenticator.fetch_access_data(code)
access_token = access_data.access_token.token
print("DEBUG access_token: {}".format(access_token))
'''
if access_token == None:
print("DEBUG My_Crawler, token = None")
return
self.yampy = yampy.Yammer(access_token=access_token)
self.user_info = self.yampy.users.find_current()
#print("DEBUG self. user_info: {}".format(self.user_info))
#dynamicly add method
self.yampy.messages.from_group = MethodType(from_group, self.yampy.messages)
print("DEBUG My crawler init finished")
def try_get_groups(self):
if self.is_auth() == False:
return None
yammer = yampy.Yammer(access_token=self.get_access_token())
groups = yammer.client.get("/groups")
return groups
def get_message_data(request, message_or_id, access_token, include_topics=False, include_replies=False):
yammer = yampy.Yammer(access_token=access_token)
message = {}
message_id = None
if isinstance(message_or_id, dict):
message = message_or_id
message_id = message_or_id['id']
else:
message_id = message_or_id
message = yammer.messages.find(message_id=message_id)
if message:
# get author
user_id = message['sender_id']
user_info = yammer.users.find(user_id)
user_networks = user_info.get('network_domains')
source_data = {
'app_name': YAMMER_CONNECTOR_ID,
'id': user_info.get('id'),
'network_domains': user_networks,
'access_token': None
}
user_data = {
'first_name': user_info.get('first_name'),
'last_name': user_info.get('last_name'),
'email': user_info.get('email')
}
user = get_or_create_user(request, {
'source_data': source_data,
'user_data': user_data,
}, False)
# get files
attached_files = upload_files(yammer, message['attachments'])
# get keywords
keywords = []
thread_id = message['thread_id']
if include_topics and thread_id:
thread = yammer.threads.find(thread_id)
keywords = [t['name'] for t in thread['references']
if t['type'] == 'topic']
# get replies
replies_result = {}
if include_replies and thread_id:
replies = yammer.messages.in_thread(thread_id)
replies_result = _get_repleis(
request, replies['messages'], message_id, access_token)
content_body = html_to_text(message['body']['plain'])
return {
'title': content_body[:50]+' ...',
'text': content_body,
'keywords': keywords,
'attached_files': attached_files,
'author': user
}, replies_result
return {}, {}
def test_reading_and_updating_current_user(self, access_token):
yammer = yampy.Yammer(access_token)
test_group_name = 'Test Group'
cur_user = yammer.users.find_current()
new_group = yammer.groups.create(test_group_name)
self.assertIn("creator_id", new_group)
self.assertIn("full_name", new_group)
self.assertEqual(new_group.full_name, test_group_name)
self.assertEqual(new_group.creator_id, cur_user.id)
result = yammer.groups.delete(new_group)
self.assertTrue(result)
def test_liking_and_unliking_messages(self, access_token):
yammer = yampy.Yammer(access_token)
message = self.message_not_liked_by_current_user(yammer)
me = yammer.users.find_current()
yammer.messages.like(message)
reloaded_message = yammer.messages.find(message)
self.assert_user_likes_message(me, reloaded_message)
yammer.messages.unlike(message)
reloaded_message = yammer.messages.find(message)
self.assert_user_does_not_like_message(me, reloaded_message)
def test_posting_reading_and_deleting_messages(self, access_token):
yammer = yampy.Yammer(access_token)
test_message = "The time is %s" % datetime.now()
result = yammer.messages.create(body=test_message)
new_message = result.messages[0]
self.assertEqual(new_message.body.plain, test_message)
all_messages = yammer.messages.all()
self.assertIn(test_message, str(all_messages))
yammer.messages.delete(new_message.id)
all_messages = yammer.messages.all()
self.assertNotIn(test_message, str(all_messages))
def test_reading_and_updating_current_user(self, access_token):
yammer = yampy.Yammer(access_token)
current_user = yammer.users.find_current()
self.assertIn("id", current_user)
self.assertIn("full_name", current_user)
user_id = current_user.id
original_full_name = current_user.full_name
result = yammer.users.update(user_id, full_name="Just Testing")
self.assertTrue(result)
updated_user = yammer.users.find_current()
self.assertIn("full_name", updated_user)
self.assertEqual("Just Testing", updated_user.full_name)
result = yammer.users.update(user_id, full_name=original_full_name)
self.assertTrue(result)
def try_get_messages(self,
group_id,
newest_message_id=None,
oldest_message_id=None):
if self.is_auth() == False:
return None
yammer = yampy.Yammer(access_token=self.get_access_token())
if newest_message_id != None:
params = {'newer_than': newest_message_id}
elif oldest_message_id != None:
params = {'older_than': oldest_message_id}
else:
params = {}
messages = yammer.client.get('/messages/in_group/' + group_id,
**params)
return messages
def find_yammer_messages(self):
root = self.request.root
yammer_connectors = list(root.get_connectors(YAMMER_CONNECTOR_ID))
yammer_connector = yammer_connectors[0] if yammer_connectors else None
access_token = yammer_connector.get_access_tokens(get_current()).get('access_token', None) \
if yammer_connector else None
if yammer_connector and access_token:
page = self.params('page')
limit = self.params('limit')
try:
yammer = yampy.Yammer(access_token=access_token)
messages = yammer.client.get('/messages',
older_than=page,
threaded=True,
limit=limit)
if messages['messages']:
current_ideas = [
i.source_data[YAMMER_CONNECTOR_ID]['id']
for i in find_yammer_content([Iidea])
]
entries = [{
'id':
e['id'],
'text':
html_to_text(e['body']['plain'][:150]) + '...',
'imported':
str(e['id']) in current_ideas
} for e in messages['messages']]
return {
'items': entries,
'total_count': len(messages['messages']),
'has_next': messages['meta']['older_available'],
'next_page': messages['messages'][-1]['id']
}
except Exception as error:
log.warning(error)
return {'items': [], 'total_count': 0}
def mysubscriber_object_published(event):
content = event.object
author = getattr(content, 'author', None)
keywords = content.keywords
request = get_current_request()
root = request.root
yammer_connectors = list(root.get_connectors(YAMMER_CONNECTOR_ID))
yammer_connector = yammer_connectors[0] if yammer_connectors else None
if yammer_connector and yammer_connector.enable_notifications:
only_from_default = getattr(
yammer_connector, 'only_from_default', False)
default_access_token = getattr(yammer_connector, 'access_token', '')
access_token = None
if only_from_default and default_access_token:
access_token = default_access_token
else:
access_token = yammer_connector.get_access_tokens(author).get('access_token', None)
access_token = access_token or default_access_token
if access_token:
yammer = yampy.Yammer(access_token=access_token)
# Post a new messages
msg = '{title} \n\n {text} \n\n {url}'.format(
title=content.title,
text=content.presentation_text(150)+'...',
url=request.resource_url(content, '@@index'))
message_data = yammer.messages.create(
msg,
topics=keywords)
if isinstance(message_data, dict) and \
message_data.get('messages', []):
content.set_source_data({
'app_name': 'yammer',
'id': str(message_data['messages'][0]['id'])
})
content.reindex()
def authenticate(self):
access_token = self.authenticator.fetch_access_token(self.access_code)
return yampy.Yammer(access_token=access_token)
def __init__(self):
self.__yammer = yampy.Yammer(access_token=os.getenv(ACCESS_TOKEN))
def getAnswers():
myClient = pymongo.MongoClient(mongo_connectStr)
mydb = myClient['helpit']
user_collection = mydb['account']
topic_collection = mydb['topic']
analysis_collection = mydb['analysis']
user_accounts = user_collection.find({'source': 'yammer'})
today = datetime.date.today()
lastweek = today - datetime.timedelta(days=7)
start = datetime.datetime(lastweek.year, lastweek.month, lastweek.day, 0,
0, 0)
yammer = yampy.Yammer(access_token='107-IEsv2JUsPZRwWvUQ3t1EaA')
oldID = None
for account in user_accounts:
if 'account' in account.keys():
accountid = int(account['account'])
upn = account['upn']
isDone = False
while True:
data = yammer.messages.from_user(user_id=accountid,
older_than=oldID)
messages = data['messages']
if not messages:
break
mlen = len(messages)
if mlen == 0:
break
for j in range(mlen):
m = messages[j]
mid = m['id']
if j == mlen - 1:
oldID = mid
post_time = datetime.datetime.strptime(
m['created_at'][:-6], '%Y/%m/%d %H:%M:%S')
if post_time < start:
isDone = True
break
if m['replied_to_id'] is None or m['replied_to_id'] == "":
continue
content = m['body']['parsed']
topics = getTopics(topic_collection, content)
if len(topics) == 0:
continue
score = 0.5
comment_count = 0
threadId = m['thread_id']
oldID_thread = None
isDone_thread = False
while True:
tdata = yammer.messages.in_thread(
thread_id=threadId, older_than=oldID_thread)
tmessages = tdata['messages']
tlen = len(tmessages)
if tlen == 0:
break
for k in range(tlen):
if k == tlen - 1:
oldID_thread = tmessages[k]['id']
ptime_thread = datetime.datetime.strptime(
tmessages[k]['created_at'][:-6],
'%Y/%m/%d %H:%M:%S')
if ptime_thread < start:
isDone_thread = True
break
if tmessages[k]['replied_to_id'] == mid:
comment_count += 1
score += getSentiment(
tmessages[k]['body']['parsed'])
if isDone_thread:
break
analysis_collection.insert_one({
'userId': accountid,
'upn': upn,
'source': 'yammer',
'post_time': post_time,
'comment_count': comment_count,
'score': score,
'topic': topics
})
if isDone:
break
report_col = mydb['report']
stime = datetime.datetime(lastweek.year, lastweek.month, lastweek.day, 0,
0, 0)
today_time = datetime.datetime(today.year, today.month, today.day, 0, 0, 0)
while stime < today_time:
stime += datetime.timedelta(days=1)
dtmp = stime + datetime.timedelta(days=1)
adocs = analysis_collection.aggregate([{
"$match": {
'post_time': {
'$lt': dtmp,
'$gte': stime
},
'source': 'yammer'
}
}, {
"$group": {
'_id': '$upn',
'score': {
'$sum': '$score'
},
'count': {
'$sum': 1
}
}
}])
for a in adocs:
report_col.insert_one({
'upn': a['_id'],
'source': 'yammer',
'count': a['count'],
'score': a['score'],
'date': time.mktime(stime.timetuple()) * 1000
})
import yampy
import random
import config
import time
import json
group_id = config.group_id
access_token = config.access_token #as a string
yammer = yampy.Yammer(access_token=access_token) #as a string
picked = {column: [] for column in 'BINGO'}
savegame = r'.\savegame.txt'
def auth():
try:
user = yammer.client.get('/users/current')
return True
except yampy.errors.UnauthorizedError as e:
print(
'UnauthorizedError: Please refresh access_token at \n'
'https://www.yammer.com/client_applications and update BingoBotConfig.py'
)
return False
def pick_new(number=None, picked=picked):
'''Add a new ball to the list'''
if not number:
number = random.randint(1, 75)
letter = f'{"BINGO"[(number - 1) // 15]}'
if number not in picked[letter]:
MAX_REQ_PER_INTERVAL = 10 # How many Yammer requests you can make in 30 seconds. Once reached, wait 30 seconds.
# Various Yammer threads for testing
GMAIL_THREAD = 414357831 # 268-ish
AURORA_THREAD = 387871026 # 12 messages
PASTEBIN_THREAD = 421373941 # Exactly 20 messages (as of 27-JUL-2014)
# Setup authenticator - Don't delete any of this! You'll need it when the access token expires
authenticator = yampy.Authenticator(client_id, client_secret)
#auth_url = authenticator.authorization_url(redirect_uri)
#print(auth_url) #Debug: show the code to stdout
#access_token = authenticator.fetch_access_token(code)
#print(access_token)
#Get your Yammer object for making requests
yammer = yampy.Yammer(access_token)
# Create a dictionary from the Yammer messages.
# The RESTful API to the "messages" endpoint will result in one response with two blocks of structures within:
# 1. messages: the actual posts/replies/polls within the message thread
# 2. references: usually users.
# Start by grabbing the latest reply in thread and go backwards from there using message ID.
# Start without newer_than or older_than parameters to get the newestMsgID.
while moreToProcess:
# Be respectful of Yammer API limits; else we get throttled / banned.
restCall += 1
if restCall % MAX_REQ_PER_INTERVAL == 0:
import yampy
import json
# authenticator = yampy.Authenticator(client_id='',
# client_secret='')
# redirect_uri = "http://localhost:8081"
# auth_url = authenticator.authorization_url(redirect_uri=redirect_uri)
# access_token = authenticator.fetch_access_token(authenticator)
# access_data = authenticator.fetch_access_data('{access token of yammer}')
'''
使用yammer的SDK yampy抓取原始语料保存到文件
使用python2
yampy在python3下运行有问题
'''
yammer = yampy.Yammer(access_token='{access token of yammer}')
# limit调节一次获取的消息条数
messages = yammer.messages.all(limit=20)
json = json.dumps(messages)
with open('./raw.json', 'w') as f:
f.write(json)
f.close()
def setUp(self):
super(UserIntegrationTest, self).setUp()
self.yammer = yampy.Yammer(
access_token="valid_token",
base_url="http://localhost:5000/api/v1",
)
import json
import datetime
from dateutil.relativedelta import relativedelta
from datetime import datetime
from dotenv import load_dotenv, find_dotenv
import smtplib
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
from time import sleep
import sys
reload(sys)
sys.setdefaultencoding('utf8')
load_dotenv(find_dotenv())
yammer = yampy.Yammer(access_token=os.environ.get('YAMMER_TOKEN'))
recipient_email = os.environ.get('RECIPIENT_EMAIL')
from_email = os.environ.get('SENDER_EMAIL')
def employee_anniversary(per_page, current_page, anniversaries=[]):
url = 'https://rimon.namely.com/api/v1/profiles.json?filter[user_status]=active&per_page=' + str(
per_page) + '&page=' + str(current_page)
token = os.environ.get('TOKEN')
payload = "{}"
headers = {'authorization': 'Bearer ' + token}
response = requests.request("GET", url, data=payload, headers=headers)
