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')
