def __prep_new_session(session_form):
"""
Prepare a new Session instance, validating Conference and User details
:param session_form:
:return: Session ready for processing of speakers
"""
if not isinstance(session_form, SessionForm):
raise TypeError('expected SessionForm')
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
if not session_form.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# fetch the key of the ancestor conference
conf_key = ndb.Key(urlsafe=session_form.websafeConfKey)
conf = conf_key.get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' %
session_form.websafeConfKey)
# check that user is conference owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the conference owner can create sessions.')
# create Session and set up the parent key
return Session.from_form(session_form)
def get_user_details(self, username: str) -> str:
url = 'https://api.twitter.com/2/users/by/username/{}'.format(username)
params = {
'user.fields': 'name,description,url,created_at,public_metrics'
}
json_response = send_get_request(url, params)
errors = json_response.get('errors', None)
if errors:
return '\n'.join([error.get('detail', '') for error in errors])
data = json_response.get('data', {})
details_str = 'Name: {}'.format(data.get('name', ''))
details_str += '\nBio: {}'.format(data.get('description', ''))
website = data.get('url', '')
if website:
details_str += '\nWebsite: {}'.format(website)
details_str += '\nJoined at: {}'.format(data.get('created_at', ''))
public_metrics = data.get('public_metrics', {})
details_str += '\nFollowing: {}'.format(
public_metrics.get('following_count', -1))
details_str += '\nFollowers: {}'.format(
public_metrics.get('followers_count', -1))
details_str += '\nTweets: {}'.format(
public_metrics.get('tweet_count', -1))
if public_metrics.get('following_count', 2000) < 2000:
following_users = self.get_all_following_users(
get_user_id(username))
details_str += '\nFollow each other: {}'.format(
'Yes' if self.username in following_users else 'No')
return details_str
def get_spotify_user_auth():
"""Allows user to login to Spotify and this app"""
try:
session.pop('token', None)
session.pop('refresh_token', None)
session.pop('user_id', None)
code = request.args.get('code')
resp = requests.post(
'https://accounts.spotify.com/api/token',
data={
"grant_type": "authorization_code",
"code": code,
"redirect_uri":
"https://the-spotify-playground.herokuapp.com/user_auth",
"client_id": CLIENT_ID,
"client_secret": CLIENT_SECRET
}).json()
token = resp['access_token']
refresh_token = resp['refresh_token']
session['token'] = token
session['refresh_token'] = refresh_token
session['user_id'] = get_user_id()
return redirect('/playground')
# A KeyError occurs if a user tries to access this route directly without having authenticated before
except KeyError:
return redirect('/')
def profile_from_user():
"""
Return user Profile from datastore, creating new one if non-existent.
:return: Profile model for the current endpoint user
"""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
# get Profile from datastore
user_id = get_user_id(user)
p_key = ndb.Key(Profile, user_id)
profile = p_key.get()
# create new Profile if not there
if not profile:
profile = Profile(
key=p_key,
displayName=user.nickname(),
mainEmail=user.email(),
teeShirtSize=str(TeeShirtSize.NOT_SPECIFIED),
)
profile.put()
return profile # return Profile
def profile_from_user():
"""
Return user Profile from datastore, creating new one if non-existent.
:return: Profile model for the current endpoint user
"""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# get Profile from datastore
user_id = get_user_id(user)
p_key = ndb.Key(Profile, user_id)
profile = p_key.get()
# create new Profile if not there
if not profile:
profile = Profile(
key=p_key,
displayName=user.nickname(),
mainEmail=user.email(),
teeShirtSize=str(TeeShirtSize.NOT_SPECIFIED),
)
profile.put()
return profile # return Profile
def _get_profile_from_user(self):
"""Return user Profile from datastore, creating new one if
non-existent."""
# Make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Try to retrieve an existing profile...
user_id = get_user_id(user)
key = ndb.Key(Profile, user_id)
profile = key.get()
# ... and if not exists, create a new Profile from logged in user data
if not profile:
profile = Profile(
userId = user_id,
key = key,
displayName = user.nickname(),
mainEmail= user.email(),
teeShirtSize = str(TeeShirtSize.NOT_SPECIFIED),
)
# Create the profile in datastore
profile.put()
return profile
def __prep_new_session(session_form):
"""
Prepare a new Session instance, validating Conference and User details
:param session_form:
:return: Session ready for processing of speakers
"""
if not isinstance(session_form, SessionForm):
raise TypeError('expected SessionForm')
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
if not session_form.name:
raise endpoints.BadRequestException("Session 'name' field required")
# fetch the key of the ancestor conference
conf_key = ndb.Key(urlsafe=session_form.websafeConfKey)
conf = conf_key.get()
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % session_form.websafeConfKey
)
# check that user is conference owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the conference owner can create sessions.')
# create Session and set up the parent key
return Session.from_form(session_form)
async def add_team_member(ack, say, command, logger):
try:
team_member_id = get_user_id(command["text"])
duplicate = Employee.query.filter(
Employee.slack_id == team_member_id).all()
if not duplicate:
url = f"{slack_api}/users.profile.get?token={slack_token}&user={team_member_id}"
response = requests.get(url)
team_member_profile = response.json()
new_uifw_team_member = Employee(
team_member_id,
team_member_profile["profile"]["real_name"],
team_member_profile["profile"]["image_original"],
team_member_profile["profile"]["title"],
)
new_uifw_team_member.insert()
slackbot_response = f"{team_member_profile['profile']['real_name']} has been added to UIFW"
else:
if len(duplicate) > 1:
name = duplicate[0].name
else:
name = duplicate.name
slackbot_response = f"{name} is already a member of UIFW"
# Acknowledge command request
await ack()
await say(slackbot_response)
except Exception as e:
logger.error(f"Error adding team member: {e}")
def replay(argv, token):
# get user's uuid
uuid = get_user_id(token)
# check files's protocol
file_protocol, remain = get_file_protocol(argv, 'fileput', 'source')
try:
if file_protocol == 'pithos':
url = pithos_url + "/" + uuid + remain
headers = {'X-Auth-Token':'{0}'.format(token)}
r=requests.get(url, headers=headers)
if r.status_code == 200:
# load the experiment from pithos file
script = yaml.load(r.text)
else:
print 'File not found on Pithos'
exit(error_fatal)
else:
# load the experiment from local file
with open(argv, 'r') as f:
script = yaml.load(f)
except Exception, e:
print e.strerror
exit(error_fatal)
def add_services():
url = get_url() + "services"
headers = {
'content-type': 'application/json'
}
data = {
"name": "volume provision",
"description": "Volume Service",
"tenant_id": get_project_id(),
"user_id": get_user_id(),
"input": "",
"constraint": "",
"group": "provisioning",
"workflows": [
{
"definition_source": "opensds.provision-volume",
"wfe_type": "st2"
},
{
"definition_source": "opensds.snapshot-volume",
"wfe_type": "st2"
}
]
}
resp = requests.post(url=url, data=json.dumps(data), headers=headers)
if resp.status_code != 200:
print("Request for Register Services failed", resp.status_code)
print(resp.text)
def save_message(self, msg, skip_reply=False):
user_id = u.get_user_id(msg)
msg_copy = msg.copy()
msg_copy['date'] = datetime.datetime.utcnow()
self.db.messages.insert_one(msg_copy)
if not skip_reply:
self.sendMessage(user_id, 'Дамп из телегарма сохранен')
def save_message(self, msg, skip_reply=False):
user_id = u.get_user_id(msg)
msg_copy = msg.copy()
msg_copy['date'] = datetime.datetime.utcnow()
self.db.messages.insert_one(msg_copy)
if not skip_reply:
self.sendMessage(user_id, 'Дамп из телегарма сохранен')
def _get_profile_from_user(self):
"""Return user Profile from datastore, creating new one if
non-existent."""
# Make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Try to retrieve an existing profile...
user_id = get_user_id(user)
key = ndb.Key(Profile, user_id)
profile = key.get()
# ... and if not exists, create a new Profile from logged in user data
if not profile:
profile = Profile(
userId=user_id,
key=key,
displayName=user.nickname(),
mainEmail=user.email(),
teeShirtSize=str(TeeShirtSize.NOT_SPECIFIED),
)
# Create the profile in datastore
profile.put()
return profile
def get_file_by_token():
token = request.args.get('token')
owner = utils.get_user_id(token)
data = mongo.get_all_files(owner)
response = jsonify(data)
response.status_code = 200
return response
def _create(request):
"""
Create or update Conference object, returning ConferenceForm/request.
:param request:
:return:
"""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
if not request.name:
raise endpoints.BadRequestException(
"Conference 'name' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in
request.all_fields()}
del data['websafeKey']
del data['organizerDisplayName']
# add default values for those missing (data model & outbound Message)
for df in CONF_DEFAULTS:
if data[df] in (None, []):
data[df] = CONF_DEFAULTS[df]
setattr(request, df, CONF_DEFAULTS[df])
# convert dates from strs to Date objects; set month based on start_date
if data['startDate']:
data['startDate'] = datetime.strptime(data['startDate'][:10],
"%Y-%m-%d").date()
data['month'] = data['startDate'].month
else:
data['month'] = 0
if data['endDate']:
data['endDate'] = datetime.strptime(data['endDate'][:10],
"%Y-%m-%d").date()
# set seatsAvailable to be same as maxAttendees on creation
if data["maxAttendees"] > 0:
data["seatsAvailable"] = data["maxAttendees"]
# generate Profile Key based on user ID and Conference
# ID based on Profile key get Conference key from ID
p_key = ndb.Key(Profile, user_id)
c_id = Conference.allocate_ids(size=1, parent=p_key)[0]
c_key = ndb.Key(Conference, c_id, parent=p_key)
data['key'] = c_key
data['organizerUserId'] = request.organizerUserId = user_id
# create Conference, send email to organizer confirming
# creation of Conference & return (modified) ConferenceForm
Conference(**data).put()
taskqueue.add(params={'email': user.email(),
'conferenceInfo': repr(request)},
url='/tasks/send_confirmation_email'
)
return request
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
notes, archived_notes = utils.get_all_notes(user_id)
return {'ok': True, 'notes': notes, 'archived_notes': archived_notes}
def get_file(filename):
token = request.args.get('token')
owner = utils.get_user_id(token)
try:
res = mongo.get_file(filename, owner)
return res
except mongo.FileError:
return abort(400)
def _create_session_object(self, request):
"""Create or update Session object, returning SessionForm/request"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required")
# get Conference object from request; bail if not found
c_key = ndb.Key(urlsafe=request.websafeConferenceKey)
conf = c_key.get()
if not conf:
raise endpoints.NotFoundException(
"No conference found with key: %s" % request.websafeConferenceKey)
# Check if user is authorized to create sessions for this conference
user_id = get_user_id(user)
p_key = ndb.Key(Profile, user_id)
profile = p_key.get()
c_owner = conf.key.parent().get()
if profile is not c_owner:
raise endpoints.UnauthorizedException(
"Sessions can be only created by conference owner")
if not request.name:
raise endpoints.BadRequestException("Name field required")
if not request.speaker:
raise endpoints.BadRequestException("Speaker field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in
request.all_fields()}
del data['websafeConferenceKey']
del data['websafeSessionKey']
# convert dates and times from strings to Date objects
if data["date"]:
data["date"] = datetime.strptime(data["date"][:10],
"%Y-%m-%d").date()
if data["startTime"]:
data["startTime"] = datetime.strptime(data["startTime"][:5],
"%H:%M").time()
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data["key"] = s_key
session = Session(**data)
session.put()
taskqueue.add(params={'speaker': request.speaker,
'websafeConferenceKey': request.websafeConferenceKey},
url='/tasks/set_featured_speaker')
return self._copy_session_to_form(session)
def add_todo(cls, params=None, _token=None):
if params is None:
return {}
payload = {
'userid': get_user_id(params['assignee']),
'create_time': int(time.time() * 1000),
'title': params['title'],
'url': params['url'],
'formItemList': {
'title': params['title'],
'content': params['content']
},
'originator_user_id': get_user_id(params['user'])
}
url = 'https://oapi.dingtalk.com/topapi/workrecord/add'
return cls._post(url, payload, _token)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('last_modified', type=int, required=True)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
diff = utils.get_diff(user_id, args['last_modified'])
return {'ok': True, 'updates': diff}
def _get_user(self):
"""helper -- get user"""
cur_user = endpoints.get_current_user()
if not cur_user:
raise endpoints.UnauthorizedException('Authourization required')
user_id = get_user_id(cur_user)
p_key = ndb.Key(User, user_id)
user = p_key.get()
if not user:
raise endpoints.NotFoundException('Please create as a user first')
return user
def get(self, note_id):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
note = utils.get_note(user_id, note_id)
if not note:
abort(404, ok=False, error='note not found')
return note
def detail_quest(quest_id):
quest = Quest.query.get(quest_id)
user_id = get_user_id()[0]
group = Group.query.get(quest.group_id)
owner_id = group.owner_id
users = db.session.query(User).join(Questmember).filter(Questmember.quest_id == quest.id)
d = quest.date_expired - timedelta(minutes = get_tz_offset())
date_expired = '%d/%d/%d %d:%d'%(d.year, d.month, d.day, d.hour, d.minute)
return render_template('quest/detail.html', quest=quest, users=users, user_id=user_id, owner_id=owner_id, date_expired = date_expired)
def delete(self, note_id):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
res_del = utils.del_note(user_id, note_id, settings.mark_as_deleted)
if res_del:
return {'ok': True}
else:
abort(404, ok=False, error='note not found')
def __init__(self, username: str, telegram_chat_ids: str):
self.sleeper = Sleeper(120)
self.username = username
self.user_id = get_user_id(username)
self.following_users = self.get_all_following_users(self.user_id)
logging.info(
'Init monitor succeed.\nUsername: {}\nUser id: {}\nFollowing users: {}'
.format(username, self.user_id, self.following_users))
self.telegram_notifier = TelegramNotifier(chat_ids=telegram_chat_ids,
username=username,
module='Following')
self.last_log_time = datetime.now()
def get_my_stars(year):
config = read_config()
cookie = get_cookie(config)
bord_id = get_board_id(config)
user_id = get_user_id(config)
board_url = LIDERSHIP_BOARD.format(year=year, board=bord_id)
response = requests.post(board_url, cookies={'session': cookie})
try:
response_json = response.json()
return response_json['members'][user_id]['stars']
except Exception:
return ''
def __init__(self, username: str, telegram_chat_ids: str):
self.sleeper = Sleeper(10)
self.user_id = get_user_id(username)
tweets = self.get_tweets()
self.last_tweet_id = tweets[0]['id']
logging.info(
'Init monitor succeed.\nUsername: {}\nUser id: {}\nLast tweet: {}'.
format(username, self.user_id, tweets[0]))
self.telegram_notifier = TelegramNotifier(chat_ids=telegram_chat_ids,
username=username,
module='Tweet')
self.last_log_time = datetime.now()
def _create_conference_object(self, request):
"""Create or update Conference object, returning ConferenceForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
if not request.name:
raise endpoints.BadRequestException("Conference 'name' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
del data['organizerDisplayName']
# add default values for those missing (both data model & outbound Message)
for df in DEFAULTS:
if data[df] in (None, []):
data[df] = DEFAULTS[df]
setattr(request, df, DEFAULTS[df])
# convert dates from strings to Date objects; set month based on start_date
if data['startDate']:
data['startDate'] = datetime.strptime(data['startDate'][:10], "%Y-%m-%d").date()
data['month'] = data['startDate'].month
else:
data['month'] = 0
if data['endDate']:
data['endDate'] = datetime.strptime(data['endDate'][:10], "%Y-%m-%d").date()
# set seatsAvailable to be same as maxAttendees on creation
# both for data model & outbound Message
if data["maxAttendees"] > 0:
data["seatsAvailable"] = data["maxAttendees"]
setattr(request, "seatsAvailable", data["maxAttendees"])
# make Profile Key from user ID
p_key = ndb.Key(Profile, user_id)
# allocate new Conference ID with Profile key as parent
c_id = Conference.allocate_ids(size=1, parent=p_key)[0]
# make Conference key from ID
c_key = ndb.Key(Conference, c_id, parent=p_key)
data['key'] = c_key
data['organizerUserId'] = request.organizerUserId = user_id
# create Conference & return (modified) ConferenceForm
Conference(**data).put()
return request
def get_conferences_created(self, request):
"""Return conferences created by user."""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
# create ancestor query for all key matches for this user
confs = Conference.query(ancestor=ndb.Key(Profile, user_id))
prof = ndb.Key(Profile, user_id).get()
# return set of ConferenceForm objects per Conference
return ConferenceForms(
items=[self._copy_conference_to_form(conf, getattr(prof, 'displayName')) for conf in confs]
)
async def remove_team_member(ack, say, command, logger):
try:
user_id = get_user_id(command["text"])
team_member = Employee.query.filter(Employee.slack_id == user_id).all()
if team_member:
for member in team_member:
member.delete()
slackbot_response = f"That Backstopper was removed from UIFW" #todo fetch name or @user
else:
slackbot_response = f"That Backstopper isn't a member of UIFW" #todo fetch name or @user
# Acknowledge command request
await ack()
await say(slackbot_response)
except Exception as e:
logger.error(f"Error removing team member: {e}")
def hook():
if request.method == 'GET':
abort(404)
data = request.json
print('---get issue hook---')
print(data)
print('--------------------')
if not isinstance(data, dict):
abort(404)
if data.get('object_kind') != 'issue' or data.get('event_type' != 'issue'):
print('not issue event!')
abort(404)
if data.get('project', {}).get('name') != 'drobot':
print('not drobot repo!')
abort(404)
action = data['object_attributes']['action'] # open or close
user = data['user']['username']
assignee = data['assignees'][0]['username']
title = data['object_attributes']['title']
url = data['object_attributes']['url']
content = data['object_attributes']['description']
resp = {}
if action == 'open':
resp = ToDoManager.add_todo(
params=dict(assignee=assignee, user=user, title=title, url=url, content=content)
)
ding_send('Gitlab新增任务[{}/{}]，已同步到钉钉待办'.format(title, assignee))
elif action == 'close':
record_id = None
user_id = get_user_id(assignee)
all_todos = ToDoManager.get_todo(user_id)
for record in all_todos.get('records', {}).get('list', []):
if record.get('url') == url:
record_id = record['record_id']
break
if record_id:
resp = ToDoManager.delete_todo(user_id, record_id)
ding_send('Gitlab删除任务[{}/{}]，已同步到钉钉待办'.format(title, assignee))
print('---action response---')
print(resp)
print('---------------------')
return jsonify(resp)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('header', type=str, required=True)
parser.add_argument('date', type=int, required=True)
parser.add_argument('longitude', type=float, required=True)
parser.add_argument('lattitude', type=float, required=True)
parser.add_argument('location_str', type=str, required=False)
parser.add_argument('description', type=str, required=False)
parser.add_argument('is_archived', type=bool, required=True)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
post_res = utils.post_note(user_id, args)
if post_res:
return {'ok': True, 'note': post_res}
abort(500, ok=False, error='unexpected error')
def put(self, note_id):
parser = reqparse.RequestParser()
parser.add_argument('token', type=str, required=True)
parser.add_argument('header', type=str, required=True)
parser.add_argument('date', type=int, required=True)
parser.add_argument('longitude', type=float, required=True)
parser.add_argument('lattitude', type=float, required=True)
parser.add_argument('location_str', type=str, required=False)
parser.add_argument('description', type=str, required=False)
args = parser.parse_args()
user_id = utils.get_user_id(args['token'])
if not user_id:
abort(403, ok=False, error='invalid token')
put_res = utils.put_note(user_id, note_id, args)
if put_res:
return {'ok': True, 'note': put_res}
else:
return abort(500, ok=False, error='note not found')
def get_conferences_created(self, request):
"""Return conferences created by user."""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# make profile key
p_key = ndb.Key(Profile, get_user_id(user))
# create ancestor query for this user
conferences = Conference.query(ancestor=p_key)
# get the user profile and display name
prof = p_key.get()
display_name = getattr(prof, 'displayName')
# return set of ConferenceForm objects per Conference
return ConferenceForms(
items=[self._copy_conference_to_form(conf, display_name) for conf in conferences]
)
def create_user(self, request):
"""Create a User."""
cur_user = endpoints.get_current_user()
if not cur_user:
raise endpoints.UnauthorizedException('Authourization required')
user_id = get_user_id(cur_user)
p_key = ndb.Key(User, user_id)
user = p_key.get()
if not user:
user = User(
key=p_key,
name=cur_user.nickname(),
email=cur_user.email(),
)
user.put()
return StringMessage(message='User {} created!'.format(
cur_user.nickname()))
return StringMessage(message='User already created!')
def user_login(email):
try:
user_id = get_user_id(email)
user = load_user(user_id)
login_user(user)
flash("Logged in as "+current_user.email)
except Exception as e:
print "can't get user"
print e
try:
user = create_user(email)
login_user(user)
flash("Welcome")
except Exception as e:
print "can't create"
print e
db_session.rollback()
abort(401)
identity_changed.send(current_app._get_current_object(), identity=Identity(user.id))
def transaction():
if verify_user(request.headers['jwt']):
if request.method == 'POST':
return add_transaction(request, Session)
elif request.method == 'PUT':
return "2"
elif request.method == 'DELETE':
return "3"
elif request.method == 'GET':
book_id = request.args.get('book_id')
user_id = get_user_id(request.headers['jwt'])
verify_book_access(book_id, user_id)
return json.dumps([
i.serialize
for i in Transaction.query.filter_by(book_id=book_id)
])
return "0"
return '-1'
def get_conferences_created(self, request):
"""Return conferences created by user."""
# make sure user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# make profile key
p_key = ndb.Key(Profile, get_user_id(user))
# create ancestor query for this user
conferences = Conference.query(ancestor=p_key)
# get the user profile and display name
prof = p_key.get()
displayName = getattr(prof, 'displayName')
# return set of ConferenceForm objects per Conference
return ConferenceForms(items=[
self._copy_conference_to_form(conf, displayName)
for conf in conferences
])
async def login():
user_id, login_token = utils.get_user_id(), utils.get_login_token()
just_logged_in = False
if not user_id or not login_token:
#webbrowser.open(SERVER_HOST + '/local-products-login?port='+str(LOCAL_SERVER_PORT), new=0, autoraise=True)
await utils.show_info(
"Sincronizador de archivos",
"No hay ningún usuario guardado. Inicia sesión...")
user_mail, password = await authenticate_box.ask_login()
if user_mail == None or password == None:
exit()
#user_mail= (await aioconsole.ainput("Correo electrónico: ")).strip()
#password= (await aioconsole.ainput("Contraseña: ")).strip()
try:
user_id, login_token = await server.login(mail=user_mail,
password=password)
except RemoteException as e:
await utils.show_warning("Linarand sincronizador de archivos",
"Hubo un problema. " + str(e))
return await login()
utils.set_user_id(user_id)
utils.set_login_token(login_token)
utils.save_data()
just_logged_in = True
try:
username = await server.authenticate(user_id=user_id,
token=login_token)
except RemoteException as e:
await utils.show_warning(
"Sincronizador de archivos",
"Hubo un problema. " + str(e) + ". Eliminando usuario")
utils.set_user_id(None)
utils.set_login_token(None)
utils.save_data()
return await login()
if just_logged_in:
asyncio.ensure_future(
utils.show_info(
"Sincronizador de archivos",
"Sesión iniciada como %s. Puedes ir a la página de Ingeniería Linarand y sincronizar los archivos que desees desde este equipo."
% username))
async def upload_file(path, existing_id=""):
if not path.exists(): return
with load_data_file(path.parent) as parent_data_file:
parent_id = parent_data_file["id"]
if parent_id is None: return
with path.open("rb") as file:
data = FormData(fields=[("existing_id", existing_id),
("product_id", str(parent_id)),
("token", utils.get_login_token()),
("user_id", str(utils.get_user_id()))],
quote_fields=False)
data.add_field("file", file, filename=path.name)
resp = await (await utils.upload_file(
constants.SERVER_HOST + "/_back/product-sync-upload",
data)).json()
with load_data_file(path) as data:
data["id"] = resp.get("id", data.get("id", None))
data["type"] = resp.get("type", data.get("type", None))
data["name"] = path.name
def post_file(filename):
def is_allowed_ext(filename):
extension = filename.split('.')[-1]
return extension in ALLOWED_EXTENSIONS
if request.method == 'POST':
f = request.files['file']
token = request.args.get('token')
owner = utils.get_user_id(token)
try:
if is_allowed_ext(filename):
mongo.save_file(filename, f, owner)
response = jsonify(success=True)
response.status_code = 201
return response
else:
return abort(400)
except mongo.FileError:
logging.info('mongo file error')
return abort(400)
def before_request():
if os.environ.get('SERVER_NAME') == 'localhost':
data = {
'name' : 'somebody',
'fb_id' : '00000000000',
'email' : '*****@*****.**',
'img_url' : '',
'timezone_offset': '-540'
}
user_id = get_user_id_from_database(data)
session.update(data)
if get_user_id():
if request.endpoint in ('index', 'login'):
return redirect(url_for('group'))
else :
if request.endpoint in ('index', 'login'):
pass
else:
return redirect(url_for('index'))
def create_group():
form = GroupForm()
user_id = get_user_id()
if request.method == 'GET':
users = User.query.filter(User.id != user_id)
return render_template('group/create.html', form=form, users=users)
elif request.method == 'POST':
if form.validate_on_submit():
group = Group(
name = form.name.data,
owner_id = user_id,
date_created = datetime.utcnow()
)
db.session.add(group)
db.session.commit()
return redirect(url_for('list'))
else:
return render_template('group/create.html', form=form)
def _update(self, request):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
# update existing conference
conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()
# check that conference exists
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' %
request.websafeConferenceKey
)
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
# copy ConferenceForm/ProtoRPC Message into dict
# data = {field.name: getattr(request, field.name) for field in
# request.all_fields()}
# Not getting all the fields, so don't create a new object; just
# copy relevant fields from ConferenceForm to Conference object
for field in request.all_fields():
data = getattr(request, field.name)
# only copy fields where we get data
if data not in (None, []):
# special handling for dates (convert string to Date)
if field.name in ('startDate', 'endDate'):
data = datetime.strptime(data, "%Y-%m-%d").date()
if field.name == 'startDate':
conf.month = data.month
# write to Conference object
setattr(conf, field.name, data)
conf.put()
prof = ndb.Key(Profile, user_id).get()
return conf.to_form(getattr(prof, 'displayName'))
def get_created(self, request):
"""
Return Conferences created by the requesting User
:param request: Void RPC Message
:return: ConferenceForms containing user-created ConferenceForm's
"""
if not isinstance(request, message_types.VoidMessage):
raise endpoints.BadRequestException()
# make sure user is auth'd
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = get_user_id(user)
# create ancestor query for all key matches for this user
confs = Conference.query(ancestor=ndb.Key(Profile, user_id))
prof = ndb.Key(Profile, user_id).get()
# return set of ConferenceForm objects per Conference
return ConferenceForms(
items=[conf.to_form(getattr(prof, 'displayName')) for conf in confs]
)
def student_search():
token = get_token()
headers = {'Authorization': 'Bearer %s' % token}
if len(sys.argv) < 2 or len(sys.argv) > 3:
error('Invalid arguments')
user_id = get_user_id(sys.argv[1], headers)
if user_id is None:
error('Not a valid user')
if (len(sys.argv) == 3):
flag = sys.argv[2]
else:
flag = None
if (flag == 'staff'):
flag = 'staff?'
endpoint = '/users/%s/' % user_id
url = url_join(endpoint)
response = requests.get(url, headers=headers)
response = bytetodict(response.content)
if response == {}:
error('Login not found')
df = pd.Series(response)
print_infos(df, flag)
def get(self):
#import pdb; pdb.set_trace()
#get request params
notebook_owner=self.request.get('owner')
notebook_name=self.request.get('name')
notebook_access=self.request.get('access')
version=self.request.get('version')
debug=self.request.get('debug')
content=""
# retrieve the page if it is allowed
if utils.access_allowed(self,notebook_access, notebook_owner):
(content, version)=utils.get_notebook_content(notebook_owner,notebook_access, notebook_name, version)
if not version:
version = "0"
template_values = {
'user_name': utils.get_user_name(self),
'user_network': utils.get_user_network(self),
'user_id': utils.get_user_id(self),
'notebook_content': content,
'notebook_version': str(version),
'login_link': utils.get_login_link(),
'notebook_owner': notebook_owner,
'notebook_name': notebook_name,
'notebook_access': notebook_access
}
# if there is debug param in url render the debug version
folder = 'html_debug/' if debug else 'html/'
template = jinja_environment.get_template( folder+'inote.html' )
text=template.render(template_values)
self.response.headers['Content-Type'] = 'text/html'
self.response.headers['Content-Version'] = str(version)
self.response.out.write(text)
def group():
user_id = get_user_id()
groups = db.session.query(Group, User.name).join(Groupmember).filter(Groupmember.user_id == user_id).join(User).filter(Group.owner_id == Group.owner_id)
return render_template('group/list.html', groups=groups)
