def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: channelObj = ChannelId.query_model({ "user_id" : self.member.user_id, "extra_param" : self.request.get("extra_param") }) if not channelObj: try: channelObj = ChannelId.create_model({ "user_id" : self.member.user_id, "extra_param" : int(self.request.get("extra_param")) }) self.response.out.write(json.dumps(response.success("success", { "token" : channelObj.token }))) except apiproxy_errors.OverQuotaError, message: self.response.out.write(json.dumps(response.failure("500", message))) else: self.response.out.write(json.dumps(response.success("success", { "token" : channelObj.token })))
def post(self): self.response.headers['Content-Type'] = 'application/json' member = validate_user_is_member_and_can_edit(self, "Member") if member: params = json.loads(self.request.body) memberData = params['data'] if get_member_by_email(memberData['email']): self.response.out.write(json.dumps(response.failure("500", "Email already in use"))) elif not mail.is_email_valid(memberData['email']): self.response.out.write(json.dumps(response.failure("500", "Invalid email address"))) else: newMember = Member() newMember.populate(**memberData) newMember.put() token = get_new_token(newMember.email) url = "%(host)s/validate?t=%(token)s" % {"host" : self.request.host_url, "token" : token.token} sender_address = member.email subject = "Confirm your membership" body = """ Thank you for creating an account! Please confirm your email address by clicking on the link below: %s """ % url mail.send_mail(sender_address, newMember.email, subject, body) self.response.write(json.dumps(response.success("success", {"email" : newMember.email})))
def apig_list(event, context): log.info("event={}".format(event)) log.info("context={}".format(str(context))) profile = "" if 'profile' in event.keys(): profile = event["profile"] ddb = ScriptletDynamoDB(app_name, profile) data = event["queryStringParameters"] user_id = data["user_id"] # user_id = data["requestContext"]["identity"]["cognitoIdentityId"] table_name = "portfolio" key = "user_id" value = user_id returned = ddb.query(table_name, key, value) log.info("returned['Count']={}".format(returned['Count'])) for item in returned['Items']: log.info("item={}".format(item)) if returned['Count'] > 0: response = success(returned['Items']) else: response = failure(returned['Items']) log.info("response={}".format(response)) return response
def post_delete_item(id): # This is meant to be reached from AJAX request. # We return a JSON response that will be used by # The JS code making the request. item = db_utils.get_item(id) db_utils.delete_item(item) return response.success()
def get(self): self.response.headers['Content-Type'] = 'application/json' member = validate_user_is_member(self) if member and member.permission == 2: members = Member.query().fetch() self.response.out.write(json.dumps(response.success("success", convert_query_to_dict(members))))
def apig_get(event, context): log.info("event={}".format(event)) log.info("context={}".format(str(context))) profile = "" if 'profile' in event.keys(): profile = event["profile"] ddb = ScriptletDynamoDB(app_name, profile) data = event["queryStringParameters"] user_id = data["user_id"] note_id = data["note_id"] table_name = "portfolio" key = {"user_id": {"S": user_id}, "note_id": {"S": note_id}} returned = ddb.get_item(table_name, key) item = returned["Item"]["content"] log.info("returned={}".format(item)) if len(returned.keys()) > 0: response = success(item) else: response = failure(item) log.info("response={}".format(response)) return response
def main(event, context): # prepare the key to search in dynamodb recipe table key = {"recipeId": event["pathParameters"]["id"]} # Execute get item in dynamodb try: result = dynamodb.call(tableRegion, tableName, "get_item", Key=key) # Return 500 and status failed in case of error except: return response.failure(json.dumps({"status": "false"})) else: # Return 200 and the retrieved item if result is not None: return response.success( json.dumps(result["Item"], cls=DecimalEncoder)) # Return "item not found" and 500 with status failed when no item was found else: return response.failure( json.dumps({ "status": "false", "error": "Item not found." }))
def import_lastfm_artists(): """ Import artists from Last.FM Arguments: - username: last.FM username to import artists from - period: ['7day', '1month', '3month', '6month', '12month', 'overall'] - (optional) limit: maximum 500, default 500 """ user = g.user import_processor = ImportProcessor() username = request.json.get("username") period = request.json.get("period") limit = request.json.get("limit") if username is None or period not in [ "7day", "1month", "3month", "6month", "12month", "overall", ]: return response.error("Username empty or period is incorrect.") if limit is None or limit > 500: limit = 500 result = import_processor.import_from_lastfm(user.id, username, limit, period) return response.success({"artists_imported": result})
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: campTars = convert_query_to_dict(CampTarget.query().order(CampTarget.order).fetch()) self.response.out.write(json.dumps(response.success("success", campTars)))
def apig_update(event, context): log.info("event={}".format(event)) log.info("context={}".format(str(context))) profile = "" if 'profile' in event.keys(): profile = event["profile"] ddb = ScriptletDynamoDB(app_name, profile) data = json.loads(event["body"]) user_id = data["user_id"] note_id = data["note_id"] content = data["content"] table_name = "portfolio" key = { "user_id": {"S": user_id}, "note_id": {"S": note_id} } # should really wrap this is a try/catch block and then use the success/failure methods returned = ddb.update(table_name, key, content) log.info("returned={}".format(returned)) if returned["ResponseMetadata"]["HTTPStatusCode"] == 200: response = success(returned["Attributes"]) else: response = failure(returned["Attributes"]) log.info("response={}".format(response)) return response
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "CampTarget") if memberObj: create_camps_data() self.response.out.write(json.dumps(response.success("success", "Camps Created")))
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: moduleObj = Module.delete_model({ "id" : self.request.get("id"), }) self.response.out.write(json.dumps(response.success("success", {})))
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: params = json.loads(self.request.body) moduleObj = Module.update_model(params['data']) logging.warn(moduleObj) self.response.out.write(json.dumps(response.success("success", {"id" : moduleObj.id})))
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: self.cursor = 0 self.cursorMap = {} data = Module.get_all_full(self) self.response.out.write(json.dumps(response.success("success", {"modules" : data}, { "cursors" : self.cursorMap })))
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: moduleObj = Module.query_model({ "id" : self.request.get("id") }) dir = self.request.get("dir") move = 0 oldRow = moduleObj.row if dir == "up" and moduleObj.row != 0: moduleObj.row -= 1 move = 1 else: moduleObjs = Module.query(Module.col == moduleObj.col).order(-Module.row).get() lastRow = -1 if moduleObjs: lastRow = moduleObjs.row if lastRow != -1 and lastRow != moduleObj.row: moduleObj.row += 1 move = 1 logging.warn("{0} : {1}".format(moduleObj.row, moduleObj.col)) if move: swapObj = Module.query(Module.col == moduleObj.col, Module.row == moduleObj.row).get() swapObj.row = oldRow swapObj.put() moduleObj.put() self.response.out.write(json.dumps(response.success("success", {})))
def user_releases_upcoming(page): query = UserRelease.query.filter( UserRelease.user_id == g.user.id, UserRelease.type.in_(g.user.filters), UserRelease.date_release > date.today()).order_by( UserRelease.date_release.asc()) data = paginate_query(query, page) return response.success(data)
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: msg = self.request.get("msg") for channelObj in ChannelId.query().fetch(): channel.send_message(channelObj.token, json.dumps({ "message" : msg, "author" : self.member.gotaname })) self.response.out.write(json.dumps(response.success("success", {})))
def get_all_sovereign_states(): """ Returns a serialized list of all sovereign states. :rtype: flask.Response """ query = request.args.get('q') page_num = int(request.args.get('page_num', 1)) per_page = int(request.args.get('per_page', 100)) if query is not None: return response.success( SovereignState.get_matching(query, page_num, per_page) ) return response.success(SovereignState.all(page_num, per_page))
def get_user(): return response.success({ 'user': { 'email': g.user.email, 'icloud': g.user.icloud, 'filters': g.user.filters, } })
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: params = json.loads(self.request.body) params['data']['email'] = self.member.email params['data']['qty'] = int(params['data']['qty']) campTarMemItm = CampTargetMemberItem.update_model(params['data']) self.response.out.write(json.dumps(response.success("success", { "email" : campTarMemItm.email, "item" : campTarMemItm.item })))
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: voteObj = PollVote.delete_model({ "user_id" : self.request.get("user_id"), "optId" : int(self.request.get("optId")), }) self.response.out.write(json.dumps(response.success("success", {})))
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: logging.warn(self.member) params = json.loads(self.request.body) moduleDataObj = moduleTypeToClassMap[params['modType']].update_model(params['data']) logging.warn(moduleDataObj) self.response.out.write(json.dumps(response.success("success", moduleDataObj.to_dict())))
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: params = json.loads(self.request.body) params['data']['user_id'] = self.member.user_id params['data']['qty'] = int(params['data']['qty']) campTarMemItm = CampTargetMemberItem.update_model(params['data']) self.response.out.write(json.dumps(response.success("success", { "user_id" : campTarMemItm.user_id, "item" : campTarMemItm.item, "lastTransactions" : convert_last_transaction(campTarMemItm.lastTransactions) })))
def user_releases_unlistened(page): query = UserRelease.query.filter( UserRelease.user_id == g.user.id, UserRelease.type.in_(g.user.filters), UserRelease.listened.is_(False), UserRelease.date_release <= date.today()).order_by( UserRelease.date_release.desc()) data = paginate_query(query, page) return response.success(data)
def post_delete_category(id): # This is meant to be reached from AJAX request. # We return a JSON response that will be used by # The JS code making the request. if not auth.is_user_admin(): return response.error('Unauthorized') db_utils.delete_category(id) return response.success()
def post(self): self.response.headers['Content-Type'] = 'application/json' if self.member: params = json.loads(self.request.body) params['data']['module_id'] = int(params['modId']) moduleDataObj = moduleTypeToClassMap[params['modType']].create_model(params['data']) Module.moduleData_created({ "id" : params['modId'] }, moduleDataObj) logging.warn(moduleDataObj) self.response.out.write(json.dumps(response.success("success", moduleDataObj.to_dict())))
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: data = convert_query_to_dict(Module.query().order(Module.col).fetch()) for d in data: moduleKey = ndb.Key('Module', d['id']) d['moduleData'] = convert_query_to_dict(moduleTypeToClassMap[d['type']].query(ancestor=moduleKey).fetch()) self.response.out.write(json.dumps(response.success("success", {"modules" : data})))
def user_releases_new(page): # TODO: Needs to be redone to access notifications table? # Or at least ensure that date_added is working properly query = UserRelease.query.filter(UserRelease.user_id == g.user.id, UserRelease.type.in_( g.user.filters)).order_by( UserRelease.date_added.desc()) data = paginate_query(query, page) return response.success(data)
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: members = convert_query_to_dict(member.Member.query().fetch()) allianceObj = Alliance.query().get() allianceData = allianceObj.to_dict() allianceData['members'] = members self.response.out.write(json.dumps(response.success("success", allianceData)))
def get_edit_category_page(id=0): if request.method == 'GET': if not auth.is_user_admin(): # Only admins can add and edit catories return render_template('unauthorized.html') if id and id != 0: # id is specified, render edit category page category = db_utils.get_category(id) return render_template('edit-category.html', category=category, CLIENT_ID=CLIENT_ID, signed_in=auth.is_signed_in(), picture=login_session.get('picture')) else: return render_template('edit-category.html', CLIENT_ID=CLIENT_ID, signed_in=auth.is_signed_in(), picture=login_session.get('picture')) elif request.method == 'POST': # This is meant to be reached from AJAX request. # We return a JSON response that will be used by # The JS code making the request. if not auth.is_user_admin(): return response.error('Unauthorized') if request.form['name'] and request.form['desc']: if id and id != 0: # id is specified, update existing category category = db_utils.update_category(id, request.form['name'], request.form['desc']) categoryData = { 'id': category.id, 'name': category.name, 'desc': category.desc } return response.success(url_for('get_index'), categoryData) else: category = db_utils.add_category(request.form['name'], request.form['desc']) categoryData = { 'id': category.id, 'name': category.name, 'desc': category.desc } return response.success(url_for('get_index'), categoryData)
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: params = json.loads(self.request.body) campTarMemItm = CampTargetMemberItem.query(CampTargetMemberItem.email == memberObj.email, CampTargetMemberItem.item == params['data']['item']).get() campTarMemItm.qty = int(params['data']['qty']) campTarMemItm.put() self.response.out.write(json.dumps(response.success("success", { "email" : campTarMemItm.email, "item" : campTarMemItm.item })))
def post(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "CampTarget") if memberObj: params = json.loads(self.request.body) campTar = CampTarget.query(CampTarget.type == params['type'], CampTarget.fromlevel == params['fromlevel'], CampTarget.tolevel == params['tolevel']).get() campTar.order = params['data']['order'] campTar.put() self.response.out.write(json.dumps(response.success("success", { "type" : campTar.type, "fromlevel" : campTar.fromlevel, "tolevel" : campTar.tolevel })))
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "CampTarget") if memberObj: params = json.loads(self.request.body) campTar = CampTarget.query(CampTarget.type == params['type'], CampTarget.fromlevel == params['fromlevel'], CampTarget.tolevel == params['tolevel']).get() deleteCampTargetItems(campTar) campTar.key.delete() self.response.out.write(json.dumps(response.success("success", {})))
def get_user(): return response.success( { "user": { "email": g.user.email, "icloud": g.user.icloud, "filters": g.user.filters, } } )
async def get(self): name = generate_video_name(config['TWITCH_CHANNEL'], self.timezone) data = await self.twitch.get_stream_data() response = await self.uploader.upload(name, data) self.write_json(success({ 'url': response.url, 'name': name }))
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: moduleDataObj = moduleTypeToClassMap[self.request.get("modType")].query_model({ "id" : self.request.get("id") }) if self.canEdit or moduleDataObj.email == self.member.email: moduleTypeToClassMap[self.request.get("modType")].delete_model({ "id" : self.request.get("id") }) Module.moduleData_deleted({ "id" : self.request.get("modId") }, moduleDataObj) self.response.out.write(json.dumps(response.success("success", {}))) else: self.response.out.write(json.dumps(response.failure("401", "No permission to edit Module Data related data")))
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: type = self.request.get("type") fromlevel = int(self.request.get("fromlevel")) tolevel = int(self.request.get("tolevel")) campTar = CampTarget.query(CampTarget.type == type, CampTarget.fromlevel == fromlevel, CampTarget.tolevel == tolevel).get() self.response.out.write(json.dumps(response.success("success", campTar.to_dict())))
def user_artists(): try: offset = int(request.args.get("offset", 0)) except ValueError: offset = 0 query = UserArtist.query.filter(UserArtist.user_id == g.user.id).order_by( UserArtist.date_updated.desc()) data = paginate_query(query, offset, "user_artist") return response.success(data)
def get(self): self.response.headers['Content-Type'] = 'application/json' if self.member: delete_from_query(CampTargetMemberItem.query().fetch()) campTars = moduledata.CampTarget.query().fetch() for campTar in campTars: for campTarItm in campTars.campItems: campTarItm.completed = 0 campTar.put() self.response.out.write(json.dumps(response.success("success", {})))
def do_sign_in(): # This is meant to be reached from AJAX request. # We return a JSON response that will be used by # The JS code making the request. if (request.form['signin_request_token'] != login_session['signin_request_token']): return response.error('Invalid token.') g_id_token = request.form['id_token'] try: idinfo = id_token.verify_oauth2_token(g_id_token, requests.Request(), CLIENT_ID) if (idinfo['iss'] not in ['accounts.google.com', 'https://accounts.google.com']): raise ValueError('Wrong issuer.') if idinfo['aud'] != CLIENT_ID: raise ValueError('Invalid client id.') except ValueError: return response.error('Could not sign in') user_id = idinfo['sub'] stored_id_token = login_session.get('id_token') stored_user_id = login_session.get('user_id') user = db_utils.get_user(user_id) if user is None: # Add user to database if id does not exist. db_utils.add_user(user_id, idinfo['email'], idinfo['name']) if stored_id_token is not None and stored_user_id == user_id: return response.success() # Store the access token in the session for later use. login_session['id_token'] = g_id_token login_session['user_id'] = user_id login_session['name'] = idinfo['name'] login_session['email'] = idinfo['email'] login_session['picture'] = idinfo['picture'] return response.success()
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "ModuleData") if memberObj: moduleDataId = int(self.request.get("id")) moduleType = self.request.get("modType") moduleClass = moduleTypeToClassMap[moduleType] moduleDataObj = moduleClass.query(moduleClass.id == moduleDataId).get() moduleDataObj.key.delete() self.response.out.write(json.dumps(response.success("success", {})))
def get_sovereign_state(vid): """ Return information for a single sovereign state. :param vid: The UUID for the sovereign state :type vid: str :rtype: flask.Response """ return response.success(SovereignState.get(vid))
def post(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "Alliance") if memberObj: params = json.loads(self.request.body) allianceData = params['data'] alliance = Alliance.query().get() alliance.populate(**allianceData) alliance.put() self.response.out.write(json.dumps(response.success("success", {})))
def email(event,context): try: body=json.loads(event['body']) text="" for i in body.keys(): text+=i+": "+body[i]+"\n" print(text) send_email(recipient="*****@*****.**",body=text,name=body['fullName']) return success({"message":"E-mail has been sent"}) except Exception as e: print("Error here :",e) return failure(repr(e))
def main(event, context): # Execute scan in dynamodb try: result = dynamodb.call(tableRegion, tableName, "scan") # Return 500 and status failed in case of error except: return response.failure(json.dumps({ "status": "false" })) # Return 200 and items in case of success else: return response.success(json.dumps(result["Items"], cls=DecimalEncoder))
def get(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member_and_can_edit(self, "CampTarget") if memberObj: delete_from_query(CampTargetMemberItem.query().fetch()) campTars = CampTarget.query().fetch() for campTar in campTars: for campTarItm in campTars.campItems: campTarItm.completed = 0 campTar.put() self.response.out.write(json.dumps(response.success("success", {})))
def login(): data = request.json try: LoginValidator(data) except: return fail("Supply username and password", 400) user = verify_login(data["username"], data["password"]) if user == None: return fail("Invalid login details", 400) return success({"token": generate_auth_token(user).decode('ascii')})
def post(self): self.response.headers['Content-Type'] = 'application/json' memberObj = member.validate_user_is_member(self) if memberObj: params = json.loads(self.request.body) campTarMemItm = CampTargetMemberItem() campTarMemItm.email = memberObj.email campTarMemItm.item = params['data']['item'] campTarMemItm.qty = int(params['data']['qty']) campTarMemItm.put() updated = update_camp_target_items(campTarMemItm, campTarMemItm.qty) self.response.out.write(json.dumps(response.success("success", { "email" : campTarMemItm.email, "item" : campTarMemItm.item }, { "updated" : updated })))
def main(event, context): # prepare the key to delete in dynamodb recipe table key = {"recipeId": event["pathParameters"]["id"]} # Execute delete item in dynamodb try: dynamodb.call(tableRegion, tableName, "delete_item", Key=key) # Return 500 and status failed in case of error except: return response.failure(json.dumps({"status": "false"})) # Return 200 in case of success else: return response.success(json.dumps({"status": "true"}))
def user_releases_global(): try: offset = int(request.args.get("offset", 0)) except ValueError: offset = 0 query = (db.session.query(ArtistRelease, Release, UserRelease).join( Release, Release.mbid == ArtistRelease.release_mbid).filter( Release.type.in_(g.user.filters), ).outerjoin( UserRelease, and_(UserRelease.mbid == Release.mbid, UserRelease.user_id == g.user.id), ).order_by(Release.date_release.desc())) data = paginate_query(query, offset, "user_release_quick") return response.success(data)
def import_artists_endpoint(): """ Import artists Arguments: - artists: [string] - import_method: ['apple', 'spotify'] """ user = g.user artists = request.json.get('artists') import_method = request.json.get('import_method') if not artists or len(artists) == 0: return response.error("Missing artists dictionary.") if not import_method: return response.error("Missing import_method") result = import_processing.import_artists(user, artists, import_method) return response.success({'artists_imported': result})
def import_artists_endpoint(): """ Import artists Arguments: - artists: [string] - import_method: ['apple', 'spotify'] """ import_processor = ImportProcessor() artists = request.json.get("artists") import_method = request.json.get("import_method") if not artists or len(artists) == 0: return response.error("Missing artists dictionary.") if not import_method: return response.error("Missing import_method") saved_imports = import_processor.save_imports(g.user.id, artists, import_method) return response.success({"artists_imported": saved_imports})
def new_user(): email = request.json.get("email") password = request.json.get("password") icloud = request.json.get("icloud") if (email is None or password is None) and icloud is None: return response.error("Proper account credentials were not provided.") if icloud and repo.get_user_by_icloud(icloud): return response.error("Registration failed.") if email and repo.get_user_by_email(email): return response.error("Registration failed.") user = repo.insert_user(email, icloud, password) if user: aeon_app.logger.info("New user created: {}".format(user.id)) return response.success("New user created: {}".format(user.id)) else: aeon_app.logger.error("New user failed to save.") return response.error("An unknown error occurred when creating this account.")
def main(event, context): # Prepare item to put in db with event data data = json.loads(event["body"]) item = { "recipeId": str(uuid.uuid4()), "content": data["content"], "picture": data["picture"], "createdAt": str(datetime.datetime.now()) } # Execute put item in dynamodb try: dynamodb.call(tableRegion, tableName, "put_item", Item=item) # Return 500 and status failed in case of error except: return response.failure(json.dumps({ "status": "false" })) # Return 200 and added item in case of success else: return response.success(json.dumps(item))
def main(event, context): # Prepare item to update in db with event data data = json.loads(event["body"]) if data.get("picture") is not None and data.get("content") is not None: updateExpression = "SET content = :content, picture = :picture, updatedAt = :updatedAt" expressionAttributeValues = { ":picture": data["picture"], ":content": data["content"], ":updatedAt": str(datetime.datetime.now()), } elif data.get("content") is not None: updateExpression = "SET content = :content, updatedAt = :updatedAt" expressionAttributeValues = { ":content": data["content"], ":updatedAt": str(datetime.datetime.now()), } else: updateExpression = "SET picture = :picture" expressionAttributeValues = { ":picture": data["picture"] } # Execute update item in dynamodb try: dynamodb.call(tableRegion, tableName, "update_item", Key={ "recipeId": event["pathParameters"]["id"] }, UpdateExpression=updateExpression, ExpressionAttributeValues=expressionAttributeValues, ReturnValues="UPDATED_NEW" ) # Return 500 and status failed in case of error except: return response.failure(json.dumps({ "status": "false" })) # Return 200 in case of success else: return response.success(json.dumps({ "status": "true" }))
def import_lastfm_artists(): """ Import artists from Last.FM Arguments: - username: last.FM username to import artists from - period: ['7day', '1month', '3month', '6month', '12month', 'overall'] - (optional) limit: maximum 500, default 500 """ user = g.user username = request.json.get('username') period = request.json.get('period') limit = request.json.get('limit') if username is None or period not in [ '7day', '1month', '3month', '6month', '12month', 'overall' ]: return response.error("Username empty or period is incorrect.") if limit is None or limit > 500: limit = 500 result = import_processing.import_from_lastfm(user, username, limit, period) return response.success({'artists_imported': result})
def import_numu_v2(): """ Import data from Numu API v2 Imports: - artists - listening history - filters """ user = g.user repo = Repo() import_processor = ImportProcessor() release_processor = ReleaseProcessor() username = user.email if user.email else user.icloud result = {} data = grab_json( "https://www.numutracker.com/v2/json2.php?importv2={}&key={}".format( username, numu_app.config.get("NUMU_V2_API_KEY") ) ) result["raw_data"] = data filters = data.get("filters") if filters: user.album = bool(filters["album"]) user.ep = bool(filters["ep"]) user.single = bool(filters["single"]) user.live = bool(filters["live"]) user.soundtrack = bool(filters["soundtrack"]) user.remix = bool(filters["remix"]) user.other = bool(filters["other"]) repo.save(user) repo.commit() artists = data.get("artists") if artists: imported = import_processor.save_imports(user.id, artists, "v2") result["artists_imported"] = imported listens = data.get("listens") if listens: releases_added = 0 for listen in listens: release_mbid = listen.get("mbid") release = release_processor.add_release(release_mbid) if release: user_release, notify = release_processor.add_user_release( release, user_id=user.id ) user_release.listened = True user_release.date_listened = listen.get("listen_date") repo.save(user_release) if notify: releases_added += 1 repo.commit() result["releases_added"] = releases_added return response.success(result)
def user_artists(page): query = UserArtist.query.filter(UserArtist.user_id == g.user.id) data = paginate_query(query, page) return response.success(data)
def do_sign_out(): login_session.clear() return response.success()
def get_edit_item_page(id=0): if request.method == 'GET': if not auth.is_signed_in(): # Redirect to login page. # The url to which we are redirected will contain a paramenter # which will be the url to redirect back to # after logging in redirect_parameter = None if id and id != 0: redirect_parameter = 'redirect={}'.format( url_for('edit_item', id=id)) else: redirect_parameter = 'redirect={}'.format(url_for('new_item')) url = '{path}?{parameter}'.format( path=url_for('get_login_page'), parameter=redirect_parameter) return redirect(url, 302) categories = db_utils.get_categories() item = None if id and id != 0: item = db_utils.get_item(id) if item is None: return render_template('404.html') else: if (not auth.is_user_admin() and item.user_id != auth.get_user_id()): # Cannot edit item that does not belong to user # But admins are allowed return render_template('unauthorized.html') return render_template('edit-item.html', item=item, categories=categories, CLIENT_ID=CLIENT_ID, signed_in=auth.is_signed_in(), user_name=auth.get_user_name(), picture=login_session.get('picture')) elif request.method == 'POST': # This is meant to be reached from AJAX request. # We return a JSON response that will be used by # The JS code making the request. if not auth.is_signed_in(): return response.error('Unauthorized') if id and id != 0: # Update item item = db_utils.get_item(id) if (not auth.is_user_admin() and item.user_id != auth.get_user_id()): # Only item owners and admins allowed to update item return response.error('Unauthorized') if (request.form['name'] and request.form['desc'] and request.form['cat-id']): item = db_utils.update_item(request.form['item-id'], request.form['name'], request.form['desc'], request.form['cat-id']) itemData = { 'id': item.id, 'name': item.name, 'desc': item.desc, 'short_desc': item.short_desc, 'category_id': item.category_id } return response.success( url_for('get_item_page', id=itemData['id']), itemData) else: return response.error('Failed to save') else: # Create new item if (request.form['name'] and request.form['desc'] and request.form['cat-id']): item = db_utils.add_item(request.form['name'], request.form['desc'], request.form['cat-id'], auth.get_user_id()) itemData = { 'id': item.id, 'name': item.name, 'desc': item.desc, 'short_desc': item.short_desc, 'category_id': item.category_id } return response.success( url_for('get_item_page', id=itemData['id']), itemData) else: return response.error('Failed to save')