def update(user, concept_key):
"""
Update a concept
:param user:
:param concept_key:
:return: Updated concept
"""
concept = ndb.Key(urlsafe=concept_key).get()
post = Utils.parse_json(request)
if 'name' in post:
concept.name = post['name']
if 'explanation' in post:
concept.explanation = post['explanation']
if 'references' in post:
references = []
for ref in post['references']:
reference = References(title=ref['title'], source=ref['source'])
references.append(reference)
concept.references = references
if 'tips' in post:
concept.tips = post['tips']
if 'questions' in post:
concept.questions = post['questions']
concept.put()
return Respond.success({'concept': concept.to_dict()})
def admin_login():
"""
Login a user
:return:
"""
# Pass the post details
post = Utils.parse_json(request)
# Check if email and password in the post
if 'email' not in post or 'password' not in post:
return Respond.error("Email password not found", error_code=422)
# Find the user with that email
user = User.query(User.email == post['email']).get()
# If user not found
if user is None:
return Respond.error("User not found with the provided email",
error_code=404)
if user.type != "Admin" and user.type != "Creator":
return Respond.error("Login with password not allowed", error_code=422)
# If password not correct
if not user.verify_password(post['password']):
return Respond.error("Password incorrect")
# Make token
token = user.make_token()
# Respond with user and token
return Respond.success({"token": token, "user": user.as_dict()})
def get(user):
"""
Get all the available courses
"""
courses = map(Course.as_dict, Course.query().fetch())
return Respond.success({"courses": courses})
def payment_status(user, payment_key):
payment_request = Utils.urlsafe_to_key(payment_key).get()
return Respond.success({
'status': payment_request.status,
'balance': user.getPoints()
})
def delete(user, concept_key):
"""
Delete the concept. Remove from chapter index
"""
concept = ndb.Key(urlsafe=concept_key).get()
concept.key.delete()
return Respond.success({"deleted_key": concept_key})
def get_chapters(user, subject_key):
subject = Utils.urlsafe_to_key(subject_key).get()
chapters = map(
Chapter.for_list,
Chapter.query(ancestor=subject.key).order(Chapter.srno).fetch())
return Respond.success({"chapters": chapters})
def get(user):
course = user.course.get()
if not course:
return Respond.error("User not subscribed to a course", error_code=400)
subjects = map(Subject.dict_for_list,
Subject.query(ancestor=course.key).fetch())
return Respond.success({"subjects": subjects})
def store(user): """ Store a course. :param user: :return: """ post = Utils.parse_json(request) course = Course(name=post['name']) course.put() return Respond.success(Course.as_dict(course))
def store(user):
"""
Store a subject.
:param user:
:return:
"""
post = Utils.parse_json(request)
subject = Subject(name=post['name'], parent=user.course)
subject.put()
return Respond.success(subject.dict_for_list())
def assign_rep(user):
"""
Assign rep to list of codes
"""
post = Utils.parse_json(request)
codes = UserCodes.query(UserCodes.srno >= post['start'], UserCodes.srno <= post['end'])
for code in codes:
code.repName = post['repName']
code.put()
return Respond.success('yo')
def done_concept(user, concept_key):
"""
Mark a concept as done
"""
# get the concept data entity
concept_data = UserConceptData.query(
UserConceptData.concept == Utils.urlsafe_to_key(concept_key),
ancestor=user.key).get()
if not concept_data:
return Respond.error(error="No data of user for this concept")
# mark it as understood
concept_data.done = True
concept_data.put()
# return
return Respond.success("Marked done")
def wrong_concept(user, concept_key):
"""
Mark a concept as wrong
"""
# get the concept data entity
concept_data = UserConceptData.query(
UserConceptData.concept == Utils.urlsafe_to_key(concept_key),
ancestor=user.key).get()
if not concept_data:
return Respond.error(error="No data of user for this concept")
# mark done as false
concept_data.done = False
concept_data.put()
# return
return Respond.success("Marked wrong")
def right_concept(user, concept_key):
"""
Mark a concept as right
"""
# get the concept data entity
concept_data = UserConceptData.query(
UserConceptData.concept == Utils.urlsafe_to_key(concept_key),
ancestor=user.key).get()
if not concept_data:
return Respond.error(error="No data of user for this concept")
# increase right count
concept_data.right = concept_data.right + 1
concept_data.put()
# return
return Respond.success("Marked right")
