def create(request):
user = users.get_current_user()
if not user:
HttpResponseRedirect('/reader/')
username = request.POST["username"]
if not re.match(r"^\w{4,16}$", username):
return index(
request,
"Username can contain only letters and digits, 4-16 characters long"
)
r = Reader.byCurrentUser()
if not r:
r = Reader()
r.name = request.POST["name"]
r.username = username
r.email = user.email()
r.id = user.user_id()
r.put()
return HttpResponseRedirect('/reader')
def post(self):
if CONF.get("installed", True) != False:
return {'err': 'installed', 'msg': _(u'不可重复执行安装操作')}
code = self.get_argument("code", "").strip()
email = self.get_argument("email", "").strip().lower()
title = self.get_argument("title", "").strip()
invite = self.get_argument("invite", "").strip()
username = self.get_argument("username", "").strip().lower()
password = self.get_argument("password", "").strip()
if not username or not password or not email or not title:
return {'err': 'params.invalid', 'msg': _(u'填写的内容有误')}
if not re.match(RE_EMAIL, email):
return {'err': 'params.email.invalid', 'msg': _(u'Email无效')}
if len(username) < 5 or len(username) > 20 or not re.match(
RE_USERNAME, username):
return {'err': 'params.username.invalid', 'msg': _(u'用户名无效')}
if len(password) < 8 or len(password) > 20 or not re.match(
RE_PASSWORD, password):
return {'err': 'params.password.invalid', 'msg': _(u'密码无效')}
# 避免重复创建
user = self.session.query(Reader).filter(
Reader.username == username).first()
if not user:
user = Reader()
user.username = username
user.name = username
user.email = email
user.avatar = "https://www.gravatar.com/avatar/" + hashlib.md5(
email).hexdigest()
user.create_time = datetime.datetime.now()
user.update_time = datetime.datetime.now()
user.access_time = datetime.datetime.now()
user.active = True
user.admin = True
user.extra = {"kindle_email": ""}
user.set_secure_password(password)
try:
user.save()
except:
import traceback
logging.error(traceback.format_exc())
return {'err': 'db.error', 'msg': _(u'系统异常，请重试或更换注册信息')}
args = loader.SettingsLoader()
args.clear()
import uuid
# set a random secret
args['cookie_secret'] = u"%s" % uuid.uuid1()
args['site_title'] = title
if invite == "true":
args['INVITE_MODE'] = True
args['INVITE_CODE'] = code
else:
args['INVITE_MODE'] = False
return self.save_extra_settings(args)
def register():
body = request.get_json()
hashed_password = generate_password_hash(body["password"], method="sha256")
new_user = Reader(email=body['email'],
password=hashed_password,
is_active=True,
username=body["username"])
Reader.create(new_user)
return jsonify({'message': 'registered successfully'}), 200
def markUnread(article_id):
'''Logic to atomically mark an article as being unread by the logged in user'''
#TODO: test it
new_reader = Reader(user_id=current_user.id)
#atomically add current user to readers of given article
number_of_items_affected = Article.objects(id=article_id).update_one(
add_to_set__readers=new_reader)
if number_of_items_affected is 1:
return jsonify(dict(status='Success'))
else:
return jsonify(dict(\
status = 'Error'\
, message = 'No articles matched the given id'\
))
def auto_login(self):
auto = int(self.settings.get('auto_login', 0))
if not auto: return False
logging.info("Auto login as user %s" % auto)
self.set_secure_cookie("user_id", str(auto))
user = self.session.query(Reader).get(auto)
if not user:
logging.info("Init default auto login user")
user = Reader(id=auto)
user.init_default_user()
user.save()
self.add_msg("success", _("自动登录成功。"))
return True
def export(request):
reader = Reader().byCurrentUser()
collection = ReaderBook.finishedBooks(reader)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="somefilename.csv"'
writer = csv.writer(response)
writer.writerow(['Title', 'ISBN', 'My Rating', 'Date Read', 'Date Added'])
for c in collection:
title = c.book.title.replace('""', '')
writer.writerow(
[title, c.book.isbn, c.rating, c.finishedDate, c.created])
return response
def index(request):
reader = Reader().byCurrentUser()
fromDate = getPastDate(1)
finished = ReaderBook.finishedBooks(reader, fromDate)
# 12 months where each is a list to a book
months = [[] for i in range(12)]
for b in finished:
if b.finishedDate:
months[b.finishedDate.month - 1].append(b.book.title)
tv = {}
tv["months"] = months
return render(tv)
def index(request, state=None, page=1):
reader = Reader().byCurrentUser()
user = users.get_current_user()
page = int(page)
template_values = {}
if state:
template_values["currentState"] = state
else:
template_values["currentState"] = ""
if user: template_values["isLoggedIn"] = True
else: template_values["isLoggedIn"] = False
if not reader:
template_values["loginUrl"] = users.create_login_url('/reader')
else:
template_values["hasReader"] = True
template_values["books"] = []
template_values["toReadCount"] = reader.toReadCount
template_values["inProgressCount"] = reader.inProgressCount
template_values["finishedCount"] = reader.finishedCount
template_values["totalCount"] = reader.totalCount
template_values["showRatings"] = True
# paging stuff
paging.preparePagingTemplateForBookcase(template_values, reader, state,
page)
# end paging stuff
if state == "unrated":
collection = ReaderBook.byReaderUnrated(reader, page - 1)
else:
collection = ReaderBook.byReaderAndState(reader, state, page - 1)
for readerBook in collection:
template_values["books"].append(
mapping.toReaderBookTemplate(readerBook.book, readerBook))
template_values["navRoot"] = "/bookcase"
template_values["viewtype"] = "searchresult.html"
return render(template_values)
def index(request):
reader = Reader().byCurrentUser()
user = users.get_current_user()
template_values = {}
if user: template_values["isLoggedIn"] = True
else: template_values["isLoggedIn"] = False
if not reader:
template_values["loginUrl"] = users.create_login_url('/reader')
addedBooks = BookList.getUnread()
finishedBooks = BookList.getFinished()
inprogressBooks = BookList.getInProgress()
template_values["addedBooks"] = []
template_values["finishedBooks"] = []
template_values["inprogressBooks"] = []
def appendBooks(bookList, viewList):
if bookList is None:
bookList = BookList()
if bookList.list is None:
bookList.list = ()
for key in bookList.list[0:5]:
bookKey = db.Key(key)
if bookKey.app() == "trackmybooks":
bookKey = db.Key.from_path(*bookKey.to_path())
book = Book.get(bookKey)
if book: viewList.append(mapping.toReaderBookTemplate(book, None))
appendBooks(addedBooks, template_values["addedBooks"])
appendBooks(finishedBooks, template_values["finishedBooks"])
appendBooks(inprogressBooks, template_values["inprogressBooks"])
t = get_template('index.html')
html = t.render(Context(template_values))
return HttpResponse(html)
def post(self):
email = self.get_argument("email", "").strip()
nickname = self.get_argument("nickname", "").strip()
username = self.get_argument("username", "").strip().lower()
password = self.get_argument("password", "").strip()
if not nickname or not username or not password:
return {'err': 'params.invalid', 'msg': _(u'用户名或密码无效')}
if not re.match(RE_EMAIL, email):
return {'err': 'params.email.invalid', 'msg': _(u'Email无效')}
if len(username) < 5 or len(username) > 20 or not re.match(
RE_USERNAME, username):
return {'err': 'params.username.invalid', 'msg': _(u'用户名无效')}
if len(password) < 8 or len(password) > 20 or not re.match(
RE_PASSWORD, password):
return {'err': 'params.password.invalid', 'msg': _(u'密码无效')}
user = self.session.query(Reader).filter(
Reader.username == username).first()
if user:
return {'err': 'params.username.exist', 'msg': _(u'用户名已被使用')}
user = Reader()
user.username = username
user.name = nickname
user.email = email
user.avatar = "https://www.gravatar.com/avatar/" + hashlib.md5(
email).hexdigest()
user.create_time = datetime.datetime.now()
user.update_time = datetime.datetime.now()
user.access_time = datetime.datetime.now()
user.active = False
user.extra = {"kindle_email": ""}
user.set_secure_password(password)
try:
user.save()
except:
import traceback
logging.error(traceback.format_exc())
return {'err': 'db.error', 'msg': _(u'系统异常，请重试或更换注册信息')}
self.send_active_email(user)
return {'err': 'ok'}
def layout(request):
# get all the books within x amount of time layed out by date
# go by each day from the earliest day
# output day and the book that is being read on that day
# and continue doing that until all the books have been output
reader = Reader().byCurrentUser()
fromDate = getPastDate(2)
finished = ReaderBook.finishedBooks(reader, fromDate)
currentDate = fromDate
byDate = {}
while currentDate <= datetime.date.today() + datetime.timedelta(days=1):
list = matchedBookByDate(currentDate, finished)
byDate[currentDate] = []
for b in list:
byDate[currentDate].append(b.book.title)
currentDate = currentDate + datetime.timedelta(days=1)
return render_to_response('layout.html',
{"data": sorted(byDate.iteritems())})
def index(request, error=None):
user = users.get_current_user()
loginUrl = users.create_login_url('/reader')
if not user:
return HttpResponseRedirect(loginUrl)
r = Reader.byCurrentUser()
if not r:
r = Reader()
template_values = {
"isLoggedIn": True,
"isNew": True,
"name": "",
"username": user.nickname(),
"email": user.email()
}
else:
template_values = {
"isLoggedIn": True,
"isNew": False,
"name": r.name,
"username": r.username,
"email": r.email
}
template_values["logoutUrl"] = users.create_logout_url("/")
if error:
template_values["errorMsg"] = error
html = render('reader.html', template_values)
return HttpResponse(html)
def subscribe(rss_url):
'''Logic to add a given rss feed to the db, if required, and subscribe the current user to this feed'''
try:
feed = Feed.get_or_construct(rss_url)
except NotAFeed:
return jsonify(
dict(status='Error',
message='The given url is not an rss feed url'))
new_subscription = Subscription(feed_id=feed.id)
#atomically add new feed subscription to current user
number_of_items_affected = User.objects(id=current_user.id).update_one(
add_to_set__subscriptions=new_subscription)
new_reader = Reader(user_id=current_user.id)
#add current user to readers of all articles in subscribed feed, currently cannot be chained into one statement
for article in Article.objects(
feed_id=feed.id).order_by("-time_stamp").limit(10):
article.update(add_to_set__readers=new_reader)
if number_of_items_affected is 1:
return jsonify(dict(status='Success'))
else:
return jsonify(dict(\
status = 'Error'\
, message = 'Unable to subscribe'\
))
# commiting tests
db.session.add(book1)
db.session.add(book2)
db.session.commit()
# show one of the tests
print(book1,'\n')
# show the same test but in json format
print(book1.json())
print('='*140,'\n')
# creating and commiting the reviewer
reader = Reader(name ='Vítor Otto',
age = '18',
profession = 'Estudante',
fav_book = book1)
reader2 = Reader(name ='Carlos',
age = '20',
profession = 'Desempregado')
db.session.add(reader)
db.session.add(reader2)
db.session.commit()
print(reader,'\n')
print(reader2,'\n')
print(reader.json())
