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): 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, 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, 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)