def create_user(self, user_id):
myuser = MyUser(id=user_id, user_id=str(user_id))
myuser.user_name = ""
myuser.user_following = []
myuser.put()
return myuser
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
user = users.get_current_user()
myuser = None
#User logged in
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
template_values = {
'url': url,
'url_text': url_string,
'myuser': myuser
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(username=user.email(),
id=user.user_id(),
myAnagram=0,
myWordCount=0)
myuser.put()
ana = Anagram.query().fetch()
# c = Counter();
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'user': user,
'myuser': myuser,
'ana': ana
# ,
# 'counter': getAnaCount()
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
button = self.request.get("button")
user = users.get_current_user()
myuser = None
emptyList = []
if button == "Next":
username = self.request.get("username").strip().lower()
DB_user_key = ndb.Key('AllUsers', username)
DB_user = DB_user_key.get()
if DB_user == None:
myuser = MyUser(id=user.user_id(),
name="",
username=username,
profileDesc="",
tweetsList=emptyList,
fallowersList=emptyList,
fallowedList=emptyList,
tweet_count=len(emptyList))
myuser.put()
DB_user = AllUsers(id=username, userkey=user.user_id())
DB_user.put()
self.redirect('edit')
return
else:
#this username is taken
self.redirect('/firstLogin')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
myuser = None
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
else:
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'myuser': myuser,
'myuserAnagrams': len(myuser.userDictionary),
'fail': False
}
template = JINJA_ENVIRONMENT.get_template('add.html')
self.response.write(template.render(template_values))
def get(self):
url = ''
url_string = ''
myuser=''
user =''
welcome = 'Welcome back'
user= users.get_current_user()
if user:
template = JINJA_ENVIRONMENT.get_template('mainpage.html')
self.response.write(template.render())
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.email())
myuser = myuser_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.email())
myuser.email_address=user.email()
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
template_values = {
'url' : url,
'url_string' : url_string,
'user' : user,
'welcome' : welcome,
'myuser' : myuser
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url' : users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('GpuUserLogin.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
gpu_query = GpuModel().query().fetch()
template_values = {
'logout_url' : users.create_logout_url(self.request.uri),
'Gmodel' : gpu_query
}
template = JINJA_ENVIRONMENT.get_template('GpuFeature.html')
self.response.write(template.render(template_values))
def add_new_user(user):
my_user = MyUser(id=user.user_id())
add_root_directory(my_user)
# set current path on first login to root directory
my_user.current_directory = ndb.Key(Directory, my_user.key.id() + '/')
my_user.put()
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
query = Address.query()
data = query.fetch()
if user == None:
template_values = {
'login_url' : users.create_login_url(self.request.uri),
'addresses': data
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'addresses': data
}
template = JINJA_ENVIRONMENT.get_template('mainpage.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if my_user == None:
my_user = MyUser(id=user.user_id(),
name=user.email(),
anagram_count=0,
word_count=0)
my_user.put()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'user': user,
'query': Anagram_engine.query().fetch(),
'anagram_count': my_user.anagram_count,
'word_count': my_user.word_count,
}
template = JINJA_ENVIRONMENT.get_template('mainpage.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
#If user is not found navigate to guest page and stop processing
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainguest.html')
self.response.write(template.render(template_values))
return
#If user is found get the user and navigate to the main page
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'myuser': myuser,
'user': user
}
template = JINJA_ENVIRONMENT.get_template('edituser.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
#If user is not found navigate to guest page and stop processing
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainguest.html')
self.response.write(template.render(template_values))
return
#If user is found get the user and navigate to the main page
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
#Update user model with the users information
name = self.request.get('name')
# age = self.request.get('age')
if name:
myuser.name = name
myuser.put()
self.redirect('/')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.url)
}
template = JINJA_ENVIRONMENT.get_template('loginpage.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id(), num_words=0, unique=0)
myuser.put()
template_values = {
'logout_url': users.create_logout_url(self.request.url),
'user': user,
'allvalues': MyDictionary.query().fetch(),
'num_words': myuser.num_words,
'unique': myuser.unique
}
template = JINJA_ENVIRONMENT.get_template('homepage.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
name = self.request.get('name')
gpu_query = GPU().query(GPU.name == name).fetch()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = myuser(id=user.user_id())
myuser.put()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'gpu': gpu_query
}
template = JINJA_ENVIRONMENT.get_template('Editpage.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
all_gpu_names = ''
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id(), email_address=user.email())
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
all_gpu_names = GpuFeatures.query().fetch()
template_values = {
'url': url,
'url_string': url_string,
'all_gpu_names': all_gpu_names,
'user': user,
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get_current_user(self):
"""Return the current user if someone logged in or None otherwise"""
default_user = "******"
gUser = users.get_current_user()
if not gUser:
# return MyUser(key_name=default_user)
if "local_user" in self.session:
user_key = self.session["local_user"]
else:
return None
user = MyUser.get(db.Key(encoded=user_key))
else:
user = get_user(gUser.nickname().lower())
if user and not user.user:
user.user = gUser
user.put()
# if default user logged in but not registered - register him (me)
if not user and gUser.nickname().lower() == default_user:
user = MyUser(key_name=default_user)
user.user = gUser
user.roles = ["admin", "teacher"]
user.alias = "admin"
user.put()
# temporary:
# if gUser and gUser.nickname() == default_user:
# user.roles = ['admin','teacher']
return user
def get(self):
show_all_key = ''
if self.request.get('show_all_key'):
show_all_key = ndb.Key(urlsafe=self.request.get('show_all_key'))
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
post = ''
welcome = 'Welcome back'
myuser = None
posts = []
comment_dictonary = {}
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
post = BlobCollection.query().order(-BlobCollection.posted_date).fetch(limit=50)
if myuser == None:
welcome = 'Welcome to the Instagram'
myuser = MyUser(id=user.user_id())
myuser.name = user.email()
myuser.put()
key_list = []
if myuser:
for follo in myuser.following:
use = MyUser.query().filter(MyUser.name == follo)
use = use.fetch(10)
for ussss in use:
key_list.append(ussss.key)
# raise UserWarning(key_list)
for p in post:
if p.user_key == myuser.key or p.user_key in key_list:
posts.append(p)
for pst in posts:
comments = Comments.query().filter(Comments.post_key == pst.key).order(-Comments.posted_date)
comment_dictonary[pst.key] = comments
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
# raise UserWarning(posts)
template_values = {
'url' : url,
'show_all_key' : show_all_key,
'posts': posts,
'comment_dictonary': comment_dictonary,
'upload_url': blobstore.create_upload_url('/upload'),
'url_string' : url_string,
'user' : user,
'welcome' : welcome,
'myuser' : myuser
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
user = users.get_current_user()
presentfolder = self.request.get('presentfolder')
upload = self.get_uploads()[0]
blobinfo = blobstore.BlobInfo(upload.key())
file = blobinfo.filename
flag = 0
dir_key = ndb.Key('directory', presentfolder)
dir = dir_key.get()
if not dir:
dir = directory(id=presentfolder)
dir.file = file
dir.directoryName = presentfolder
dir.fileBool = True
dir.blobname = upload.key()
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if my_user == None:
my_user = MyUser(id=user.user_id())
my_user.username = user.user_id()
for x in my_user.directory:
if x.file == file:
flag = 1
if flag == 0:
my_user.directory.append(dir)
my_user.put()
self.redirect('/')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('login.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id(),
username=user.email(),
anaCount=0,
wordCount=0)
myuser.put()
anagrmEngine = model.query().fetch()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'user': user,
'anagrmEngine': anagrmEngine,
'anaCount': myuser.anaCount,
'wordCount': myuser.wordCount
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
#If user is not found navigate to guest page and stop processing
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri),
}
template = JINJA_ENVIRONMENT.get_template('viewcommentst.html')
self.response.write(template.render(template_values))
return
#If user is found get the user and navigate to the main page
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
key = self.request.GET['key']
post_key = ndb.Key('Post', int(key))
post = post_key.get()
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'myuser': myuser,
'get_serving_url': get_serving_url,
'i': post_key
}
template = JINJA_ENVIRONMENT.get_template('viewcomments.html')
self.response.write(template.render(template_values))
def add_new_user(user):
my_user = MyUser(id=user.user_id())
add_root_directory(my_user)
# set current path on first login to root directory
my_user.current_directory = ndb.Key(Directory, my_user.key.id() + '/')
my_user.put()
def post(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
user = users.get_current_user()
if user is None:
url = users.create_login_url(self.request.uri)
url_string = 'login'
welcome = 'Welcome to Anagram Engine'
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'welcome': welcome
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
else:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.email())
myuser = myuser_key.get()
if myuser is None:
welcome = 'Welcome back to the application'
myuser = MyUser(id=user.email(), emailAddress=user.email())
myuser.email_address = user.email()
myuser.put()
if self.request.get('button') == 'Search':
searchWord = self.request.get('input_text')
if searchWord.isalpha():
lex = Anagram.processWord(searchWord)
anagram_key = ndb.Key('Anagram', lex)
anagram = anagram_key.get()
if anagram:
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'myuser': myuser,
'anagrams': anagram.words
}
else:
template_values = {'error': 'No Anagrams Found'}
else:
template_values = {'error': 'Invalid Search'}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
# pull the current user from the Request
user = users.get_current_user()
ID =self.request.get("ID")
pID =self.request.get("pID")
vuser = ""
myuser = ""
post_obj = ""
# determine if we have a user logged in or not
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', ID)
myuser = myuser_key.get()
vuser_key = ndb.Key('MyUser', user.user_id())
vuser = vuser_key.get()
post_key = ndb.Key('Post', pID)
post_obj = post_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id = user.user_id())
myuser.email_address = user.email()
myuser.put()
if not vuser.username:
self.redirect('/')
else:
url = users.create_login_url(self.request.uri)
login_status = "You are not logged in."
url_string = 'login'
self.redirect('/')
template_values = {
'url' : url,
'url_string' : url_string,
'user' : user,
'myuser' : myuser,
'vuser' : vuser,
'post_obj' : post_obj
}
# pull the template file and ask jinja to render
# it with the given template values
template = JINJA_ENVIRONMENT.get_template('read_more_comments.html')
self.response.write(template.render(template_values))
def create_user(self, user_id, email_address):
myuser = MyUser(id=user_id,
user_id=str(user_id),
email_address=str(email_address))
myuser.user_name = ""
myuser.following = []
myuser.put()
return myuser
def get(self):
self.response.headers['Content-Type'] = 'text/html'
# URL that will contain a login or logout link
# and also a string to represent this
url = ''
url_string = ''
welcome = 'Welcome back'
datastore_message = "Below you will see the items that are currently stored in the datastore."
myev = None
# pull the current user from the Request
user = users.get_current_user()
# determine if we have a user logged in or not
if user:
url = users.create_logout_url(self.request.uri)
login_status = "You are logged in."
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
#myuser = MyUser(email_address = user.email())
myuser = myuser_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.user_id())
myuser.email_address = user.email()
myuser.put()
else:
url = users.create_login_url(self.request.uri)
login_status = "To Add a new EV, You need to login. Click on login above"
url_string = 'login'
# by providing self.request.uri we are asking to be redirected back
# to the URL of the page represented by this class.
query = MyEV.query()
r = list(query.fetch())
#print('data')
#print(r)
template_values = {
'url': url,
'url_string': url_string,
'login_status': login_status,
'datastore_message': datastore_message,
'user': user,
'welcome': welcome,
'myev': myev,
'list': r
}
# pull the template file and ask jinja to render
# it with the given template values
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
action = self.request.get('button')
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
file = self.request.get('StoreFile')
if action == 'Store':
openFile = open(file)
readLine = openFile.readline()
while readLine:
words = (readLine.strip('\n\r')).lower()
lexi_order = reduce(lambda x, y: x + y, sorted(words))
num_letters = len(words)
mydictionary_key = user.user_id() + lexi_order
mydictionary_list = ndb.Key(MyDictionary, mydictionary_key)
mydictionary_list_all = mydictionary_list.get()
if mydictionary_list_all == 'None':
display_all = MyDictionary(id=mydictionary_key,
lexi_order=lexi_order.lower(),
num_letters=num_letters,
count=1)
num_words = myuser.num_words + 1
unique = myuser.unique + 1
myuser = MyUser(id=user.user_id(),
num_words=num_words,
unique=unique)
myuser.put()
display_all.word.append(words)
display_all.put()
self.redirect('/')
else:
counter = len(mydictionary_list_all.word) + 1
mydictionary_list_all.count = counter
mydictionary_list_all.word.append(words)
mydictionary_list_all.put()
num_words = myuser.num_words + 1
unique = myuser.unique
myuser = MyUser(id=user.user_id(),
num_words=num_words,
unique=unique)
myuser.put()
readLine = openFile.readline()
openFile.close()
template_values = {'display': 'Successful'}
template = JINJA_ENVIRONMENT.get_template('store.html')
self.response.write(template.render(template_values))
def get(self):
user = users.get_current_user()
resultList = []
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainpage_guest.html')
self.response.write(template.render(template_values))
return
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if my_user == None:
my_user = MyUser(id=user.user_id(),
name=user.email(),
anagram_count=0,
word_count=0)
my_user.put()
wordList = self.request.get('wordList')
wordSorted = sorting(wordList)
resultList = []
subList = subSort(wordSorted)
for key in subList:
w_key = ndb.Key('Anagram_engine', user.user_id() + key)
my_word = w_key.get()
if my_word != None:
resultList.extend(my_word.wordList)
user = users.get_current_user()
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
template_values = {
'user': user,
'anagram_count': my_user.anagram_count,
'word_count': my_user.word_count,
'resultList': resultList
}
template = JINJA_ENVIRONMENT.get_template('subAnagram.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
search_list = ''
template_values = {'myuser': myuser, 'search_list': search_list}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
# URL that will contain a login or logout link
# and also a string to represent this
url = ''
url_string = ''
myuser = ''
# pull the current user from the Request
user = users.get_current_user()
upload_url = blobstore.create_upload_url('/upload_photo')
# determine if we have a user logged in or not
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.user_id(), )
myuser.email_address = user.email()
myuser.put()
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
if not myuser.username:
self.redirect('/')
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
self.redirect('/')
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'myuser': myuser,
'upload_url': upload_url,
}
# pull the template file and ask jinja to render
# it with the given template values
template = JINJA_ENVIRONMENT.get_template('newpost.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
welcome = 'Welcome back'
myuser = None
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.user_id())
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'welcome': welcome,
'myuser': myuser
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
myuser.name = self.request.get('users_name')
myuser.age = int(self.request.get('users_age'))
myuser.put()
self.redirect('/')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
#If user is not found navigate to guest page and stop processing
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('mainguest.html')
self.response.write(template.render(template_values))
return
#If user is found get the user and navigate to the main page
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
key = self.request.GET['key']
other_user_key = ndb.Key('MyUser', key)
other_user = other_user_key.get()
date_format = '%Y-%m-%d %H:%M:%S.%f'
if other_user == myuser:
posts = sorted(
myuser.users_posts,
key=lambda x: datetime.strptime(x.get().time, date_format),
reverse=True)
else:
posts = sorted(
other_user.users_posts,
key=lambda x: datetime.strptime(x.get().time, date_format),
reverse=True)
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'myuser': myuser,
'other_user': other_user,
'other_user_key': other_user_key,
'user': user,
'get_serving_url': get_serving_url,
'posts': posts
}
template = JINJA_ENVIRONMENT.get_template('profilepage.html')
self.response.write(template.render(template_values))
def get(self):
self.request.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
if user == None:
template_values = {
'login_url': users.create_login_url(self.request.url)
}
template = JINJA_ENVIRONMENT.get_template('loginpage.html')
self.response.write(template.render(template_values))
return
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
name = self.request.get('name')
userbio = MyUser.query(MyUser.name == name).fetch()
list_tweets = MyUser.UserTweets.query(UserTweets.name == name).fetch()
twitter_key = ndb.Key('UserTweets', myuser.name)
twitter = twitter_key.get()
usertweets_new = myuser.usertweets
followBool = True
if userbio[0]:
logging.info(myuser.following)
if userbio[0].name in myuser.following:
followBool = False
template_values = {
'logout_url': users.create_logout_url(self.request.url),
'userbio': userbio,
'tweets': list_tweets,
'usertweets': myuser.usertweets,
'followBool': followBool,
'currentuser_name': myuser.name
}
template = JINJA_ENVIRONMENT.get_template('profile.html')
self.response.write(template.render(template_values))
