def test_result(user, subject_key):
"""
Save the result and calculate points
"""
# subject = Utils.urlsafe_to_key(subject_key).get()
post = Utils.parse_json(request)
points_counter = 0
for result in post['result']:
if result['marked'] == "right":
UserTests(concept=Utils.urlsafe_to_key(result['key']),
right=True,
parent=user.key).put()
user.addPoints(1, "Answered correctly")
points_counter += 1
if result['marked'] == "wrong":
UserTests(concept=Utils.urlsafe_to_key(result['key']),
right=False,
parent=user.key).put()
user.addPoints(1, "Answered incorrectly")
points_counter += 1
return Respond.success({
"new_points": points_counter,
"balance": user.getPoints()
})
def revision_result(user, subject_key):
"""
Save the result and calculate points
"""
subject = Utils.urlsafe_to_key(subject_key).get()
post = Utils.parse_json(request)
points_counter = 0
for result in post['result']:
if result['marked'] == "read":
concept = Utils.urlsafe_to_key(result['key']).get()
data = UserConcept.query(UserConcept.concept == concept.key,
ancestor=user.key).get()
if not data:
data = UserConcept(parent=user.key,
subject=subject.key,
concept=concept.key)
data.read += 1
data.put()
user.addPoints(1, "Read concept")
points_counter += 1
return Respond.success({
"new_points": points_counter,
"balance": user.getPoints()
})
def add_code_for_user(user, user_key):
"""
Add a code for a user to user
"""
post = Utils.parse_json(request)
UserCodes(parent=Utils.urlsafe_to_key(user_key),
code=post['code'],
points=post['points']).put()
return Respond.success("Code added")
def subscribe(user, course_key):
"""
Subscribe a course
:param user:
:param course_key:
:return: Response
"""
post = Utils.parse_json(request)
user.course = Utils.urlsafe_to_key(course_key)
user.college = post['college']
user.put()
return Respond.success("Course subscribed by user")
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 activate_pro(user):
"""
Activate pro usage for the user
:param user:
:return: Response
"""
# Perform checks
if user.getPoints() < PRO_COST:
return Respond.error('Low balance', error_code=420)
if user.pro:
return Respond.error('User already a pro', error_code=410)
post = Utils.parse_json(request)
users_with_device = User.query(User.device == post['device']).fetch()
if len(users_with_device) > 0:
return Respond.error('Device already registered by another user')
# Activate Pro for user on this device
user.subtractPoints(PRO_COST, 'Activated Pro')
user.pro = True
user.device = post['device']
user.put()
return Respond.success('Activated pro for user')
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 subject_index(user, subject_key):
subject = Utils.urlsafe_to_key(subject_key).get()
index = []
chapters = Chapter.query(ancestor=subject.key).order(Chapter.srno)
# user_data = UserConcept.query(
# UserConcept.subject == subject.key,
# ancestor=user.key
# ).fetch()
for chapter in chapters:
concepts = []
concepts_list = Concept.query(ancestor=chapter.key).order(Concept.srno)
for concept in concepts_list:
concepts.append({"key": concept.key, "name": concept.name})
for concept in concepts:
# for data in user_data:
# if data.concept == concept['key']:
# concept['read'] = data.read
# concept['important'] = data.important
concept['key'] = concept['key'].urlsafe()
index.append({
"key": chapter.key.urlsafe(),
"name": chapter.name,
"concepts": concepts
})
return Respond.success({"index": index})
def mark_concept_important(user, concept_key):
"""
Mark a concept as important
"""
concept = Utils.urlsafe_to_key(concept_key).get()
# Get the user data for the concept
user_data = UserConcept.query(UserConcept.concept == concept.key,
ancestor=user.key).get()
if not user_data:
subject = concept.key.parent().parent()
user_data = UserConcept(subject=subject,
concept=concept.key,
important=True,
parent=user.key)
user_data.put()
else:
if user_data.important:
return Respond.error('Concept already marked important')
user_data.important = True
user_data.put()
return Respond.success('Concept marked important')
def subject_test(user, subject_key):
"""
Send test concepts
"""
subject_key = Utils.urlsafe_to_key(subject_key)
session_data = user.getSession()
if session_data['views'] < 5:
return Respond.error("Not enough views left", error_code=400)
# Find revised concepts
concepts = UserConcept.query(UserConcept.subject == subject_key,
ancestor=user.key).fetch()
# select 5 randomly
if len(concepts) < 5:
return Respond.error("Less than 5 concepts read", error_code=400)
# Unique indices
random_nums = random.sample(range(1, len(concepts)), 5)
test_concepts = []
for i in random_nums:
test_concepts.append(concepts[i].concept.get().to_dict())
user.subtractSessionViews(5)
return Respond.success({
"concepts": test_concepts,
"session_data": user.getSession()
})
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 post_back_to_external_events():
if request.method == "POST":
event_data = request.get_data('data')
event_json = Utils.bytes_to_json(event_data)
TaskObjectBuilder.build_task(PlacedTask.get_task(
event_json["id"])).save_to_db()
PlacedTask.remove_placed_task(event_json["id"])
return render_template("FullCalendar.html")
def login_company(company_name, password):
company_data = Database.find_one(COLLECTION, {"company_name": company_name})
if company_data is None:
return False
if Utils.check_hashed_password(password, company_data['password']):
return True
else:
return False
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 update_task():
if request.method == "POST":
event_data = request.get_data('data')
event_json = Utils.bytes_to_json(event_data)
print(event_json)
task = TaskObjectBuilder.build_placed_task(
PlacedTask.get_task(event_json["id"]), event_json["start"],
event_json["end"], session["user_id"])
task.update_task()
return render_template("FullCalendar.html")
def run(cadir):
filename = Utils.createFolder(cadir[0]) # 创建文件夹
log = Logger.Loger()
log.info(cadir[2] + u"测试开始")
log.info(u"开始创建文件夹和文件")
log.info(u"日志文件：" + filename[0])
log.info(u"报告文件：" + filename[1])
log.info(u"文件夹和文件创建成功")
log.info(u"开始执行测试用例")
result, infos = runTest(cadir[0], cadir[1]) # 收集和执行测试用例
log.info(u"测试用例执行完成，开始写入报告")
if cadir[2] == "functiontest":
Utils.createReport(result, infos, filename, cadir[3]) # 测试结果写入报告
log.info(u"报告写入结束，测试结束")
log.info(u"开始发送邮件……")
isSuccess = Utils.sendMail(filename[1], cadir[3])
log.info(isSuccess)
log.info(
"================================================================\n")
def read_concept(user, concept_key):
"""
Send the concept to the user
"""
if not user_has_views(user, 1):
return Respond.error('Not enough views left', error_code=420)
concept = Utils.urlsafe_to_key(concept_key).get()
return Respond.success({"concept": concept.to_dict()})
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 post_request():
if request.method == "POST":
event_data = request.get_data('data')
event_json = Utils.bytes_to_json(event_data)
task = TaskObjectBuilder.build_placed_task(
Task.get_task(event_json["id"]), event_json["start"],
event_json["end"], session["user_id"])
task.save_placed_task()
Task.remove_task(event_json["id"])
# add to db.placed_tasks here
# delete from db.External_tasks using the id
return render_template("FullCalendar.html")
def get_batch_concepts(user):
"""
Send concepts required by in the request
:param user:
:return:
"""
post = Utils.parse_json(request)
concepts = post['concepts']
if not user_has_views(user, len(concepts)):
return Respond.error('Not enough views left', error_code=420)
response = []
for concept in concepts:
entity = Utils.urlsafe_to_key(concept).get()
response.append(entity.to_dict())
return Respond.success({"concepts": response})
def social_login():
"""
Login via google
With the id token get user details, if the user does not
exist then create it. If the user is coming back then just save the id token
Then make a token and send it to the client
"""
post = Utils.parse_json(request)
id_token = post['id_token']
url = 'https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=%s' % id_token
try:
result = urlfetch.fetch(url)
if result.status_code == 200:
result = json.loads(result.content)
name = result['name']
email = result['email']
picture = result['picture']
else:
error = 'Status code: {} , Response: {}'.format(
result.status_code, result.content)
logging.error(error)
return Respond.error('Error getting user info from google.')
except urlfetch.Error:
logging.exception('Caught exception fetching url')
return Respond.error('Error getting user info from google.')
users = User.query(User.email == email).fetch()
if len(users) > 1:
return Respond.error("There was an error", error_code=422)
elif len(users) == 1:
# User already exists. Just make a token and return
user = users[0]
# Make token
token = user.make_token()
# Respond with user and token
return Respond.success({"token": token, "user": user.as_dict()})
else:
# New User. Create and send token
user = User(name=name, email=email, picture_uri=picture)
user.put()
# Make token
token = user.make_token()
# Respond with user and token
return Respond.success({"token": token, "user": user.as_dict()})
def get_from_teamwork(actn, name):
http = urllib3.PoolManager()
company = "wltc"
key = "twp_VJ8lmPZG8cdnAmW1UEYPqbHPzldj"
action = actn
url = "https://{0}.teamwork.com/{1}".format(company, action)
headers = urllib3.util.make_headers(basic_auth=key + ":xxx")
request = http.request('GET', url, headers=headers)
data = request.data
dic = Utils.bytes_to_json(data)
tasks = dic[name]
return tasks
def get_from_teamwork_scaled(actn, name, company_name, key):
http = urllib3.PoolManager()
company = company_name
key = key
action = actn
url = "https://{0}.teamwork.com/{1}".format(company, action)
headers = urllib3.util.make_headers(basic_auth=key + ":xxx")
request = http.request('GET', url, headers=headers)
data = request.data
dic = Utils.bytes_to_json(data)
tasks = dic[name]
return tasks
def edit_chapter(user, chapter_key):
"""
Edit the chapter
:param user:
:param chapter_key:
:return:
"""
chapter = ndb.Key(urlsafe=chapter_key).get()
post = Utils.parse_json(request)
chapter.name = post['name']
chapter.put()
return Respond.success(chapter.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 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")
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 save_result(user):
"""
Save the result for the user
:param user:
:return:
"""
post = Utils.parse_json(request)
points_counter = 0
for result in post['result']:
if result['marked'] == "read":
concept = Utils.urlsafe_to_key(result['key']).get()
data = UserConcept.query(UserConcept.concept == concept.key,
ancestor=user.key).get()
if not data:
data = UserConcept(parent=user.key, concept=concept.key)
data.read += 1
data.put()
user.addPoints(1, "Read concept")
points_counter += 1
user.subtractSessionViews(len(post['result']))
return Respond.success({
"new_points": points_counter,
"balance": user.getPoints(),
"session": user.getSession()
})
