def post(self):
checklist = Checklist(
title=self.request.get("title"), public=True, user=users.get_current_user(), deleted=False, subscribers=0
)
checklist.put()
self.response.write("/l/" + str(checklist.key().id()))
def create_checklist(request):
if request.POST:
print request.FILES
print request.POST
checklist = Checklist(name=request.POST['name'], author=request.user)
checklist.save()
if 'mass' in request.POST:
print request.POST['mass']
for i, item in enumerate(request.POST['mass'].split('\n')):
print i, item
checklist_element = ChecklistElement(checklist=checklist, text=item.strip(), order=i)
checklist_element.save()
else:
matches = {}
for i, element in enumerate(sorted([j for j in request.POST.keys() if j.startswith('text_')])):
checklist_element = ChecklistElement(checklist=checklist, text=request.POST[element], order=i)
checklist_element.save()
matches[element[5:]] = checklist_element.id
print checklist.name
for i in request.FILES:
f = request.FILES[i]
ext = f.name[f.name.index('.')+1:]
checklist_element = ChecklistElement.objects.get(id=matches[i[6:]])
checklist_element.image = f
checklist_element.save()
checklist.save()
for device in Device.objects.filter(user=request.user):
device.checklists.add(checklist)
context = RequestContext(request, {'action': 'create'})
return render_to_response("edit_checklist.html", context)
def post(self):
user = users.get_current_user()
if user:
checklist = Checklist(
title=self.request.get('title'),
user=user)
checklist.put()
self.redirect('/')
def test_reset_all_checked_count(client):
assert checklist_1.checked_count != 0
assert checklist_1.last_review_id != 0
with get_session() as s:
Checklist.reset_all_checked_count(s, checklist_1.scene_id)
with get_session() as s:
checklist_1_after = Checklist.get_by_id(s, checklist_1.id)
assert checklist_1_after.checked_count == 0
assert checklist_1_after.last_review_id == 0
def post(self):
checklist = Checklist(
title=self.request.get('title'),
public=True,
user=users.get_current_user(),
deleted=False,
)
checklist.put()
helpers.createResponse(self, 'new_cl.html', {'cl':checklist})
def post(self):
checklist = Checklist(
title=self.request.get('title'),
public=bool(self.request.get('public')),
description=self.request.get('description'),
user=users.get_current_user(),
deleted=False,
)
checklist.put()
self.redirect('/')
def get(self):
checklist = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=checklist): return
if not self.addable(checklist):
helpers.createResponse(self, 'message_can_not_create_item.html')
return
helpers.createResponse(self, 'create_item.html', {'checklist': checklist})
def post(self):
cl = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False):
return
user = users.get_current_user()
for sub in Subscription.all().filter("user ==", user).filter("deleted ==", False):
if sub.source.key() == cl.key():
helpers.createResponse(self, 'message_already_subscribed.html',
{'old_checklist': cl})
sub = Subscription(
user=user,
source=cl,
deleted=False,
)
sub.put()
for item in cl.item_set:
subItem = SubscribedItem(
subscription=sub,
original=item,
finished=False,
deleted=False,
)
subItem.put()
helpers.createResponse(self, 'message_subscribed.html')
def home():
"""
Home of a user, shows active checklists and templates.
"""
templates = ChecklistTemplate.objects(owner=g.user.name)
checklists = Checklist.objects(owner=g.user.name)
return render_template('home.html', templates=templates, checklists=checklists)
def get(self):
user = users.get_current_user()
checklist_q = Checklist.all().filter("user ==", user).filter("deleted ==", False).order("title");
cursor = self.request.get('cursor_cl')
if cursor:
checklist_q = checklist_q.with_cursor(cursor)
checklists = checklist_q.fetch(10)
checklist_q = checklist_q.with_cursor(checklist_q.cursor())
subs_by_cl = []
for cl in checklists:
subs = []
for sub in cl.subscription_set:
subs.append(sub)
subs_by_cl.append(subs)
subs_q = Subscription.all().filter("user ==", user).filter("deleted ==", False);
cursor = self.request.get('cursor_sub')
if cursor:
subs_q = subs_q.with_cursor(cursor)
subs = subs_q.fetch(10)
subs_q = subs_q.with_cursor(subs_q.cursor())
helpers.createResponse(self, 'dashboard_cls.html',
{'checklists': checklists,
'cursor_cl': checklist_q.cursor(),
'subs_by_cl': subs_by_cl,
'subs': subs,
'cursor_sub': subs_q.cursor(),
'more_subs': subs_q.count(1) == 1,
'more_cls': checklist_q.count(1) == 1,
})
def get(self, **args):
cl = Checklist.get(Key.from_path("Checklist", long(args['id'])))
if not cl or cl.deleted:
helpers.createResponse(self, 'message_not_exist.html')
return
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False): return
item_q = cl.item_set.filter("deleted ==", False).order("creation_time")
cursor = self.request.get('cursor_item')
if cursor:
item_q = item_q.with_cursor(cursor)
items = item_q.fetch(20)
subs = []
for sub in cl.subscription_set:
subs.append(sub)
cursor_item = item_q.cursor()
item_q = item_q.with_cursor(cursor_item)
helpers.createResponse(self, 'dashboard_items.html',
{'items': items,
'cl': cl,
'cursor_item': cursor_item,
'more_items': item_q.count(1) == 1,
'subs': subs,
})
def get(self):
user = users.get_current_user()
checklists, user_url, cl_cursor, item_cursors, items = None, None, None, None, None
if not user:
user_url = users.create_login_url(self.request.uri)
else:
user_url = users.create_logout_url("/")
q = Checklist.all().filter("user ="******"title")
checklists = q.fetch(5)
item_queries = [ cl.listitem_set for cl in checklists ]
items = [ q.fetch(10) for q in item_queries ]
cl_cursor = q.cursor()
item_cursors = [ q.cursor() for q in item_queries ]
template = jinja_environment.get_template('templates/index.html')
template_values = {
'checklists': checklists,
'cl_cursor': cl_cursor,
'items': items,
'item_cursors': item_cursors,
'user': user,
'user_url': user_url
}
self.response.out.write(template.render(template_values))
def get(self, **args):
cl = Checklist.get(Key.from_path("Checklist", long(args['id'])))
if not cl or cl.deleted:
helpers.createResponse(self, 'message_not_exist.html')
return
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False): return
item_q = cl.item_set.filter("deleted ==", False).order("creation_time")
cursor = self.request.get('cursor')
if cursor:
item_q = item_q.with_cursor(cursor)
items = item_q.fetch(20)
user = users.get_current_user()
subscribed = False
for sub in Subscription.all().filter("user ==", user).filter("deleted ==", False):
if sub.source.key() == cl.key():
subscribed = True
break
helpers.createResponse(self, 'dashboard_subscribe.html',
{'items': items,
'cl': cl,
'cursor_item': item_q.cursor(),
'subscribed': subscribed,
},
)
def get(self):
user = users.get_current_user()
checklist_q = Checklist.all().filter("user ==", user).filter("deleted ==", False).order("title");
cursor = self.request.get('cursor_cl')
if cursor:
checklist_q = checklist_q.with_cursor(cursor)
checklists = checklist_q.fetch(20)
cursor_cl = checklist_q.cursor()
checklist_q = checklist_q.with_cursor(cursor_cl)
subs_q = Subscription.all().filter("user ==", user).filter("deleted ==", False);
cursor = self.request.get('cursor_sub')
if cursor:
subs_q = subs_q.with_cursor(cursor)
subs = subs_q.fetch(20)
cursor_sub = subs_q.cursor()
subs_q = subs_q.with_cursor(cursor_sub)
helpers.createResponse(self, 'dashboard_cls.html',
{'checklists': checklists,
'cursor_cl': cursor_cl,
'subs': subs,
'cursor_sub': cursor_sub,
'more_subs': subs_q.count(1) == 1,
'more_cls': checklist_q.count(1) == 1,
})
def get(self):
for item in Item.all().filter("deleted ==", True):
if item.item_set.count(1) == 0:
item.delete()
for cl in Checklist.all().filter("deleted ==", True):
if cl.checklist_set.count(1) == 0:
cl.delete()
def post(self):
cl = Checklist.get(Key(self.request.get('cl')))
if helpers.checkPermission(users.User(self.request.get('email')), cl=cl):
difficulty_sum, weighted_progress = 0, 0
for item in cl.item_set:
difficulty_sum += item.difficulty
weighted_progress += item.difficulty*item.progress
cl.progress = weighted_progress/difficulty_sum
cl.put()
def post(self):
cl = Checklist.get(Key((self.request.get('key'))))
if not helpers.checkPermissionAndRespond(self, cl=cl): return
for item in cl.item_set:
item.deleted = True
item.put()
cl.deleted = True
cl.put()
self.response.write('ok')
def post(self):
checklist = Checklist.get(Key(self.request.get('cl_key')))
if not helpers.checkPermissionAndRespond(self, cl=checklist): return
item = Item(
title=self.request.get('title'),
checklist=checklist,
deleted=False)
item.put()
helpers.createResponse(self, 'new_item.html', {'item': item})
def get(self):
user = users.get_current_user()
checklist_q = Checklist.all().filter("user ="******"deleted ==", False).order("title")
cursor = self.request.get('cursor')
if cursor:
checklist_q = checklist_q.with_cursor(cursor)
checklists = checklist_q.fetch(7)
helpers.createResponse(self, 'list_cls.html',
{'checklists': checklists,
'checklists_cursor': checklist_q.cursor()})
def post(self):
cl = Checklist.get(Key(self.request.get("cl_key")))
for sub in cl.subscription_set:
total, finished = 0, 0
for subItem in sub.subscribeditem_set:
total += 1
if subItem.finished:
finished += 1
if sub.progress != finished * 100 / total:
sub.progress = finished * 100 / total
sub.put()
def new_checklist():
name = request.form.get('name', None)
template_pk = request.form.get('template', None)
if not all([name, template_pk]):
return abort(400)
try:
template = ChecklistTemplate.objects.get(pk=template_pk)
except ChecklistTemplate.DoesNotExist:
return abort(404)
checklist = Checklist.from_template(template, name, g.user.name)
checklist.save()
return redirect(checklist.url)
def post(self):
checklist = Checklist.get(Key(self.request.get("cl_key")))
if not helpers.checkPermissionAndRespond(self, cl=checklist):
return
item = Item(title=self.request.get("title"), checklist=checklist, deleted=False)
item.put()
taskqueue.add(url="/taskqueue/updatesubscription", params={"key": item.key()})
taskqueue.add(url="/taskqueue/updateprogress", params={"cl_key": item.checklist.key()})
helpers.createResponse(self, "new_item.html", {"item": item})
def post(self):
checklist = Checklist.get(Key(self.request.get("key")))
if helpers.checkPermissionAndRespond(self, cl=checklist):
checklist.title = self.request.get('title')
checklist.public = bool(self.request.get('public'))
checklist.description = self.request.get('description')
checklist.put()
for copy in checklist.checklist_set:
helpers.pushNotification(checklist, "edited the checklist", checklist.user, copy.user , True)
self.redirect('/cl/' + str(checklist.key().id()))
def post(self):
cl = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False):
return
user = users.get_current_user()
for checklist in Checklist.all().filter("user ==", user):
if checklist.source.key() == cl.key():
helpers.createResponse(self, 'message_already_subscribed.html',
{'old_checklist': cl, 'my_checklist': checklist})
return
new_cl = Checklist(
title = cl.title,
description = cl.description,
user = user,
progress = cl.progress,
public = cl.public,
source = cl,
deleted = cl.deleted,
)
new_cl.put()
for item in cl.item_set:
new_item = Item(
title = item.title,
description = item.description,
progress = item.progress,
progress_description = item.progress_description,
difficulty = item.difficulty,
original = item,
checklist = new_cl,
deleted = item.deleted,
)
new_item.put()
helpers.pushNotification(cl, "subscribed to your Checklist", user, cl.user, True)
helpers.createResponse(self, 'message_subscribed.html')
def post(self):
value = self.request.get("value")
key, tmp, field = self.request.get("id").rpartition("_")
checklist = Checklist.get(Key(key))
if helpers.checkPermissionAndRespond(self, cl=checklist):
if field == 'title':
checklist.title = value
elif field == 'public':
checklist.public = value.lower() not in ['no', 'false']
elif field == 'description':
checklist.description = value
checklist.put()
self.response.write(value)
def post(self):
cl = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
if not helpers.checkPermissionAndRespond(self, cl=cl): return
for item in cl.item_set:
item.deleted = True
item.put()
cl.deleted = True
cl.put()
for copy in cl.checklist_set:
helpers.pushNotification(cl, "deleted the checklist", cl.user, copy.user , True)
helpers.createResponse(self, 'message_deleted.html')
def get(self):
user = users.get_current_user()
if user:
query = self.request.query.split('&')
cl_key, cursor = query[0], query[1]
cl = Checklist.get(db.Key(cl_key))
query = cl.listitem_set.with_cursor(cursor)
items = query.fetch(10)
# self.response.out.write("<tr></tr>")
template = jinja_environment.get_template('templates/more_items.html')
template_values = {
'items': items,
}
self.response.out.write(template.render(template_values))
def get_home_checklists():
"""
获取首页的清单列表
:return:
"""
s = g.mysql_session
raw_scene_id = KvConfig.get_value_of_key(
s, KvConfig.KEY_HOME_CHECKLIST_SCENE_ID)
checklists_res = []
if raw_scene_id is None:
return succeed(data=checklists_res)
checklists = Checklist.get_list_by_scene(s, int(raw_scene_id))
checklist_ids = [x.id for x in checklists]
# 检索自己是否打卡的相关信息
my_reviews_id_map = {}
checklist_count_map = {}
user = None
if g.user:
user = g.user
my_reviews = ChecklistReview.get_today_list_of_user(s, user.id)
my_reviews_id_map = {x.checklist_id: x for x in my_reviews}
checklist_count_map = ChecklistReview.get_reviews_count_of_n_days_before(
s, user.id, checklist_ids)
for checklist in checklists:
single_checklist_info = dict(
id=checklist.id,
description=checklist.description,
checked_count=checklist_count_map.get(checklist.id, 0),
checked=0,
)
if my_reviews_id_map.get(checklist.id):
single_checklist_info["checked"] = 1
review = my_reviews_id_map.get(checklist.id)
last_review = dict(description=review.detail, )
last_review["author_nickname"] = user.nickname
single_checklist_info["last_review"] = last_review
checklists_res.append(single_checklist_info)
return succeed(data=checklists_res)
def get(self, **args):
cl = Checklist.get(Key.from_path("Checklist", long(args['id'])))
if not cl or cl.deleted:
helpers.createResponse(self, 'message_not_exist.html')
return
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False): return
item_q = cl.item_set.filter("deleted ==", False).order("title")
cursor = self.request.get('cursor')
if cursor:
item_q = item_q.with_cursor(cursor)
items = item_q.fetch(7)
helpers.createResponse(self, 'list_items.html',
{'items': items,
'checklist': cl,
'item_cursor': item_q.cursor()})
def post(self):
checklist = Checklist.get(self.request.get('checklist'))
if not helpers.checkPermissionAndRespond(self, cl=checklist): return
if not self.addable(checklist):
helpers.createResponse(self, 'message_can_not_create_item.html')
return
item = Item(
title=self.request.get('title'),
difficulty=int(self.request.get('difficulty')),
progress=0,
checklist=checklist,
deleted=False)
if self.request.get('description') != '':
item.description=self.request.get('description')
item.put()
self.redirect("/cl/" + str(checklist.key().id()))
def add_review():
json_dict = g.json_dict
s = g.mysql_session
user = g.user
checklist = Checklist.get_by_id(s, json_dict["checklist_id"])
is_new, review = ChecklistReview.add_or_update(s, user.id, checklist.id,
json_dict.get("mood", "打卡"))
s.commit()
if is_new: # 下面的更新存在并发问题
checklist.checked_count += 1
checklist.last_review_id = review.id
return succeed(data=dict(
checklist=dict(
id=checklist.id,
checked_count=checklist.checked_count,
),
is_new=(1 if is_new else 0),
review_id=review.id,
mood=review.detail,
))
def post(self):
user = users.get_current_user()
if user:
checklist = Checklist.get(self.request.get('checklist_key'))
listitem = ListItem(
title=self.request.get('title'),
assigner=user,
assignees=[user],
priority=int(self.request.get('priority')),
finished=bool(self.request.get('finished')),
checklist=checklist)
if self.request.get('link') != '':
listitem.link = self.request.get('link')
if self.request.get('deadline') != '':
# TODO: replace this with deadline
listitem.deadline=datetime.now()
if self.request.get('details') != '':
listitem.details=self.request.get('detail')
listitem.put()
self.redirect('/')
def post(self):
cl = Checklist.get(Key.from_path('Checklist', long(self.request.get('cl_id'))))
subscribe = self.request.get('subscribe')
if not helpers.checkPermissionAndRespond(self, cl=cl, edit=False):
return
user = users.get_current_user()
if subscribe == 'false':
for sub in Subscription.all().filter("user ==", user).filter("deleted ==", False):
if sub.source.key() == cl.key():
for subItem in sub.subscribeditem_set:
subItem.delete()
sub.delete()
cl.subscribers = cl.subscribers - 1
self.response.write("unsubscribed")
else:
sub = Subscription(
user=user,
source=cl,
deleted=False,
)
sub.put()
for item in cl.item_set.filter("deleted ==", False):
subItem = SubscribedItem(
subscription=sub,
original=item,
finished=False,
deleted=False,
)
subItem.put()
cl.subscribers = cl.subscribers + 1
self.response.write("subscribed")
cl.put()
def fetch_all():
"""
根据传入的 last_review_id 进行抽取，固定每次抽取 fetch_size 个
:return:
"""
last_id = request.args.get("last_review_id", REVIEW_ID_LIMITATION)
fetch_size = 10
s = g.mysql_session
reviews = ChecklistReview.get_reviews_ref_last_review_id(
s, last_id, fetch_size)
has_more_reviews = fetch_size == len(reviews)
# 发布阅评的用户信息
user_ids = [x.user_id for x in reviews]
users = User.get_by_id_list(s, user_ids)
users_id_map = {x.id: x for x in users}
# 每个阅评对应的检查项
checklist_ids = [x.checklist_id for x in reviews]
checklists = Checklist.get_by_id_list(s, checklist_ids)
checklists_id_map = {x.id: x for x in checklists}
# 点赞
review_star_map = {}
if g.user:
review_ids = [x.id for x in reviews]
review_stars = ChecklistReviewStar.get_reviews_star_of_user(
s, g.user.id, review_ids)
review_star_map = {x.review_id: x for x in review_stars}
reviews_json = []
for review in reviews:
review_json = dict(
review_id=review.id,
review_mood=review.detail,
star_count=review.star_count,
created_at=review.created_at.strftime("%Y-%m-%d %H:%M:%S"),
has_stared=0,
)
# 组装用户信息，如果不存在用户信息，说明数据不完整，不做记录
review_author = users_id_map.get(review.user_id)
if review_author is None:
continue
review_json["author"] = review_author.get_base_info()
# 组装检查项信息
checklist = checklists_id_map.get(review.checklist_id)
if checklist is None:
continue
review_json["checklist"] = dict(
id=checklist.id,
description=checklist.description,
)
# 拼点赞信息
review_star = review_star_map.get(review.id)
if review_star:
review_json["has_stared"] = 1
reviews_json.append(review_json)
last_review_id = reviews[-1].id if reviews else -1
return succeed(data=dict(
reviews=reviews_json,
last_review_id=last_review_id,
has_more_reviews=(1 if has_more_reviews else 0),
))
def checklists_reset_checked_count():
scene_id = 1
with get_session() as s:
Checklist.reset_all_checked_count(s, scene_id)
