def connect_handler(cv, provider): """Shared method to handle the connection process :param connection_values: A dictionary containing the connection values :param provider_id: The provider ID the connection shoudl be made to """ cv.setdefault('user_id', current_user.get_id()) connection = _datastore.find_connection(**cv) if connection is None: after_this_request(_commit) connection = _datastore.create_connection(**cv) msg = ('Connection established to %s' % provider.name, 'success') connection_created.send(current_app._get_current_object(), user=current_user._get_current_object(), connection=connection) else: msg = ('A connection is already established with %s ' 'to your account' % provider.name, 'notice') connection_failed.send(current_app._get_current_object(), user=current_user._get_current_object()) redirect_url = session.pop(config_value('POST_OAUTH_CONNECT_SESSION_KEY'), get_url(config_value('CONNECT_ALLOW_VIEW'))) do_flash(*msg) return redirect(redirect_url)
def connect_handler(cv, provider): """Shared method to handle the connection process :param connection_values: A dictionary containing the connection values :param provider_id: The provider ID the connection shoudl be made to """ cv.setdefault('user_id', current_user.get_id()) connection = _datastore.find_connection(**cv) if connection is None: after_this_request(_commit) connection = _datastore.create_connection(**cv) msg = ('Connection established to %s' % provider.name, 'success') connection_created.send(current_app._get_current_object(), user=current_user._get_current_object(), connection=connection) else: msg = ('A connection is already established with %s ' 'to your account' % provider.name, 'notice') connection_failed.send(current_app._get_current_object(), user=current_user._get_current_object()) redirect_url = session.pop(config_value('POST_OAUTH_CONNECT_SESSION_KEY'), get_url(config_value('CONNECT_ALLOW_VIEW'))) do_flash(*msg) return redirect(redirect_url)
def write_activity_on_follow(follow, **kwargs): if current_user.is_authenticated: if isinstance(follow.following, Dataset): write_activity.delay(UserFollowedDataset, current_user._get_current_object(), follow.following) elif isinstance(follow.following, Reuse): write_activity.delay(UserFollowedReuse, current_user._get_current_object(), follow.following) elif isinstance(follow.following, Organization): write_activity.delay(UserFollowedOrganization, current_user._get_current_object(), follow.following) elif isinstance(follow.following, User): write_activity.delay(UserFollowedUser, current_user._get_current_object(), follow.following)
def write_activity_on_discuss(discussion, **kwargs): if current_user.is_authenticated: if isinstance(discussion.subject, Dataset): write_activity.delay(UserDiscussedDataset, current_user._get_current_object(), discussion.subject) elif isinstance(discussion.subject, Reuse): write_activity.delay(UserDiscussedReuse, current_user._get_current_object(), discussion.subject)
def write_activity_on_discuss(discussion, **kwargs): if current_user.is_authenticated(): if isinstance(discussion.subject, Dataset): write_activity.delay( UserDiscussedDataset, current_user._get_current_object(), discussion.subject) elif isinstance(discussion.subject, Reuse): write_activity.delay( UserDiscussedReuse, current_user._get_current_object(), discussion.subject)
def post(self, dataset): '''Upload a new community resource''' args = upload_parser.parse_args() infos = self.extract_infos_from_args(args, dataset) infos['owner'] = current_user._get_current_object() community_resource = CommunityResource.objects.create(**infos) return community_resource, 201
def make_submission_version_update_handler(cls, channel): identity = None if channel == 'SMS': identity = g.get('phone', '') elif channel == 'WEB': user = current_user._get_current_object() identity = user.email if not user.is_anonymous() else 'unknown' def update_submission_version(sender, document, **kwargs): if sender != Submission: return data_fields = document.form.tags if document.form.form_type == 'INCIDENT': data_fields.extend(['status']) version_data = { k: document[k] for k in data_fields if k in document } cls().create(submission=document, data=json.dumps(version_data), timestamp=datetime.utcnow(), channel=channel, identity=identity) return update_submission_version
def update_submission_version(sender, document, **kwargs): if sender != services.submissions.__model__: return # save actual version data data_fields = document.form.tags if document.form.form_type == 'INCIDENT': data_fields.extend(['status']) version_data = {k: document[k] for k in data_fields if k in document} # get previous version previous = services.submission_versions.find( submission=document).order_by('-timestamp').first() if previous: prev_data = json.loads(previous.data) diff = DictDiffer(version_data, prev_data) # don't do anything if the data wasn't changed if not diff.added() and not diff.removed() and not diff.changed(): return # save user email as identity channel = 'WEB' user = current_user._get_current_object() identity = user.email if not user.is_anonymous() else 'unknown' services.submission_versions.create( submission=document, data=json.dumps(version_data), timestamp=datetime.utcnow(), channel=channel, identity=identity )
def make_submission_version_update_handler(cls, channel): identity = None if channel == 'SMS': identity = g.get('phone', '') elif channel == 'WEB': user = current_user._get_current_object() identity = user.email if not user.is_anonymous() else 'unknown' def update_submission_version(sender, document, **kwargs): if sender != Submission: return data_fields = document.form.tags if document.form.form_type == 'INCIDENT': data_fields.extend(['status']) version_data = { k: document[k] for k in data_fields if k in document } cls().create( submission=document, data=json.dumps(version_data), timestamp=datetime.utcnow(), channel=channel, identity=identity ) return update_submission_version
def get_game_sessions(): sessions = [] user_id = current_user._get_current_object().id q = GameSession.query.outerjoin(GameSessionPlayers).filter(or_(GameSessionPlayers.user_id == user_id,GameSession.host_id == user_id)).order_by(GameSession.created).all() for session in q: sessions.append(session.as_dict()) return api_package(data=sessions)
def location_headers(pk): user = current_user._get_current_object() # disallow processing other users' files upload = services.user_uploads.get_or_404(pk=pk, user=user) try: dataframe = load_source_file(upload.data) except Exception: # delete loaded file upload.data.delete() upload.delete() return abort(400) deployment = g.deployment headers = dataframe.columns template_name = 'frontend/location_headers.html' if request.method == 'GET': form = generate_location_update_mapping_form(deployment, headers) return render_template(template_name, form=form) else: form = generate_location_update_mapping_form(deployment, headers, request.form) if not form.validate(): return render_template(template_name, form=form) else: # get header mappings data = form.data.copy() # invoke task asynchronously kwargs = {'upload_id': unicode(upload.id), 'mappings': data} import_locations.apply_async(kwargs=kwargs) return redirect(url_for('locations.locations_list'))
def on_user_updated_organization(organization): if current_user and current_user.is_authenticated: user = current_user._get_current_object() write_activity.delay(UserUpdatedOrganization, user, organization, organization=organization)
def friends(): args = request.args user = current_user._get_current_object() if 'NoGroup' in args: #Lets get friends that are NOT in groups only q = Friends.query.filter(and_(Friends.user_id == user.id,Friends.group_id == None)).all() else: #otherwise lets get ALL friends regardless if they are in a group or not q = Friends.query.filter(Friends.user_id == user.id).all() friends = [] for f in q: friends.append({'type':'friend','friend':f.as_dict()}) if 'FriendRequests' in args: print "Get requests" q = FriendRequests.query.filter(FriendRequests.user_id == user.id).all() print q, user.id for fr in q: friends.append({ 'type':'friend_request', 'friend_request':{ 'id':fr.id, 'username':fr.friend.username } }) return api_package(data=friends)
def confirm_friend(): user = current_user._get_current_object() form = request.get_json() schema = { 'id':{'type':'integer','empty':False} } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) friend_request = FriendRequests.query.filter(FriendRequests.id == form['id']).first() if friend_request: #we are confirming this, so create friendships that last both ways. my_friend = Friends(user_id = user.id,friend_id = friend_request.friend_id) their_friend = Friends(user_id = friend_request.friend_id,friend_id = user.id) meeple.db.session.add(my_friend) meeple.db.session.add(their_friend) meeple.db.session.delete(friend_request) #remove this friend request meeple.db.session.commit() #now return who this friend is back to them. return api_package(data=my_friend.as_dict()) else: return api_error("This request does not exist")
def add_friend_to_group(id): user = current_user._get_current_object() form = request.get_json() schema = { 'id':{'type':'integer','empty':False}, } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) #first see if this is a valid group group = FriendsGroup.query.filter(and_(FriendsGroup.user_id == user.id,FriendsGroup.id == id)).first() if group: #lets see if this is a confirmed friend of yours friend = Friends.query.filter(and_(Friends.user_id == user.id,Friends.friend_id == form['id'])).first() if friend: #lets see if this friend is not in this group if friend.group_id == group.id: return api_error("This friend is already in this group") else: friend.group_id = group.id meeple.db.session.commit() return api_package() else: return api_error("Friend does not exist") else: return api_error("This group does not exist.")
def remove_connection(provider_id, provider_user_id): """Remove a specific connection for the authenticated user to the specified provider """ provider = get_provider_or_404(provider_id) ctx = dict(provider=provider.name, user=current_user, provider_user_id=provider_user_id) deleted = _datastore.delete_connection(user_id=current_user.get_id(), provider_id=provider_id, provider_user_id=provider_user_id) if deleted: after_this_request(_commit) msg = ('Connection to %(provider)s removed' % ctx, 'info') connection_removed.send(current_app._get_current_object(), user=current_user._get_current_object(), provider_id=provider_id) else: msg = ('Unabled to remove connection to %(provider)s' % ctx, 'error') do_flash(*msg) return redirect(request.referrer or get_post_login_redirect())
def get(self): '''List all discussions related to my organizations.''' q = filter_parser.parse_args().get('q') discussions = discussions_for(current_user._get_current_object()) discussions = discussions.order_by('-created') if q: discussions = discussions.filter(title__icontains=q.decode('utf-8')) return list(discussions)
def get(self): '''List all issues related to my organizations.''' q = filter_parser.parse_args().get('q') issues = issues_for(current_user._get_current_object()) issues = issues.order_by('-created') if q: issues = issues.filter(title__icontains=q.decode('utf-8')) return list(issues)
def put(self, community): '''Update a given community resource''' form = api.validate(CommunityResourceForm, community) form.populate_obj(community) if not community.organization: community.owner = current_user._get_current_object() community.modified = datetime.now() community.save() return community
def get(self): '''List all discussions related to my organizations.''' q = filter_parser.parse_args().get('q') discussions = discussions_for(current_user._get_current_object()) discussions = discussions.order_by('-created') if q: decoded = q.decode('utf-8') discussions = discussions.filter(title__icontains=decoded) return list(discussions)
def get(self): """List all discussions related to my organizations.""" q = filter_parser.parse_args().get("q") discussions = Discussion.objects.from_organizations( current_user._get_current_object(), *current_user.organizations ).order_by("-created") if q: discussions = discussions.filter(title__icontains=q.decode("utf-8")) return list(discussions)
def write_activity_on_follow(follow, **kwargs): if current_user.is_authenticated: if isinstance(follow.following, Dataset): write_activity.delay(UserFollowedDataset, current_user._get_current_object(), follow.following) elif isinstance(follow.following, Reuse): write_activity.delay(UserFollowedReuse, current_user._get_current_object(), follow.following) elif isinstance(follow.following, Organization): write_activity.delay(UserFollowedOrganization, current_user._get_current_object(), follow.following) elif isinstance(follow.following, User): write_activity.delay(UserFollowedUser, current_user._get_current_object(), follow.following)
def put(self, community): '''Update a given community resource''' form = api.validate(CommunityResourceForm, community) form.populate_obj(community) if not community.organization: community.owner = current_user._get_current_object() community.modified = datetime.now() community.save() return community
def friend_groups(): user = current_user._get_current_object() q = FriendsGroup.query.filter(FriendsGroup.user_id == user.id).all() groups = [] for g in q: groups.append(g.as_dict()) non_grouped = [] return api_package(data=groups)
def user_context_processor(): if current_user.is_authenticated(): user = current_user._get_current_object() else: user = None return { 'user': user, 'login_user_form': LoginForm(), 'register_form': RegisterForm(), }
def get(self): '''List all current user pending notifications''' user = current_user._get_current_object() notifications = [] orgs = [o for o in user.organizations if o.is_admin(user)] # Fetch user open issues datasets = Dataset.objects.owned_by(user, *orgs) reuses = Reuse.objects.owned_by(user, *orgs) for issue in Issue.objects(subject__in=list(datasets) + list(reuses)): notifications.append({ 'type': 'issue', 'created_on': issue.created, 'details': { 'subject': { 'type': issue.subject.__class__.__name__.lower(), 'id': str(issue.subject.id) } } }) # Fetch pending membership requests for org in orgs: for request in org.pending_requests: notifications.append({ 'type': 'membership_request', 'created_on': request.created, 'details': { 'organization': org.id, 'user': { 'id': str(request.user.id), 'fullname': request.user.fullname, 'avatar': str(request.user.avatar) } } }) # Fetch pending transfer requests for transfer in Transfer.objects(recipient__in=[user] + orgs, status='pending'): notifications.append({ 'type': 'transfer_request', 'created_on': transfer.created, 'details': { 'id': str(transfer.id), 'subject': { 'class': transfer.subject.__class__.__name__.lower(), 'id': str(transfer.subject.id) } } }) return notifications
def get(self): '''List all current user pending notifications''' user = current_user._get_current_object() notifications = [] orgs = [o for o in user.organizations if o.is_admin(user)] # Fetch user open issues datasets = Dataset.objects.owned_by(user, *orgs) reuses = Reuse.objects.owned_by(user, *orgs) for issue in Issue.objects(subject__in=list(datasets)+list(reuses)): notifications.append({ 'type': 'issue', 'created_on': issue.created, 'details': { 'subject': { 'type': issue.subject.__class__.__name__.lower(), 'id': str(issue.subject.id) } } }) # Fetch pending membership requests for org in orgs: for request in org.pending_requests: notifications.append({ 'type': 'membership_request', 'created_on': request.created, 'details': { 'organization': org.id, 'user': { 'id': str(request.user.id), 'fullname': request.user.fullname, 'avatar': str(request.user.avatar) } } }) # Fetch pending transfer requests for transfer in Transfer.objects(recipient__in=[user]+orgs, status='pending'): notifications.append({ 'type': 'transfer_request', 'created_on': transfer.created, 'details': { 'id': str(transfer.id), 'subject': { 'class': transfer.subject.__class__.__name__.lower(), 'id': str(transfer.subject.id) } } }) return notifications
def comment_create_view(): submission = services.submissions.get_or_404( pk=request.form.get('submission')) comment = request.form.get('comment') saved_comment = services.submission_comments.create( submission=submission, user=current_user._get_current_object(), comment=comment, submit_date=datetime.utcnow()) return jsonify(comment=saved_comment.comment, date=mkunixtimestamp(saved_comment.submit_date), user=saved_comment.user.email)
def post(self): '''Create a new community resource''' form = api.validate(CommunityResourceForm) resource = CommunityResource() form.populate_obj(resource) if not resource.dataset: api.abort(400, errors={'dataset': 'A dataset identifier is required'}) if not resource.organization: resource.owner = current_user._get_current_object() resource.modified = datetime.now() resource.save() return resource, 201
def participant_list_import(): form = file_upload_form(request.form) if not form.validate(): return abort(400) else: # get the actual object from the proxy user = current_user._get_current_object() event = services.events.get_or_404(pk=form.event.data) upload = stash_file(request.files['spreadsheet'], user, event) upload.save() return redirect( url_for('participants.participant_headers', pk=unicode(upload.id)))
def post(self, id): '''Add comment and optionnaly close an issue given its ID''' issue = Issue.objects.get_or_404(id=id) form = api.validate(IssueCommentForm) issue.discussion.append(Message( content=form.comment.data, posted_by=current_user.id )) close = form.close.data if close: issue.closed_by = current_user._get_current_object() issue.closed = datetime.now() issue.save() if close: on_issue_closed.send(issue) return marshal(issue, issue_fields), 200
def participant_list_import(): form = file_upload_form(request.form) if not form.validate(): return abort(400) else: # get the actual object from the proxy user = current_user._get_current_object() event = services.events.get_or_404(pk=form.event.data) upload = stash_file(request.files['spreadsheet'], user, event) upload.save() return redirect(url_for( 'participants.participant_headers', pk=unicode(upload.id) ))
def comment_create_view(): submission = services.submissions.get_or_404( pk=request.form.get('submission')) comment = request.form.get('comment') saved_comment = services.submission_comments.create( submission=submission, user=current_user._get_current_object(), comment=comment, submit_date=datetime.utcnow() ) return jsonify( comment=saved_comment.comment, date=mkunixtimestamp(saved_comment.submit_date), user=saved_comment.user.email )
def post(self, id): '''Add comment and optionnaly close an issue given its ID''' issue = Issue.objects.get_or_404(id=id) form = api.validate(IssueCommentForm) message = Message(content=form.comment.data, posted_by=current_user.id) issue.discussion.append(message) close = form.close.data if close: issue.closed_by = current_user._get_current_object() issue.closed = datetime.now() issue.save() if close: on_issue_closed.send(issue, message=message) else: on_new_issue_comment.send(issue, message=message) return marshal(issue, issue_fields), 200
def participant_headers(pk): user = current_user._get_current_object() # disallow processing other users' files upload = services.user_uploads.get_or_404(pk=pk, user=user) try: dataframe = load_source_file(upload.data) except Exception: # delete loaded file upload.data.delete() upload.delete() return abort(400) deployment = g.deployment headers = dataframe.columns template_name = 'frontend/participant_headers.html' if request.method == 'GET': form = generate_participant_import_mapping_form(deployment, headers) return render_template(template_name, form=form) else: form = generate_participant_import_mapping_form( deployment, headers, request.form) if not form.validate(): return render_template( template_name, form=form ) else: # get header mappings data = form.data.copy() # phone_header = data.pop('phone') # group_header = data.pop('group') # mappings = {v: k for k, v in data.iteritems() if v} # mappings.update(phone=phone_header) # mappings.update(group=group_header) # invoke task asynchronously kwargs = { 'upload_id': unicode(upload.id), 'mappings': data } import_participants.apply_async(kwargs=kwargs) return redirect(url_for('participants.participant_list'))
def participant_headers(pk): user = current_user._get_current_object() # disallow processing other users' files upload = services.user_uploads.get_or_404(pk=pk, user=user) try: dataframe = load_source_file(upload.data) except Exception: # delete loaded file upload.data.delete() upload.delete() return abort(400) deployment = g.deployment headers = dataframe.columns template_name = 'frontend/participant_headers.html' if request.method == 'GET': form = generate_participant_import_mapping_form(deployment, headers) return render_template(template_name, form=form) else: form = generate_participant_import_mapping_form( deployment, headers, request.form) if not form.validate(): return render_template( template_name, form=form ) else: # get header mappings data = form.data.copy() # phone_header = data.pop('phone') # group_header = data.pop('group') # mappings = {v: k for k, v in data.iteritems() if v} # mappings.update(phone=phone_header) # mappings.update(group=group_header) # invoke task asynchronously kwargs = { 'upload_id': unicode(upload.id), 'mappings': data } import_participants.apply_async(kwargs=kwargs) return redirect(url_for('participants.participant_list'))
def post(self, id): '''Add comment and optionnaly close a discussion given its ID''' discussion = Discussion.objects.get_or_404(id=id) form = api.validate(DiscussionCommentForm) message = Message(content=form.comment.data, posted_by=current_user.id) discussion.discussion.append(message) close = form.close.data if close: CloseDiscussionPermission(discussion).test() discussion.closed_by = current_user._get_current_object() discussion.closed = datetime.now() discussion.save() if close: on_discussion_closed.send(discussion, message=message) else: on_new_discussion_comment.send(discussion, message=message) return discussion
def create_game_sessions(): form = request.get_json() print form if form is None: return api_error("Invalid Request") schema = { 'name':{'type':'string','empty':False}, 'game_id':{'type':'integer','required':True}, 'start_date':{'type':'string','empty':False}, 'host_is_playing':{'type':'boolean','required':True} } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) game = Game().query.filter_by(game_id=form['game_id']).first() if game is None: return api_error("There was an issue adding the game to this session.") #this probably shouldnt happen but, we should check anyways newgamesession = GameSession() user = current_user._get_current_object() if form['host_is_playing'] is True: newgamesession.players.append(user) #the user/host is also a player. addplayer_helper(newgamesession,user) newgamesession.host = user #attach this session to the user creating it, as they are the host. newgamesession.game = game #relate this gamesession to this board game #name is optional. If left empty, the board games name will be used instead. if 'name' in form: newgamesession.name = form['name'] else: newgamesession.name = game.name #user can specify a future start date, otherwise utcnow() is used as default value in table. if 'start_date' in form: newgamesession.start_date = date_parse(form['start_date']) meeple.db.session.add(newgamesession) meeple.db.session.commit() return api_package(data=newgamesession.as_dict())
def update_submission_version(sender, document, **kwargs): if sender != services.submissions.__model__: return # save actual version data data_fields = document.form.tags if document.form.form_type == 'INCIDENT': data_fields.extend(['status', 'witness']) version_data = {k: document[k] for k in data_fields if k in document} # save user email as identity channel = 'WEB' user = current_user._get_current_object() identity = user.email if not user.is_anonymous() else 'unknown' services.submission_versions.create(submission=document, data=json.dumps(version_data), timestamp=datetime.utcnow(), channel=channel, identity=identity)
def post(self, id): '''Add comment and optionnaly close a discussion given its ID''' discussion = Discussion.objects.get_or_404(id=id) form = api.validate(DiscussionCommentForm) message = Message( content=form.comment.data, posted_by=current_user.id ) discussion.discussion.append(message) close = form.close.data if close: CloseDiscussionPermission(discussion).test() discussion.closed_by = current_user._get_current_object() discussion.closed = datetime.now() discussion.save() if close: on_discussion_closed.send(discussion, message=message) else: on_new_discussion_comment.send(discussion, message=message) return discussion
def post(self, id): '''Add comment and optionnaly close an issue given its ID''' issue = Issue.objects.get_or_404(id=id) form = api.validate(IssueCommentForm) message = Message( content=form.comment.data, posted_by=current_user.id ) issue.discussion.append(message) close = form.close.data if close: CloseIssuePermission(issue).test() issue.closed_by = current_user._get_current_object() issue.closed = datetime.now() issue.save() if close: on_issue_closed.send(issue, message=message) else: on_new_issue_comment.send(issue, message=message) return issue
def location_headers(pk): user = current_user._get_current_object() # disallow processing other users' files upload = services.user_uploads.get_or_404(pk=pk, user=user) try: dataframe = load_source_file(upload.data) except Exception: # delete loaded file upload.data.delete() upload.delete() return abort(400) deployment = g.deployment headers = dataframe.columns template_name = 'frontend/location_headers.html' if request.method == 'GET': form = generate_location_update_mapping_form(deployment, headers) return render_template(template_name, form=form) else: form = generate_location_update_mapping_form( deployment, headers, request.form) if not form.validate(): return render_template( template_name, form=form ) else: # get header mappings data = form.data.copy() # invoke task asynchronously kwargs = { 'upload_id': unicode(upload.id), 'mappings': data } import_locations.apply_async(kwargs=kwargs) return redirect(url_for('locations.locations_list'))
def remove_all_connections(provider_id): """Remove all connections for the authenticated user to the specified provider """ provider = get_provider_or_404(provider_id) ctx = dict(provider=provider.name, user=current_user) deleted = _datastore.delete_connections(user_id=current_user.get_id(), provider_id=provider_id) if deleted: after_this_request(_commit) msg = ('All connections to %s removed' % provider.name, 'info') connection_removed.send(current_app._get_current_object(), user=current_user._get_current_object(), provider_id=provider_id) else: msg = ('Unable to remove connection to %(provider)s' % ctx, 'error') do_flash(*msg) return redirect(request.referrer)
def create_friends_group(): user = current_user._get_current_object() form = request.get_json() schema = { 'name':{'type':'string','empty':False}, } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) #first see if this name exists group = FriendsGroup.query.filter(and_(FriendsGroup.user_id == user.id,FriendsGroup.name == form['name'])).first() if group: return api_error("This group name already exists") group = FriendsGroup(user_id=user.id,name=form['name']) meeple.db.session.add(group) meeple.db.session.commit() return api_package(data=group.as_dict())
def update_submission_version(sender, document, **kwargs): if sender != services.submissions.__model__: return # save actual version data data_fields = document.form.tags if document.form.form_type == 'INCIDENT': data_fields.extend(['status', 'witness']) version_data = {k: document[k] for k in data_fields if k in document} # save user email as identity channel = 'WEB' user = current_user._get_current_object() identity = user.email if not user.is_anonymous() else 'unknown' services.submission_versions.create( submission=document, data=json.dumps(version_data), timestamp=datetime.utcnow(), channel=channel, identity=identity )
def add_player_to_session(id): form = request.get_json() user = current_user._get_current_object() if form is None: return api_error("Invalid Request") try: id = int(id) except ValueError as e: return api_error("id values must be integers only.") schema = { 'user_id':{'type':'integer','required':True} } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) gs = GameSession.query.filter_by(id=id).first() if gs is None: return api_error("Unable to find a game session by that id") new_player = Friends.query.filter(and_(Friends.user_id == user.id,Friends.friend_id == form['user_id'])).first() if new_player is None: return api_error("Unable to find player to add to this game session") #check if this player is already in if new_player.friend in gs.players: return api_error("This player is already in this game session") gs.players.append(new_player.friend) player_props = addplayer_helper(gs,new_player.friend) meeple.db.session.commit() return api_package(data=player_props)
def request_friend(): user = current_user._get_current_object() form = request.get_json() schema = { 'username':{'type':'string','empty':False} } v = Validator(schema) if v.validate(form) is False: return api_validation_error(v.errors) #first check, is this you? You idiot... if user.username == form['username']: return api_error("You cannot friend yourself") friend = User.query.filter(User.username == form['username']).first() if friend: #second check, is he already your friend? am_i_friend = Friends.query.filter(and_(Friends.user_id == user.id,Friends.friend_id == friend.id)).first() if am_i_friend: return api_error("You are already friends") #is this already requested? ar = FriendRequests.query.filter(and_(FriendRequests.user_id == friend.id,FriendRequests.friend_id == user.id)).first() if ar: return api_package() #this is the inverse as to who this is for new_request = FriendRequests(user_id=friend.id,friend_id=user.id) """ TODO insert notification event here as well. Notifcation table to show/email that so and so is requesting friendship """ meeple.db.session.add(new_request) meeple.db.session.commit() return api_package() else: return api_error("User not found")
def get_or_404(self, **kwargs): if not current_user.is_authenticated(): api.abort(404) return current_user._get_current_object()
def get(self): '''Fetch the current user (me) metrics''' return current_user._get_current_object()
def put(self, **kwargs): '''Update my profile''' user = current_user._get_current_object() form = api.validate(UserProfileForm, user) return form.save()
def get_query(self): '''Returns the queryset of the objects to list.''' user = current_user._get_current_object() return models.Event.objects(deployment=user.deployment)
def get_query(self): user = current_user._get_current_object() return models.User.objects(deployment=user.deployment)
def put(self, **kwargs): '''Update my profile''' user = current_user._get_current_object() form = api.validate(UserProfileForm, user) return form.save()
def get(self): '''Fetch the current user (me) identity''' return current_user._get_current_object()
def get_query(self): user = current_user._get_current_object() return models.Deployment.objects(pk=user.deployment.pk)
def on_user_deleted_reuse(reuse): if not reuse.private and current_user and current_user.is_authenticated(): user = current_user._get_current_object() organization = reuse.organization write_activity.delay(UserDeletedReuse, user, reuse, organization)