def post(self):
email = self.request.get('email')
error = check_email_valid(email)
if not error and Guest.query(Guest.email == email).get():
error = u"Данный Email уже существует"
if error:
invite = Invite.query(Invite.url == self.request.path[1:]).get()
template_values = {
'error': error,
'title': invite.title,
'url': invite.url,
}
template = JINJA_ENVIRONMENT.get_template('invite.html')
self.response.write(template.render(template_values))
return
path = self.request.get('url')
invite = Invite.query(Invite.url == path).get()
if invite.count == invite.users_count:
self.redirect('/')
return
invite.users_count += 1
invite.put()
token = hashlib.md5(u'%s-%s' % (datetime.now(), email)).hexdigest()
guest = Guest(email=email,
token=token,
date=datetime.now(),
invite=invite)
guest.put()
self.response.set_cookie('token', token, max_age=3600)
template = JINJA_ENVIRONMENT.get_template('sign.html')
self.response.write(template.render())
def post(self, name=None):
user = users.get_current_user()
if user and (user.email() in ACTIVE_USER_EMAILS or users.is_current_user_admin()):
if name is None:
# Create New Reminder
title = self.request.get("title")
if title == None or title == "":
self.response.write("Title cannot be empty or None")
return
# TODO: allow selective reminders
existing_reminder = Reminders.get_by_key_name(title)
if(existing_reminder == None):
reminder = Reminders(key_name=title)
reminder.description = self.request.get("description")
reminder.put()
self.redirect("/reminders/" + title)
else:
self.response.write("Key Already Exists")
else:
# name is available, individual reminder
reminder = Reminders.get_by_key_name(name)
if(reminder == None):
template = JINJA_ENVIRONMENT.get_template('404.html')
self.response.write(template.render({}))
else:
# update the reminder
if(self.request.get("do") == "Mark Completed"):
# complete the reminder
reminder.lastdismissed = datetime.datetime.now()
reminder.lastupdated = datetime.datetime.now()
reminder.snooze = None
reminder.save()
reminderhistory = ReminderHistory(reminder=reminder)
reminderhistory.remarks = self.request.get("remarks")
reminderhistory.updatedby = user
reminderhistory.update = ReminderHistory.UPDATE_DISMISS
reminderhistory.put()
self.redirect(self.request.uri)
elif(self.request.get("do") == "Snooze"):
# update the reminder
reminder.lastupdated = datetime.datetime.now()
reminder.snooze = int(self.request.get("snooze"))
reminder.save()
reminderhistory = ReminderHistory(reminder=reminder)
reminderhistory.remarks = self.request.get("remarks")
reminderhistory.updatedby = user
reminderhistory.update = ReminderHistory.UPDATE_SNOOZE
reminderhistory.put()
self.redirect(self.request.uri)
else:
template = JINJA_ENVIRONMENT.get_template('error.html')
self.response.write(template.render({}))
elif (user):
template_values = {'logout_url': users.create_logout_url("/")}
template = JINJA_ENVIRONMENT.get_template('403.html')
self.response.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
token = self.request.cookies.get('token')
if token:
template = JINJA_ENVIRONMENT.get_template('sign.html')
self.response.write(template.render())
return
admin = users.is_current_user_admin()
template_values = {
'admin': admin,
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def get(self, format):
current_user = users.get_current_user();
if not current_user:
self.redirect("/")
return
user = models.User.get_user(current_user.user_id())
url = users.create_logout_url(self.request.uri)
template_values = {'user' : users.get_current_user(), 'url' : url}
streams = models.TrendSetter.topTrending()
template_values['user_streams'] = streams
r = lambda: random.randint(0,255)
# ["83BAE8", "E3DB18", "057351", "8F354D", "941F23", "1C6D76"]
template_values['random_colors'] = [('%02X%02XF0' % (r(),r())) for i in xrange(0,30)]
job = models.Jobs.gql("WHERE user = :1 and job_type = :2", user, 'trends').get()
if job:
template_values['checked_options'] = {job.duration : 'checked'}
else:
template_values['checked_options'] = {'noreport' : 'checked'}
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
# may be send latest
self.response.out.write(json.dumps({"status" : "OK", "result" : streams }))
return
else:
template = JINJA_ENVIRONMENT.get_template('templates/trending.html')
self.response.write(template.render(template_values))
def get(self):
domains_dict = get_domain_dict(Guest.query())
template_values = {
'domains_dict': domains_dict,
}
template = JINJA_ENVIRONMENT.get_template('emails.html')
self.response.write(template.render(template_values))
def get(self, format):
if not users.get_current_user():
self.redirect("/")
return
else:
stream_id = self.request.get("id")
if stream_id:
stream = models.Stream.get_by_id(long(stream_id))
if not stream:
self.response.out.write(json.dumps({"status" : "ERROR", "reason" : "No Stream Found" }))
url = users.create_logout_url(self.request.uri)
template_values = {
'user' : users.get_current_user(),
'url' : url,
'stream_id' : stream_id
}
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
self.response.out.write(json.dumps({"status" : "OK", "result" : photos }))
else:
template = JINJA_ENVIRONMENT.get_template('templates/geo_view.html')
self.response.write(template.render(template_values))
else:
self.response.out.write(json.dumps({"status" : "ERROR", "reason" : "No Stream Found" }))
def get(self):
user = users.get_current_user()
if user:
# Filter by the google appengine user id property.
active_user = User.query(User.google_id == user.user_id()).fetch(1)
if not active_user:
# If we couldn't find a user it means that is the first time it uses the application.
# We just need to create a new entity with the get_current_user() information.
active_user = User(email=user.email(), username=user.nickname(), google_id=user.user_id())
active_user.put()
logging.info("New user created. Email address is: %s", active_user.email)
else:
active_user = active_user[0]
token = channel.create_channel(str(active_user.key.id()))
memcache.add(key=str(active_user.key.id()), value=token)
template_vars = {
'user': active_user,
'token': token,
'logout_url': users.create_logout_url('/welcome'),
'boards': Board.query().order(Board.created_at)
}
template = JINJA_ENVIRONMENT.get_template('root.html')
self.response.write(template.render(template_vars))
else:
self.redirect('/welcome')
def get(self):
user = users.get_current_user()
if not user:
self.redirect(self.uri_for('login', dest=self.uri_for('newGame')))
else:
template = JINJA_ENVIRONMENT.get_template('newGame.html')
context = {'user': user}
self.response.write(template.render(context))
def get(self):
one_day_ago = datetime.today() - timedelta(1)
data = {
'image': GetImages().select_by_date(one_day_ago, '<='),
'dt': one_day_ago
}
template = JINJA_ENVIRONMENT.get_template('template/instagram.html')
self.response.write(template.render(data))
def get(self):
user = users.get_current_user()
if not user:
template = JINJA_ENVIRONMENT.get_template('welcome.html')
self.response.write(template.render(login_url=users.create_login_url('/')))
else:
self.redirect('/')
def get(self):
if not users.is_current_user_admin():
self.error(404)
self.response.write("<html><head><title>404 Not Found</title></head><body><h1>"
"404 Not Found</h1>The resource could not be found.<br /><br /></body></html>")
return
template = JINJA_ENVIRONMENT.get_template('create_invite.html')
self.response.write(template.render())
def get(self, format):
if not users.get_current_user():
self.redirect("/")
return
else:
url = users.create_logout_url(self.request.uri)
template = JINJA_ENVIRONMENT.get_template('templates/create.html')
template_values = {'user' : users.get_current_user(), 'url' : url}
self.response.write(template.render(template_values))
def get(self):
context = {
'auth_url': OAUTH_AUTH_URL,
'client_id': OAUTH_CLIENT_ID,
'scope': ' '.join(OAUTH_SCOPE),
'redirect_uri': OAUTH_REDIRECT_URI,
'continue': self.request.get('continue', '/')
}
template = JINJA_ENVIRONMENT.get_template('oauth_login.html')
self.response.write(template.render(context))
def get(self):
template_values = {
'user': '******',
'greetings': 'greetings',
'guestbook_name': 'urllib.quote_plus(guestbook_name)',
'url': 'url',
'url_linktext': 'url_linktext',
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def sendMail(ids, mailType):
message = mail.EmailMessage(sender="*****@*****.**",
subject="Hi! from imgshare!")
template = JINJA_ENVIRONMENT.get_template('templates/newsletter.html')
for email in ids:
message.to = email
message.html = template.render(Mailer.trendingEmailTemplateValues())
message.send()
return
def get(self):
q = self.request.get('q',default_value='italian')
url = "http://www.vam.ac.uk/api/v2/shop-index/shop-item/?q=%s" % q
result = urlfetch.fetch(url)
if result.status_code == 200:
p = json.loads(result.content)
data = {
'image': p['data'],
}
template = JINJA_ENVIRONMENT.get_template('template/shopwall.html')
self.response.write(template.render(data))
def get(self):
user = users.get_current_user()
if user:
if(user.email() in ACTIVE_USER_EMAILS or users.is_current_user_admin()):
template_values = {
'page':{'title':"3 Idiots Flat"},
'user':user,
'active_tab':"home",
'logout_url': users.create_logout_url("/"),
}
template = JINJA_ENVIRONMENT.get_template('base.html')
self.response.write(template.render(template_values))
else:
template_values = {
'logout_url': users.create_logout_url("/")
}
template = JINJA_ENVIRONMENT.get_template('403.html')
self.response.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
if users.get_current_user():
# create new user if it doens't exist
models.User.create_new_user(users.get_current_user().email(),
users.get_current_user().user_id())
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
template = JINJA_ENVIRONMENT.get_template('templates/index.html')
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
template = JINJA_ENVIRONMENT.get_template('templates/login.html')
template_values = {
'url': url,
'url_linktext': url_linktext,
'user' : users.get_current_user()
}
self.response.write(template.render(template_values))
def get(self):
token = self.request.cookies.get('token')
if token:
template = JINJA_ENVIRONMENT.get_template('sign.html')
self.response.write(template.render())
return
path = self.request.path[1:]
invite = Invite.query(Invite.url == path).get()
if invite.count == invite.users_count:
self.redirect('/')
return
invite.views_count += 1
invite.put()
template_values = {
'title': invite.title,
'url': invite.url,
}
template = JINJA_ENVIRONMENT.get_template('invite.html')
self.response.write(template.render(template_values))
def send_game_invite(game, context=None):
html_template = JINJA_ENVIRONMENT.get_template('mail/gameInvite.html')
plain_template = JINJA_ENVIRONMENT.get_template('mail/gameInvite.txt')
invitee = game.player_X
invitor = game.player_O
context = context or {}
context.update({'name': invitee.nickname(),
'opponent_name': invitor.nickname(),
'game': game})
html = html_template.render(context)
plaintext = plain_template.render(context)
subject = 'Play Tic-Tac-Toe by email with ' + invitor.email()
headers = {GAME_KEY_HEADER: game.key.urlsafe()}
_send_to(invitee.email(),
invitee.nickname(),
subject,
plaintext,
html,
headers=headers)
def get(self, format):
user = models.User.get_user(users.get_current_user().user_id())
url = users.create_logout_url(self.request.uri)
template_values = {'user' : users.get_current_user(), 'url' : url}
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
# may be send latest
self.response.out.write(json.dumps({"status" : "OK", "result" : ['stream1', 'stream2'] }))
return
else:
template = JINJA_ENVIRONMENT.get_template('templates/social.html')
self.response.write(template.render(template_values))
def get(self, name=None):
user = users.get_current_user()
if user and (user.email() in ACTIVE_USER_EMAILS or users.is_current_user_admin()):
if name is None:
# generic reminders page - list all reminders
reminders = Reminders.all().fetch(50)
template_values = {
'page':{'title':"Reminders"},
'user':user,
'active_tab':"reminders",
'user_emails': ACTIVE_USER_EMAILS,
'users': ACTIVE_USERS,
'reminders':reminders
}
template = JINJA_ENVIRONMENT.get_template('reminders/index.html')
self.response.write(template.render(template_values))
pass
else:
# individual reminder
reminder = Reminders.get_or_insert(key_name=name)
template_values = {
'page':{'title':reminder.description},
'user':user,
'active_tab':"reminders",
'reminder':reminder
}
template = JINJA_ENVIRONMENT.get_template('reminders/reminder.html')
self.response.write(template.render(template_values))
elif (user):
template_values = {'logout_url': users.create_logout_url("/")}
template = JINJA_ENVIRONMENT.get_template('403.html')
self.response.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
def get(self):
if not users.is_current_user_admin():
self.error(404)
self.response.write("<html><head><title>404 Not Found</title></head><body><h1>"
"404 Not Found</h1>The resource could not be found.<br /><br /></body></html>")
return
sort_tag = self.request.get('sort')
invite_order = sort_tag_dict[sort_tag]
template_values = {
'invites': Invite.query().order(invite_order),
}
template = JINJA_ENVIRONMENT.get_template('invites_list.html')
self.response.write(template.render(template_values))
def get(self, format):
if not users.get_current_user():
self.redirect("/")
# stream = models.Stream.get_by_id(int(self.request.get("stream_id")))
# images = stream.get_images()
upload_url = blobstore.create_upload_url('/upload.html')
template = JINJA_ENVIRONMENT.get_template('templates/sample_uploader.html')
url = users.create_login_url(self.request.uri)
template_values = {
'url': url,
'user' : users.get_current_user(),
'upload_url' : upload_url
}
self.response.write(template.render(template_values))
def post(self):
current_user = users.get_current_user()
if not current_user:
self.redirect(self.uri_for('login', dest=self.uri_for('newGame')))
else:
invitee_email = self.request.get('invitee')
invitee_user = users.User(invitee_email)
# construct the game
new_game = game.Game(player_X=invitee_user, player_O=current_user)
new_game.put()
# send the invite
send_game_invite(new_game)
template = JINJA_ENVIRONMENT.get_template('inviteSent.html')
context = {'user':current_user,
'invitee': invitee_email }
self.response.write(template.render(context))
def get(self, format):
if not users.get_current_user():
self.redirect("/")
return
else:
stream_id = self.request.get("id")
if stream_id:
stream = models.Stream.get_by_id(long(stream_id))
if not stream:
self.response.out.write(json.dumps({"status" : "ERROR", "reason" : "No Stream Found" }))
get_more = self.request.get("get_more");
user = models.User.get_user(users.get_current_user().user_id())
if self.request.get("useCursor") == "false":
stream_photos = stream.get_images(limit=None, useCursor=False, user=user)
elif get_more:
stream_photos = stream.get_images(limit=3, useCursor=True, user=user)
else:
stream_photos = stream.get_images(limit=3, useCursor=True, user=user, resetCursor=True)
photos = []
for photo in stream_photos:
photos.append(photo.__dict__())
url = users.create_logout_url(self.request.uri)
stream.update_view_count()
template_values = {'user' : users.get_current_user(), 'url' : url}
template_values['photos'] = photos
template_values['stream'] = stream
template_values['upload_url'] = '/upload/' #blobstore.create_upload_url('/upload')
template_values['owner'] = stream.owner.google_id == user.google_id
template_values['subscribed'] = [True for st in models.Stream.get_all_subscribed_streams(user) if stream.key().id() == st['id']] != []
template_values['upload'] = self.request.get("upload",'')
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
self.response.out.write(json.dumps({"status" : "OK", "result" : photos }))
else:
template = JINJA_ENVIRONMENT.get_template('templates/view_stream_adv.html')
self.response.write(template.render(template_values))
else:
self.response.out.write(json.dumps({"status" : "ERROR", "reason" : "No Stream Found" }))
def get(self, format):
if not users.get_current_user():
self.redirect("/")
return
else:
user = models.User.get_user(users.get_current_user().user_id())
user_streams = {}
user_streams["owned"] = models.Stream.get_all_owned_streams(user)
user_streams["subscribed"] = models.Stream.get_all_subscribed_streams(user)
url = users.create_logout_url(self.request.uri)
template_values = {'user' : users.get_current_user(), 'url' : url}
template_values['user_streams'] = user_streams
r = lambda: random.randint(0,255)
#["83BAE8", "E3DB18", "057351", "8F354D", "941F23", "1C6D76"]
template_values['random_colors'] = [('%02X%02XF0' % (r(),r())) for i in xrange(0,30)]
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
return self.response.out.write(json.dumps({"status" : "OK", "result" : user_streams}))
else:
template = JINJA_ENVIRONMENT.get_template('templates/view.html')
self.response.write(template.render(template_values))
def get(self, format):
if not users.get_current_user():
self.redirect("/")
return
user = models.User.get_user(users.get_current_user().user_id())
url = users.create_logout_url(self.request.uri)
template_values = {'user' : users.get_current_user(), 'url' : url}
if not self.request.get('name'):
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
# may be send latest
self.response.out.write(json.dumps({"status" : "OK", "result" : [] }))
return
else:
template = JINJA_ENVIRONMENT.get_template('templates/search.html')
self.response.write(template.render(template_values))
return
# if q is present
streams = models.Search.find_by_keyword(self.request.get('name'));
self.response.write(json.dumps({"status" : "OK", "result" : streams}))
def post(self):
email = self.request.get('email')
pattern = re.compile("[^@]+@[^@]+\.[^@]+")
if not pattern.match(email):
self.redirect('/invite_view')
return
path = self.request.get('url')
invite = Invite.query(Invite.url == path).get()
if invite.count == invite.users_count:
self.redirect('/')
return
invite.users_count += 1
invite.put()
token = hashlib.md5(u'%s-%s' % (datetime.now(), email)).hexdigest()
guest = Guest(email=email,
token=token,
date=datetime.now(),
invite=invite)
guest.put()
self.response.set_cookie('token', token, max_age=3600)
template = JINJA_ENVIRONMENT.get_template('sign.html')
self.response.write(template.render())
def get(self, format):
if not users.get_current_user():
if format.find('json') > 0:
self.error(401)
else:
self.redirect("/")
return
else:
url = users.create_logout_url(self.request.uri)
template_values = {'user' : users.get_current_user(), 'url' : url}
user = models.User.get_user(users.get_current_user().user_id())
streams = {}
streams["owned"] = models.Stream.get_all_owned_streams(user)
streams["subscribed"] = models.Stream.get_all_subscribed_streams(user)
if format.find('json') > 0:
self.response.headers.add_header("Content-Type", "application/json")
self.response.write(json.dumps({"status" : "OK", "result" : streams}))
else:
template = JINJA_ENVIRONMENT.get_template('templates/manage.html')
template_values["streams"] = streams
#self.respose.set_status(200);
self.response.write(template.render(template_values))
def get(self):
template = JINJA_ENVIRONMENT.get_template('page.html')
self.response.write(template.render())
