def get(self):
self.response.headers['Content-Type'] = 'text/html'
# pull the current user from the Request
user = users.get_current_user()
url_ID = self.request.get("url_ID")
vuser = ""
myuser = ""
# 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', url_ID)
myuser = myuser_key.get()
vuser_key = ndb.Key('MyUser', user.user_id())
vuser = vuser_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,
}
# pull the template file and ask jinja to render
# it with the given template values
template = JINJA_ENVIRONMENT.get_template('fwers.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()
list = ''
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
anagramlist = AnagramList()
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.anagramcount = 0
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
action = self.request.get('button')
if action == 'Search':
string = self.request.get('value_2')
word = sorted(string)
order = ''.join(word)
key = ndb.Key('AnagramList', user.user_id() + order)
anagramlist = key.get()
list = anagramlist.list
if list == None:
self.redirect('/')
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'welcome': welcome,
'anagramlist': list
}
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('first_mainpage.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(),
email_address=user.email())
myuser.put()
#all_keys = EV.query().fetch(keys_only = True)
template_values = {
'logout_url': users.create_logout_url(self.request.uri),
'username': user,
#'all_keys' : all_keys,
'message': "Add EVs"
}
#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 = ''
# pull the current user from the request
#user = users.get_current_user()
#if user:
#url = users.create_logout_url(self.request.uri)
#url_string = 'logout'
#else:
#url = users.create_login_url(self.request.uri)
#url_string = 'login'
#template_values = {
#'url' : url,
#'url_string' : url_string,
#'user' : user
#}
template = JINJA_ENVIRONMENT.get_template('main.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 = ''
login_status = ''
welcome = ''
#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:
login_status = "You are logged in."
myuser_key = ndb.Key('MyUser', user.user_id())
#myuser = MyUser(email_address = user.email())
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
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:
login_status = "To visit this page, You need to login."
url = users.create_login_url(self.request.uri)
url_string = 'login'
self.redirect('/')
return
#url = users.create_login_url(self.request.uri)
#url_string = 'login'
template_values = {
'url': url,
'url_string': url_string,
'login_status': login_status,
'user': user,
'welcome': welcome
}
template = JINJA_ENVIRONMENT.get_template('addingev.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()
timeline = []
for posts in myuser.users_posts:
timeline.append(posts)
for f in myuser.following_list:
for posts in f.get().users_posts:
timeline.append(posts)
date_format = '%Y-%m-%d %H:%M:%S.%f'
#perform get here to get the post object from its key
posts = sorted(
timeline,
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,
'upload_url': blobstore.create_upload_url('/upload'),
'get_serving_url': get_serving_url,
#Only show the first 50 posts
'posts': posts[:50]
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Typ'] = 'text/html'
#initializing variables
url = ''
url_string = ''
welcome = 'Welcome back'
myuser = None
#gets current user
user = users.get_current_user()
#selection for user
if user:
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
#gets user key
myuser_key = ndb.Key('MyUser', user.user_id())
#generates user from key
myuser = myuser_key.get()
if myuser == None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.user_id())
#adds mail attribute
myuser.email_address = user.email()
#saves user to datastore
myuser.put()
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
#assign template values to be rendered to the html page
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'
global anagramUniqueWordCount
global anagramWordListCount
welcome = 'Welcome'
url_string = ''
myuser = ''
url = ''
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(),
username=user.email(),
anagramwordlistcount=0,
anagramuniquewordcount=0)
myuser.put()
anagramUniqueWordCount = myuser.anagramuniquewordcount
anagramWordListCount = myuser.anagramwordlistcount
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,
'uniqueanagramwordcurrentdata': anagramUniqueWordCount,
'anagramwordlistcurrentdata': anagramWordListCount
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html' ''
query = MyUser.query()
# URL that will contain a login or logout link
# and also a string to represent this
url = ''
url_string = ''
welcome = 'Welcome back'
myuser = ''
# pull the current user from the Request
user = users.get_current_user()
# determine if we have a user logged in or not
if user:
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()
if not myuser.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 = {
'user': user,
'myuser': myuser,
}
# pull the template file and ask jinja to render
# it with the given template values
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 = ''
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()
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'myuser': myuser,
}
template = JINJA_ENVIRONMENT.get_template('add.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['content-type'] = 'text/html'
url = ''
url_string = ''
myuser = None
no_words = []
welcome = 'Welcome back'
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 is None:
welcome = 'Welcome to the application'
myuser = MyUser(id=user.user_id())
myuser.put()
for list in myuser.lists:
my_list_key = ndb.Key('MyList', user.user_id() + "-" + list)
my_list = my_list_key.get()
no_words.append(len(my_list.anagrams))
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,
'no_words': no_words,
}
template = JINJA_ENVIRONMENT.get_template('dictionary.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers["Content-Type"] = "text/html"
user = Services().get_current_user()
word_model = Anagram.query()
anagram_model = None
if user:
url = users.create_logout_url(self.request.uri)
myuser_key = ndb.Key("MyUser", Services().get_current_user_id())
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=user.user_id())
myuser.put()
anagram_query = Anagram.query(Anagram.user_id == Services().get_current_user_id())
inputed_word = self.request.get("input_word").lower()
if len(inputed_word) > 0:
if self.request.GET.get("search") == "Search Word":
anagram_query = anagram_query.filter(Anagram.inputed_words.IN([inputed_word]))
anagram_model = anagram_query.fetch()
else:
url = users.create_login_url(self.request.uri)
template_values = {
"url": url,
"user": user,
"anagram_model":anagram_model
}
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.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()
template_values = {
'logout_url': users.create_logout_url(self.request.url)
}
template = JINJA_ENVIRONMENT.get_template('signup.html')
self.response.write(template.render(template_values))
else:
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user()
name = self.request.get('name')
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
storetweets = UserTweets().query().fetch()
template_values = {
'logout_url': users.create_logout_url(self.request.url),
'usertweets': myuser.usertweets,
'user': user,
'myuser': myuser
}
template = JINJA_ENVIRONMENT.get_template('twitterhome.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['content-type'] = 'text/html'
url = ''
url_string = ''
my_user = None
my_sizes = []
user = users.get_current_user()
if user:
url = users.create_logout_url("/")
url_string = 'logout'
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if my_user is None:
my_user = MyUser(id=user.user_id())
my_user.put()
for gallery in my_user.galleries:
my_gallery_key = ndb.Key('MyGallery',
user.user_id() + "-" + gallery)
my_gallery = my_gallery_key.get()
my_sizes.append(len(my_gallery.images))
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'my_user': my_user,
'my_sizes': my_sizes,
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
template = JINJA_ENVIRONMENT.get_template('username.html')
user = users.get_current_user()
action = self.request.get('button')
if action == 'Submit':
edit = self.request.get('edit')
full_name = self.request.get('full_name')
description = self.request.get('description')
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if edit == 'yes':
myuser.full_name = full_name
myuser.description = description
myuser.put()
self.redirect('/')
elif edit == 'no':
username = self.request.get('username')
username_query = MyUser.query(
MyUser.username == username).fetch()
if not username_query:
if myuser == None:
myuser = MyUser(id=user.user_id(),
userid=user.user_id(),
email_address=user.email(),
username=username,
full_name=full_name,
description=description,
followers=[],
following=[])
myuser.put()
self.redirect('/')
else:
error = 'Username already exists'
template_values = {'error': error, 'myuser': myuser}
self.response.write(template.render(template_values))
elif action == 'Back':
self.redirect('/')
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
myuser = ''
user = ''
welcome = 'Welcome back'
user = users.get_current_user()
y = ''
if user:
y = reve.query().fetch()
url = users.create_logout_url(self.request.uri)
url_string = 'logout'
template = JINJA_ENVIRONMENT.get_template('option.html')
self.response.write(template.render())
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()
else:
y = reve.query().fetch()
url = users.create_login_url(self.request.uri)
url_string = 'login'
template = JINJA_ENVIRONMENT.get_template('option.html')
self.response.write(template.render())
template_values = {
'y': y,
'url': url,
'url_string': url_string,
'user': user,
'welcome': welcome,
'myuser': myuser
}
template = JINJA_ENVIRONMENT.get_template('A1.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Typ'] = 'text/html'
url = ''
url_string = ''
welcome = 'Welcome back'
myuser = None
# get current user
user = users.get_current_user()
# selection statement for 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'
# values to be rendered to the main.html page
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'
url = ''
url_string = ''
welcome = 'Welcome'
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'
gpu_name_list_compare_query = MyGPUDatabase().query().fetch()
template_values = {
'url' : url,
'url_string' : url_string,
'user' : user,
'welcome' : welcome,
'myuser' : myuser,
'gpu_name_list_query' : gpu_name_list_compare_query
}
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('loginpage_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),
'gpu': Gpu.query().fetch()
}
template = JINJA_ENVIRONMENT.get_template('login_page.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()
if action=='Add':
wordEntered = self.request.get('Word')
if not re.match("^[a-z]*$", wordEntered.lower()):
message = "Please enter alphabets only"
else:
addedText = self.request.get('Word')
wordLexi = list(addedText.lower())
anaSort = sorted(wordLexi)
addWord = ''.join(anaSort)
anagramEnginekey = ndb.Key('model',user.email()+addWord)
anagram = anagramEnginekey.get()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if anagram == None :
addAnagram = model(id=user.email()+addWord,anagramK=addWord)
addAnagram.User=user.email()
addAnagram.wordList.append(wordEntered)
addAnagram.wCount = 1
addAnagram.lCount = len(wordEntered)
wordCount = myuser.wordCount+1
anaCount = myuser.anaCount+1
myuser = MyUser(id=user.user_id(),username=user.email(),anaCount=anaCount,wordCount=wordCount)
myuser.put()
addAnagram.put()
message = "Word added"
else:
flag = False
for word in anagram.wordList:
if word == wordEntered:
flag = True
break
else:
flag = False
if flag:
message = 'Word already exists'
else:
# anagram.User=user.email()
anagram.wordList.append(wordEntered)
anagram.wCount = anagram.wCount + 1
anagram.put()
wordCount = myuser.wordCount+1
anaCount = myuser.anaCount
myuser = MyUser(id=user.user_id(),username=user.email(),anaCount=anaCount,wordCount=wordCount)
myuser.put()
message = "Word added"
template_values ={
'message':message,
'word_count': myuser.wordCount,
'ana_count' : myuser.anaCount
}
template = JINJA_ENVIRONMENT.get_template('add.html')
self.response.write(template.render(template_values))
def storingAnagramWord(getLexicographicalWord, self):
getUserName = users.get_current_user()
myuser_key = ndb.Key('MyUser', getUserName.user_id())
myuser = myuser_key.get()
anagramWordLetterLength = len(getLexicographicalWord)
lexicographicalOrderedAnagramWord = ReorderingWord(getLexicographicalWord)
keyName = getUserName.user_id()+lexicographicalOrderedAnagramWord
retriveAnagramkey = ndb.Key(MyAnagramDatabase, keyName)
retriveAnagramWord = retriveAnagramkey.get()
if retriveAnagramWord == None:
userSpecificAnagramCount = MyUser(id=getUserName.user_id(), anagramwordlistcount = myuser.anagramwordlistcount+1,
anagramuniquewordcount = myuser.anagramuniquewordcount+1,
username=getUserName.email())
storedatabase = MyAnagramDatabase(id=keyName, lettercount = anagramWordLetterLength, useremailid = getUserName,
wordcount = 1)
storedatabase.anagramwordlist.append(getLexicographicalWord)
userSpecificAnagramCount.put()
storedatabase.put()
template_values = {
'success' : 'Word added successfully to the system',
'getLexicographicalWordPrint' : getLexicographicalWord
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
else:
counterWordExist = 0
for storedAnagramWord in retriveAnagramWord.anagramwordlist:
if storedAnagramWord == getLexicographicalWord:
counterWordExist = 1
break
if counterWordExist == 1:
template_values = {
'error' : 'Word already exist in the system',
'storedAnagramWordPrint' : storedAnagramWord
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
else:
userSpecificAnagramCount = MyUser(id=getUserName.user_id(),
anagramuniquewordcount = myuser.anagramuniquewordcount,
anagramwordlistcount = myuser.anagramwordlistcount+1,
username=getUserName.email())
retriveAnagramListLength = len(retriveAnagramWord.anagramwordlist)
retriveAnagramWord.wordcount = retriveAnagramListLength + 1
retriveAnagramWord.anagramwordlist.append(getLexicographicalWord)
userSpecificAnagramCount.put()
retriveAnagramWord.put()
template_values = {
'success' : 'Word added successfully to the system',
'getLexicographicalWordPrint' : getLexicographicalWord
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
fileUpload = self.request.get('file')
action = self.request.get('button')
user = users.get_current_user()
if action=='Upload':
openf= open(fileUpload)
readFile = openf.readline()
while readFile:
Word=(readFile.strip('\n\r')).lower()
# readText = self.request.get(Word)
wordLexi = list(Word.lower())
anaSort = sorted(wordLexi)
addWord = ''.join(anaSort)
anagramEnginekey = ndb.Key('model',user.email()+addWord)
anagram = anagramEnginekey.get()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
if anagram == None :
addAnagram = model(id=user.email()+addWord,anagramK=addWord)
addAnagram.User=user.email()
addAnagram.wordList.append(Word)
addAnagram.wCount = 1
addAnagram.lCount = len(Word)
addAnagram.put()
wordCount = myuser.wordCount+1
anaCount = myuser.anaCount+1
myuser = MyUser(id=user.user_id(),username=user.email(),anaCount=anaCount,wordCount=wordCount)
myuser.put()
message = 'File uploaded successfully'
else:
flag = False
for word in anagram.wordList:
if word == Word:
flag = True
break
else:
flag = False
if flag:
message = 'Word already exists'
else:
# anagram.User=user.email()
anagram.wordList.append(Word)
anagram.wCount = anagram.wCount + 1
anagram.put()
wordCount = myuser.wordCount+1
anaCount = myuser.anaCount
myuser = MyUser(id=user.user_id(),username=user.email(),anaCount=anaCount,wordCount=wordCount)
myuser.put()
readFile = openf.readline()
openf.close()
template_values ={
'message': message
}
template = JINJA_ENVIRONMENT.get_template('upload.html')
self.response.write(template.render(template_values))
def post(self):
self.response.headers['Content - Type'] = 'text / html'
action = self.request.get('button')
if action == 'ADD WORD':
wordList = self.request.get('wordList')
wordLength = len(wordList)
wordSorted = sort(wordList)
# subWords= subAnagram(wordList)
if wordList == '':
self.redirect('/')
else:
user = users.get_current_user()
anagram_key = user.user_id() + wordSorted
lexicography = ndb.Key(Anagram_engine, anagram_key)
wordRetrieved = lexicography.get()
my_user_key = ndb.Key('MyUser', user.user_id())
my_user = my_user_key.get()
if wordRetrieved == None:
wordInfo = Anagram_engine(id=anagram_key,
wordSorted=wordSorted.lower(),
wordLength=wordLength,
email=user,
wordCount=1)
anagram_count = my_user.anagram_count + 1
word_count = my_user.word_count + 1
my_user = MyUser(id=user.user_id(),
name=user.email(),
anagram_count=anagram_count,
word_count=word_count)
my_user.put()
wordInfo.wordList.append(wordList)
wordInfo.put()
self.redirect('/')
else:
counter = len(wordRetrieved.wordList) + 1
wordRetrieved.wordCount = counter
wordRetrieved.wordList.append(wordList)
wordRetrieved.put()
word_count = my_user.word_count + 1
anagram_count = my_user.anagram_count
my_user = MyUser(id=user.user_id(),
name=user.email(),
anagram_count=anagram_count,
word_count=word_count)
my_user.put()
responseMessage = {
"message":
" New Word is added to the anagram engine database. "
}
template = JINJA_ENVIRONMENT.get_template(
'add_anagram.html')
self.response.write(template.render(responseMessage))
def post(self):
#action = self.request.get('button')
sq = MyEV.query().fetch(keys_only=True)
datastore_message = 'Search results'
#query = MyEV.query()
#r = list(query.fetch())
if self.request.get('button'):
if self.request.get('q_name'):
searchquery = MyEV.query(
MyEV.name == self.request.get('q_name')).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
if self.request.get('q_manufacturer'):
searchquery = MyEV.query(MyEV.manufacturer == self.request.get(
'q_manufacturer')).fetch(keys_only=True)
sq = set(sq).intersection(searchquery)
# If a user enters a query either lower or upper limit, the results
# displays all that is saved in the datastore. It displays a result
# specific to the query if both upper and lower limits are entered.
if self.request.get('q_year') and self.request.get('q_yearMAX'):
searchquery = MyEV.query(
MyEV.year >= int(self.request.get('q_year'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
searchquery = MyEV.query(
MyEV.year <= int(self.request.get('q_yearMAX'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
if self.request.get('q_batterysize') and self.request.get(
'q_batterysizeMAX'):
searchquery = MyEV.query(
MyEV.batterysize >= int(self.request.get('q_batterysize'))
).fetch(keys_only=True)
sq = set(sq).intersection(searchquery)
searchquery = MyEV.query(MyEV.batterysize <= int(
self.request.get('q_batterysizeMAX'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
if self.request.get('q_wltp') and self.request.get('q_wltpMAX'):
searchquery = MyEV.query(
MyEV.WLTPrange >= float(self.request.get('q_wltp'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
searchquery = MyEV.query(
MyEV.WLTPrange <= float(self.request.get('q_wltpMAX'))
).fetch(keys_only=True)
sq = set(sq).intersection(searchquery)
if self.request.get('q_cost') and self.request.get('q_costMAX'):
searchquery = MyEV.query(
MyEV.cost >= int(self.request.get('q_cost'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
searchquery = MyEV.query(
MyEV.cost <= int(self.request.get('q_costMAX'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
if self.request.get('q_power') and self.request.get('q_powerMAX'):
searchquery = MyEV.query(
MyEV.power >= int(self.request.get('q_power'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
searchquery = MyEV.query(
MyEV.power <= int(self.request.get('q_powerMAX'))).fetch(
keys_only=True)
sq = set(sq).intersection(searchquery)
ro = ndb.get_multi(sq)
'''
if self.request.get('q_batterysize'):
searchquery = sq.filter(MyEV.batterysize ==int(self.request.get('q_batterysize')))
if self.request.get('q_wltp'):
searchquery = sq.filter(MyEV.WLTPrange== float(self.request.get('q_wltp')))
if self.request.get('q_cost'):
searchquery = sq.filter(MyEV.cost == int(self.request.get('q_cost')))
if self.request.get('q_power'):
searchquery = sq.filter(MyEV.power == int(self.request.get('q_power')))
# If nothing selected on the form, display the full EV list
if searchquery==None:
ro=list(sq.fetch())
ev_string = 'No attribute selected. The EV names in the datastore are displayed below.'
# Display a list of EVs that satisfy the query as a list of hyperlinks.
else:
ro=list(searchquery.fetch())
ev_string = 'The EV names in the datastore based on the query are displayed below.'
'''
# URL that will contain a login or logout link
# and also a string to represent this
url = ''
url_string = ''
welcome = 'Welcome back'
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)
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)
url_string = 'login'
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'datastore_message': datastore_message,
'welcome': welcome,
'myev': myev,
'list': ro
}
# 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 add_new_user(user):
MyUser(id=user.user_id()).put()
def get(self):
self.response.headers['Content-Type'] = 'text/html'
user = users.get_current_user() #Fetching the current user
#If user is not loogged in, display main_guest page
if user == None:
template_values = {
'url': users.create_login_url(self.request.uri),
}
template = JINJA_ENVIRONMENT.get_template('main_guest.html')
self.response.write(template.render(template_values))
return
#If user is logged in
#We fetch the user key and details
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
#If this is a new user, we create a datastore entity for it
if myuser == None:
email_address = user.email().lower()
name = user.email().split('@')
myuser = MyUser(id=user.user_id(),
email_address=email_address,
username=name[0].lower(),
followers_count=0,
following_count=0)
myuser.put()
img_url_list = []
no_posts = False
if myuser.following != []:
query = Post.query().filter(
ndb.OR(Post.post_by.IN(myuser.following), Post.post_by ==
myuser_key)).order(-Post.upload_time).fetch(50)
else:
query = Post.query().filter(
Post.post_by == myuser_key).order(-Post.upload_time).fetch(50)
if query != []:
for i in query:
url = images.get_serving_url(i.uploads)
img_url_list.append(url)
else:
no_posts = True
#With the details, we render the Home page of our application
template_values = {
'url': users.create_logout_url(self.request.uri),
'user': user,
'myuser': myuser,
'img_url_list': img_url_list,
'query': query,
'no_posts': no_posts,
'upload_url': blobstore.create_upload_url('/upload')
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
url = ''
url_string = ''
myuser = ''
user = ''
welcome = 'Welcome back'
user = users.get_current_user()
po = []
capt = []
im = []
cap = []
im1 = []
cap1 = []
alpo = 0
if user:
user = users.get_current_user()
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()
myuser_key2 = ndb.Key('MyUser', user.email()).get()
im = myuser_key2.following
if myuser_key2.following == None:
for i in myuser_key2.following:
im.append(i)
im.append(user.email())
df = []
for j in im:
ca = ndb.Key('Post', j).get()
if ca != None:
for i in range(0, len(ca.timepost)):
df.append(ca.timepost[i])
df.sort(reverse=True)
for i in range(0, len(df)):
f = 0
for k in range(0, len(im)):
if f == 0:
fg = ndb.Key('Post', im[k]).get()
if fg != None:
for j in range(0, len(fg.timepost)):
if fg.timepost[j] == df[i]:
im1.append(fg.imageurl[j])
cap1.append(fg.caption[j])
f = 1
break
else:
break
po = im1
capt = cap1
po.sort(reverse=True)
capt.sort(reverse=True)
if len(po) < 50:
alpo = len(po)
else:
alpo = 50
else:
url = users.create_login_url(self.request.uri)
url_string = 'login'
template_values = {
'alpo': alpo,
'po': po,
'capt': capt,
'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 self.request.get('my_gpu_geometryShader'):
geometryShader = True
else:
geometryShader = False
if self.request.get('my_gpu_tesselationShader'):
tesselationShader = True
else:
tesselationShader = False
if self.request.get('my_gpu_shaderInt16'):
shaderInt16 = True
else:
shaderInt16 = False
if self.request.get('my_gpu_sparseBinding'):
sparseBinding = True
else:
sparseBinding = False
if self.request.get('my_gpu_textureCompressionETC2'):
textureCompressionETC2 = True
else:
textureCompressionETC2 = False
if self.request.get('my_gpu_vertexPipelineStoreandAtomics'):
vertexPipelineStoreandAtomics = True
else:
vertexPipelineStoreandAtomics = False
query = Address.query(
Address.geometryShader == geometryShader,
Address.tesselationShader == tesselationShader,
Address.shaderInt16 == shaderInt16,
Address.sparseBinding == sparseBinding,
Address.textureCompressionETC2 == textureCompressionETC2,
Address.vertexPipelineStoreandAtomics ==
vertexPipelineStoreandAtomics)
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('myfeature.html')
self.response.write(template.render(template_values))
if self.request.get('button') == 'Cancel':
self.redirect('/')
def get(self):
action=self.request.get('task')
action1 =self.request.get('invite')
user=users.get_current_user()
if action :
x=ndb.Key('TaskListdata',self.request.get('taskboard_name')+""+self.request.get('task_name')).get()
if x==None:
if self.request.get('task_Status')=='':
b=False
else:
b=self.request.get('task_Status')
action=self.request.get('task')
user=users.get_current_user()
x=TaskListdata(id=self.request.get('taskboard_name')+""+self.request.get('task_name'))
x.taskboard_name=self.request.get('taskboard_name')
x.task_creater=user.email()
x.task_Status=str(b)
if self.request.get('task_Status')=='True':
x.task_completed_date_time=now.strftime("%d/%m/%Y %H:%M:%S")
x.task_allocated_user=self.request.get('task_allocated_user')
x.task_name=self.request.get('task_name')
x.task_due_date=self.request.get('task_due_date')
x.put()
o=user.email()+""+self.request.get('taskboard_name')
mytask = ndb.Key('TaskBoarddata', self.request.get('taskboard_owner_name')+""+self.request.get('taskboard_name')).get()
mytask.task.append(self.request.get('taskboard_name')+""+self.request.get('task_name'))
mytask.put()
self.redirect('/')
else:
self.response.write('task already present in task boad')
self.redirect('/')
elif action1=="invite":
self.response.write('action1')
admin=self.request.get('taskboard_owner_name')
self.response.write(self.request.get('taskboard_owner_name'))
if admin==user.email():
myuser_key = ndb.Key('MyUser', self.request.get('user'))
myuser = myuser_key.get()
if myuser == None:
myuser = MyUser(id=self.request.get('user'))
myuser.email_address=self.request.get('user')
myuser.i.append(user.email()+""+self.request.get('taskboard_name'))
myuser.put()
mytask = ndb.Key('TaskBoarddata',user.email()+""+self.request.get('taskboard_name') ).get()
mytask.taskboard_participant.append(self.request.get('user'))
mytask.put()
self.redirect('/')
else:
myuser = ndb.Key('MyUser', self.request.get('user')).get()
myuser.i.append(user.email()+""+self.request.get('board'))
myuser.put()
mytask = ndb.Key('TaskBoarddata',user.email()+""+self.request.get('taskboard_name') ).get()
mytask.taskboard_participant.append(self.request.get('user'))
mytask.put()
self.redirect('/')
else:
self.response.write('Please Contact Admin To add participant.')
self.redirect('/')
template_values = {
'taskboard_name':self.request.get('taskboard_name'),
'taskboard_owner_name':self.request.get('taskboard_owner_name'),
'list':list,
'task_Status':self.request.get('task_Status')
}
template = JINJA_ENVIRONMENT.get_template('dash.html')
self.response.write(template.render(template_values))
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') == 'Add':
addWord = self.request.get('add_word')
if addWord.isalpha():
lex = Anagram.processWord(addWord)
anagram_key = ndb.Key('Anagram', lex)
anagram = anagram_key.get()
if anagram:
if not addWord in anagram.words:
anagram.words.append(addWord)
anagram.put()
myuser.userWordCount += 1
myuser.put()
else:
newAnagram = Anagram(id=lex,
letterCount=len(addWord),
words=[addWord.lower()])
newAnagram.put()
myuser.userWordCount += 1
myuser.userAnagramCount += 1
myuser.put()
template_values = {
'url': url,
'url_string': url_string,
'user': user,
'myuser': myuser,
'message': 'Word Added',
}
template = JINJA_ENVIRONMENT.get_template('add.html')
self.response.write(template.render(template_values))
def addUser(user):
my_user = MyUser(id=user.user_id())
addRoot(my_user)
my_user.currentDir = ndb.Key(Directory, my_user.key.id() + '/')
my_user.put()
