def get(self, drawing_id):
drawing_db = model.Drawing.get_by_id(drawing_id)
if not drawing_db or not drawing_db.json:
helpers.make_not_found_exception('Drawing %s not found' %
drawing_id)
if drawing_db.json:
return flask.jsonify(drawing_db.json)
def delete(self, currency_key):
currency_db = ndb.Key(urlsafe=currency_key).get()
if not currency_db:
helpers.make_not_found_exception('Currency %s not found' %
currency_key)
currency_db.key.delete()
return helpers.make_response(currency_db, model.Currency.FIELDS)
def delete(self):
resource_keys = util.param("resource_keys", list)
if not resource_keys:
helpers.make_not_found_exception("Resource(s) %s not found" % resource_keys)
resource_db_keys = [ndb.Key(urlsafe=k) for k in resource_keys]
delete_resource_dbs(resource_db_keys)
return flask.jsonify({"result": resource_keys, "status": "success"})
def delete(self, transaction_key):
transaction_db = ndb.Key(urlsafe=transaction_key).get()
if not transaction_db:
helpers.make_not_found_exception('Transaction %s not found' %
transaction_key)
transaction_db.key.delete()
return helpers.make_response(transaction_db, model.Transaction.FIELDS)
def delete(self, module_id):
module_config_keys = util.param("module_config_keys", list)
if not module_config_keys:
helpers.make_not_found_exception("Story(s) %s not found" % module_config_keys)
module_config_db_keys = [ndb.Key(urlsafe=k) for k in module_config_keys]
api_v1.set_obj_dbs_deleted(module_config_db_keys)
return flask.jsonify({"result": module_config_keys, "status": "success"})
def get(self, transaction_key):
transaction_db = ndb.Key(urlsafe=transaction_key).get()
if not transaction_db or transaction_db.user_key != auth.current_user_key(
):
helpers.make_not_found_exception('Transaction %s not found' %
transaction_key)
return helpers.make_response(transaction_db, model.Transaction.FIELDS)
def delete(self, comment_key):
comment_db = ndb.Key(urlsafe=comment_key).get()
if not comment_db:
helpers.make_not_found_exception('Comment %s not found' %
comment_key)
comment_db.key.delete()
return helpers.make_response(comment_db, model.Comment.FIELDS)
def get(self, title):
serie = Serie.get_by_id(title)
if not serie:
helpers.make_not_found_exception('Serie %s not found' % title)
issues = Issue.query(Issue.serie == serie.key).fetch()
return helpers.make_response(issues, model.Issue.FIELDS)
def delete(self, language_key):
language_db = ndb.Key(urlsafe=language_key).get()
if not language_db:
helpers.make_not_found_exception('Language %s not found' %
language_key)
language_db.key.delete()
return helpers.make_response(language_db, model.Language.FIELDS)
def delete(self, key):
resource_db = ndb.Key(urlsafe=key).get()
if not resource_db or (resource_db.user_key != auth.current_user_key()
and not auth.current_user_db().admin):
helpers.make_not_found_exception('Resource %s not found' % key)
delete_resource_key(resource_db.key)
return helpers.make_response(resource_db, model.Resource.FIELDS)
def post(self):
try:
drawing_json = json.loads(
json.dumps(json.loads(flask.request.data),
indent=2,
sort_keys=True))
m = hashlib.md5()
m.update(str(drawing_json))
drawing_hash = m.hexdigest()
drawing_db = model.Drawing.get_by('hash', drawing_hash)
if not drawing_db:
drawing_db = model.Drawing(hash=drawing_hash,
json=drawing_json)
drawing_db.put()
task.task_calculate_stats(drawing_db.created)
except (ValueError, AssertionError):
helpers.make_not_found_exception('Not valid JSON')
response = flask.make_response(
flask.jsonify({
'id':
drawing_db.key.id(),
'json':
flask.url_for('api.id',
drawing_id=drawing_db.key.id(),
_external=True),
}))
return response
def get(self, drawing_id):
drawing_db = model.Drawing.get_by_id(drawing_id)
if not drawing_db:
helpers.make_not_found_exception('Drawing %s not found' % drawing_id)
response = flask.make_response(drawing_db.data)
response.headers.set('Content-Type', 'application/octet-stream')
return response
def delete(self, key):
album_db = ndb.Key(urlsafe=key).get()
if not album_db or album_db.user_key != auth.current_user_key():
helpers.make_not_found_exception('Album %s not found' % key)
resource_dbs, cursors = album_db.get_resource_dbs()
delete_resource_dbs(resource_dbs)
delete_album_key(album_db.key)
return helpers.make_response(album_db, model.Album.FIELDS)
def delete(self):
drawing_keys = util.param('drawing_keys', list)
if not drawing_keys:
helpers.make_not_found_exception('Drawing(s) %s not found' % drawing_keys)
drawing_db_keys = [ndb.Key(urlsafe=k) for k in drawing_keys]
ndb.delete_multi(drawing_db_keys)
return flask.jsonify({
'result': drawing_keys,
'status': 'success',
})
def delete(self):
vote_keys = util.param('vote_keys', list)
if not vote_keys:
helpers.make_not_found_exception('Vote(s) %s not found' % vote_keys)
vote_db_keys = [ndb.Key(urlsafe=k) for k in vote_keys]
ndb.delete_multi(vote_db_keys)
return flask.jsonify({
'result': vote_keys,
'status': 'success',
})
def delete(self):
post_keys = util.param('post_keys', list)
if not post_keys:
helpers.make_not_found_exception('Post(s) %s not found' % post_keys)
post_db_keys = [ndb.Key(urlsafe=k) for k in post_keys]
ndb.delete_multi(post_db_keys)
return flask.jsonify({
'result': post_keys,
'status': 'success',
})
def delete(self):
user_keys = util.param('user_keys', list)
if not user_keys:
helpers.make_not_found_exception('User(s) %s not found' % user_keys)
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
delete_user_dbs(user_db_keys)
return flask.jsonify({
'result': user_keys,
'status': 'success',
})
def delete(self):
user_keys = util.param('user_keys', list)
if not user_keys:
helpers.make_not_found_exception('User(s) %s not found' % user_keys)
user_db_keys = [ndb.Key(urlsafe=k) for k in user_keys]
delete_user_dbs(user_db_keys)
return flask.jsonify({
'result': user_keys,
'status': 'success',
})
def delete(self):
comment_keys = util.param('comment_keys', list)
if not comment_keys:
helpers.make_not_found_exception('Comment(s) %s not found' %
comment_keys)
comment_db_keys = [ndb.Key(urlsafe=k) for k in comment_keys]
ndb.delete_multi(comment_db_keys)
return flask.jsonify({
'result': comment_keys,
'status': 'success',
})
def delete(self):
language_keys = util.param('language_keys', list)
if not language_keys:
helpers.make_not_found_exception('Language(s) %s not found' %
language_keys)
language_db_keys = [ndb.Key(urlsafe=k) for k in language_keys]
ndb.delete_multi(language_db_keys)
return flask.jsonify({
'result': language_keys,
'status': 'success',
})
def delete(self):
resource_keys = util.param('resource_keys', list)
if not resource_keys:
helpers.make_not_found_exception('Resource(s) %s not found' %
resource_keys)
resource_db_keys = [ndb.Key(urlsafe=k) for k in resource_keys]
delete_resource_dbs(resource_db_keys)
return flask.jsonify({
'result': resource_keys,
'status': 'success',
})
def delete(self):
transaction_keys = util.param('transaction_keys', list)
if not transaction_keys:
helpers.make_not_found_exception('Transaction(s) %s not found' %
transaction_keys)
transaction_db_keys = [ndb.Key(urlsafe=k) for k in transaction_keys]
ndb.delete_multi(transaction_db_keys)
return flask.jsonify({
'result': transaction_keys,
'status': 'success',
})
def delete(self):
resource_keys = util.param('resource_keys', list)
if not resource_keys:
helpers.make_not_found_exception(
'Resource(s) %s not found' % resource_keys
)
resource_db_keys = [ndb.Key(urlsafe=k) for k in resource_keys]
delete_resource_dbs(resource_db_keys)
return flask.jsonify({
'result': resource_keys,
'status': 'success',
})
def get(self, title):
issue = Issue.get_by_id(title)
if not issue:
helpers.make_not_found_exception('Issue %s not found' % title)
if len(issue.summary) == 0:
parser = Parser()
parser.parse_issue_summary(issue)
return flask.jsonify({
'result': issue.summary,
'status': 'success',
})
def put(self, key):
resource_db = ndb.Key(urlsafe=key).get()
if not resource_db:
helpers.make_not_found_exception('Resource %s not found' % key)
review = model.ResourceReview(
parent=resource_db.key,
reviewer_user_key=auth.current_user_key(),
value=-10)
review.put()
resource_db.reset_hotness()
resource_db.put()
return helpers.make_response(resource_db, model.Resource.FIELDS)
def delete(self):
story_keys = util.param('story_keys', list)
restore = util.param('restore', bool)
if not story_keys:
helpers.make_not_found_exception('Story(s) %s assigned in the parameter [story_keys]'
' not found' % story_keys)
story_db_keys = [ndb.Key(urlsafe=k) for k in story_keys]
api_resource_base.set_obj_dbs_deleted(story_db_keys, restore)
return flask.jsonify({
'result': story_keys,
'status': 'success',
'now': datetime.utcnow().isoformat()
})
def delete(self):
resource_keys = util.param('resource_keys', list)
if not resource_keys:
helpers.make_not_found_exception(
'Resource(s) %s not found' % resource_keys
)
for k in resource_keys:
resource_db_key = ndb.Key(urlsafe=k)
resource_db = resource_db_key.get()
if resource_db.user_key == auth.current_user_key():
delete_resource_dbs([resource_db_key])
return flask.jsonify({
'result': resource_keys,
'status': 'success',
})
def get(self, lesson_key):
"""Returns lesson"""
lesson_db = ndb.Key(urlsafe=lesson_key).get()
if not lesson_db:
return helpers.make_not_found_exception('Lesson %s not found' %
lesson_key)
return helpers.make_response(lesson_db, model.Lesson.FIELDS)
def post(self, lesson_key):
"""Updates a specific lesson"""
if util.param('name') and util.param('is_a'):
b_is_a = util.param('is_a')
b_data = helpers.data_scheme_constructor(
b_is_a, helpers.rerieve_content_fields(util))
b_topics = [
ndb.Key(urlsafe=topic_key_url)
for topic_key_url in util.param('topics', list)
]
b_name = util.param('name')
b_description = util.param('description')
b_lesson = ndb.Key(urlsafe=lesson_key).get()
if not b_lesson:
return helpers.make_not_found_exception('Lesson %s not found' %
lesson_key)
b_lesson.data = b_data
b_lesson.name = b_name
b_lesson.is_a = b_is_a
b_lesson.description = b_description
b_lesson.topics = b_topics
b_lesson = b_lesson.put()
response = {
'status': 'success',
'count': 1,
'now': helpers.time_now(),
'result': {
'message':
'Lesson was successfuly updated!!',
'view_url':
flask.url_for('lesson', lesson_key=b_lesson.urlsafe())
},
}
return response
return helpers.make_bad_request_exception("Unsifificient parameters")
def post(self, lesson_key):
if util.param('name') and util.param('is_a'):
b_is_a = util.param('is_a')
b_data = helpers.data_scheme_constructor(b_is_a, helpers.rerieve_content_fields(util))
b_topics = [ ndb.Key(urlsafe=topic_key_url) for topic_key_url in util.param('topics', list)]
b_name = util.param('name')
b_description = util.param('description')
b_contributor = auth.current_user_key()
b_lesson = ndb.Key(urlsafe=lesson_key).get()
if not b_lesson:
return helpers.make_not_found_exception('Lesson %s not found' % b_lesson)
b_lesson_version = model.LessonVersion(data=b_data,name=b_name,is_a=b_is_a,description=b_description,topics=b_topics,lesson=b_lesson.key,contributor=b_contributor).put()
b_lesson.contributors += [b_contributor]
b_lesson.lesson_versions += [b_lesson_version]
b_lesson.put()
response = {
'status': 'success',
'count': 1,
'now': helpers.time_now(),
'result': {'message': 'Lesson Version update proposal was successfuly created!!',
'view_url': flask.url_for('lesson_version', version_key=b_lesson_version.urlsafe())
},
}
return response
return helpers.make_bad_request_exception("Unsifificient parameters")
def post(self, version_key):
"""Updates a specific lesson version by key"""
if util.param('name') and util.param('is_a'):
b_is_a = util.param('is_a')
b_data = helpers.data_scheme_constructor(b_is_a, helpers.rerieve_content_fields(util))
b_topics = [ ndb.Key(urlsafe=topic_key_url) for topic_key_url in util.param('topics', list)]
b_name = util.param('name')
b_description = util.param('description')
b_lesson_version = ndb.Key(urlsafe=version_key).get()
if not b_lesson_version:
return helpers.make_not_found_exception('LessonVersion %s not found' % b_lesson_version)
b_lesson_version.data=b_data
b_lesson_version.name=b_name
b_lesson_version.is_a=b_is_a
b_lesson_version.description=b_description
b_lesson_version.topics=b_topics
b_lesson_version = b_lesson_version.put()
response = {
'status': 'success',
'count': 1,
'now': helpers.time_now(),
'result': {'message': 'Lesson Version was successfuly updated!',
'view_url': flask.url_for('lesson_version', version_key=b_lesson_version.urlsafe())
},
}
return response
return helpers.make_bad_request_exception("Unsifificient parameters")
def post(self, lesson_key):
"""Updates a specific lesson"""
if util.param("name") and util.param("is_a"):
b_is_a = util.param("is_a")
b_data = helpers.data_scheme_constructor(b_is_a, helpers.rerieve_content_fields(util))
b_topics = [ndb.Key(urlsafe=topic_key_url) for topic_key_url in util.param("topics", list)]
b_name = util.param("name")
b_description = util.param("description")
b_lesson = ndb.Key(urlsafe=lesson_key).get()
if not b_lesson:
return helpers.make_not_found_exception("Lesson %s not found" % lesson_key)
b_lesson.data = b_data
b_lesson.name = b_name
b_lesson.is_a = b_is_a
b_lesson.description = b_description
b_lesson.topics = b_topics
b_lesson = b_lesson.put()
response = {
"status": "success",
"count": 1,
"now": helpers.time_now(),
"result": {
"message": "Lesson was successfuly updated!!",
"view_url": flask.url_for("lesson", lesson_key=b_lesson.urlsafe()),
},
}
return response
return helpers.make_bad_request_exception("Unsifificient parameters")
def get(self, course_key):
"""Returns a course"""
course_db = ndb.Key(urlsafe=course_key).get()
if not course_db:
return helpers.make_not_found_exception('Course %s not found' %
course_key)
return helpers.make_response(course_db, model.Course.FIELDS)
def get(self, track_key):
"""Returns a track"""
track_db = ndb.Key(urlsafe=track_key).get()
if not track_db:
return helpers.make_not_found_exception('track %s not found' %
track_key)
return helpers.make_response(track_db, model.Track.FIELDS)
def delete(self, version_key):
"""Deletes a specific lesson version"""
lesson_version_key = ndb.Key(urlsafe=version_key)
if not lesson_version_key:
return helpers.make_not_found_exception('LessonVersion %s not found' % lesson_version_key)
lesson_version_key.delete()
return flask.jsonify({
'result': {'message': 'LessonVersion successfuly deleted', 'key': lesson_version_key},
'status': 'success',
})
def delete(self, lesson_key):
"""Deletes a specific lesson"""
lesson_key = ndb.Key(urlsafe=lesson_key).get()
if not lesson_key:
return helpers.make_not_found_exception("Lesson %s not found" % lesson_key)
lesson_key.deadLock = True
lesson_key.approved = False
lesson_key = lesson_key.put()
return flask.jsonify(
{"result": {"message": "Lesson has been placed in dealock state", "key": lesson_key}, "status": "success"}
)
def delete(self, course_key):
"""Deletes a specific course"""
course_db = ndb.Key(urlsafe=course_key).get()
if not course_db:
return helpers.make_not_found_exception('Course %s not found' % course_key)
course_db.deadLock = True
course_db.approved = False
course_db = course_db.put()
return flask.jsonify({
'result': {'message': 'Course has been placed in dealock state', 'key': course_key},
'status': 'success',
})
def delete(self, track_key):
"""Deletes a specific Track"""
track_db = ndb.Key(urlsafe=track_key).get()
if not track_db:
return helpers.make_not_found_exception('track %s not found' % track_key)
track_db.deadLock = True
track_db.approved = False
track_db = track_db.put()
return flask.jsonify({
'result': {'message': 'track has been placed in dealock state', 'key': track_key},
'status': 'success',
})
def post(self, lesson_key):
data = util.param("data")
lesson_db = ndb.Key(urlsafe=lesson_key).get()
if not lesson_db:
return helpers.make_not_found_exception("Lesson %s not found" % lesson_key)
if data == "true":
lesson_db.approved = True
elif data == "false":
lesson_db.approved = False
lesson_key = lesson_db.put()
return flask.jsonify(
{"result": {"message": "Lesson has been updated", "key": lesson_key.urlsafe()}, "status": "success"}
)
def post(self, course_key):
data = util.param("data")
course_db = ndb.Key(urlsafe=course_key).get()
if not course_db:
return helpers.make_not_found_exception('Course %s not found' % course_key)
if data == "true":
course_db.approved = True
elif data == "false":
course_db.approved = False
course_db = course_db.put()
return flask.jsonify({
'result': {'message': 'Course has been updated', 'key': course_db.urlsafe()},
'status': 'success',
})
def post(self, version_key):
data = util.param("data")
lesson_version_db = ndb.Key(urlsafe=version_key).get()
if not lesson_version_db:
return helpers.make_not_found_exception('Lesson Version %s not found' % version_key)
if data == "true":
lesson_version_db.approved = True
elif data == "false":
lesson_version_db.approved = False
version_key = lesson_version_db.put()
return flask.jsonify({
'result': {'message': 'Lesson has been updated', 'key': version_key.urlsafe()},
'status': 'success',
})
def post(self, track_key):
data = util.param("data")
track_db = ndb.Key(urlsafe=track_key).get()
if not track_db:
return helpers.make_not_found_exception('track %s not found' % track_key)
if data == "true":
track_db.approved = True
elif data == "false":
track_db.approved = False
track_db = track_db.put()
return flask.jsonify({
'result': {'message': 'track has been updated', 'key': track_db.urlsafe()},
'status': 'success',
})
def delete(self, version_key):
"""Deletes a specific lesson version"""
lesson_version_key = ndb.Key(urlsafe=version_key)
if not lesson_version_key:
return helpers.make_not_found_exception(
'LessonVersion %s not found' % lesson_version_key)
lesson_version_key.delete()
return flask.jsonify({
'result': {
'message': 'LessonVersion successfuly deleted',
'key': lesson_version_key
},
'status': 'success',
})
def delete(self, course_key):
"""Deletes a specific course"""
course_db = ndb.Key(urlsafe=course_key).get()
if not course_db:
return helpers.make_not_found_exception('Course %s not found' %
course_key)
course_db.deadLock = True
course_db.approved = False
course_db = course_db.put()
return flask.jsonify({
'result': {
'message': 'Course has been placed in dealock state',
'key': course_key
},
'status': 'success',
})
def delete(self, track_key):
"""Deletes a specific Track"""
track_db = ndb.Key(urlsafe=track_key).get()
if not track_db:
return helpers.make_not_found_exception('track %s not found' %
track_key)
track_db.deadLock = True
track_db.approved = False
track_db = track_db.put()
return flask.jsonify({
'result': {
'message': 'track has been placed in dealock state',
'key': track_key
},
'status': 'success',
})
def delete(self, lesson_key):
"""Deletes a specific lesson"""
lesson_key = ndb.Key(urlsafe=lesson_key).get()
if not lesson_key:
return helpers.make_not_found_exception('Lesson %s not found' %
lesson_key)
lesson_key.deadLock = True
lesson_key.approved = False
lesson_key = lesson_key.put()
return flask.jsonify({
'result': {
'message': 'Lesson has been placed in dealock state',
'key': lesson_key
},
'status': 'success',
})
def delete(self, topic_key):
"""Deletes a specific topic"""
topic_db = ndb.Key(urlsafe=topic_key).get()
if not topic_db:
helpers.make_not_found_exception("Topic %s not found" % topic_key)
pass
def get(self, topic_key):
topic_db = ndb.Key(urlsafe=topic_key).get()
if not topic_db:
helpers.make_not_found_exception("Topic %s not found" % topic_key)
return helpers.make_response(topic_db, model.Topic.FIELDS)
def get(self, crash_key):
crash_db = ndb.Key(urlsafe=crash_key).get()
if not crash_db:
helpers.make_not_found_exception('Crash %s not found' % crash_key)
return helpers.make_response(crash_db, model.Crash.FIELDS)
def get(self, course_key):
"""Returns a course"""
course_db = ndb.Key(urlsafe=course_key).get()
if not course_db:
return helpers.make_not_found_exception('Course %s not found' % course_key)
return helpers.make_response(course_db, model.Course.FIELDS)
def get(self, person_key):
person_db = ndb.Key(urlsafe=person_key).get()
if not person_db:
helpers.make_not_found_exception('Person %s not found' % person_key)
return helpers.make_response(person_db, model.Person.FIELDS)
def delete(self, key):
resource_db = ndb.Key(urlsafe=key).get()
if not resource_db or resource_db.user_key != auth.current_user_key():
helpers.make_not_found_exception('Resource %s not found' % key)
delete_resource_key(resource_db.key)
return helpers.make_response(resource_db, model.Resource.FIELDS)
def get(self, lesson_key):
"""Returns lesson"""
lesson_db = ndb.Key(urlsafe=lesson_key).get()
if not lesson_db:
return helpers.make_not_found_exception("Lesson %s not found" % lesson_key)
return helpers.make_response(lesson_db, model.Lesson.FIELDS)
def get(self, project_key):
project_db = ndb.Key(urlsafe=project_key).get()
if not project_db:
helpers.make_not_found_exception('Project %s not found' % project_key)
return helpers.make_response(project_db, model.Project.FIELDS)
def get(self, track_key):
"""Returns a track"""
track_db = ndb.Key(urlsafe=track_key).get()
if not track_db:
return helpers.make_not_found_exception('track %s not found' % track_key)
return helpers.make_response(track_db, model.Track.FIELDS)
def get(self, repo_key):
repo_db = ndb.Key(urlsafe=repo_key).get()
if not repo_db:
helpers.make_not_found_exception('Repo %s not found' % repo_key)
return helpers.make_response(repo_db, model.Repo.FIELDS)
def get(self, album_key):
album_db = ndb.Key(urlsafe=album_key).get()
if not album_db:
helpers.make_not_found_exception('album %s not found' % album_key)
return helpers.make_response(album_db, model.Album.FIELDS)
def delete(self, user_key):
user_db = ndb.Key(urlsafe=user_key).get()
if not user_db:
helpers.make_not_found_exception('User %s not found' % user_key)
user_db.key.delete()
return helpers.make_response(user_db, model.User.FIELDS)
def get(self, member_key):
member_db = ndb.Key(urlsafe=member_key).get()
if not member_db:
helpers.make_not_found_exception('member %s not found' % member_key)
return helpers.make_response(member_db, model.Member.FIELDS)
