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 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):
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'
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 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):
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 == 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 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 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 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 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):
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(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):
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'
# 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 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'
# 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 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.response.headers['Content-Type'] = 'text/html'
# pull the current user from the Request
user = users.get_current_user()
if user == None:
url_string = 'login'
url = users.create_login_url(self.request.uri)
template_values = {
'url_string': url_string,
'url': url,
'login_url': users.create_login_url(self.request.uri)
}
template = JINJA_ENVIRONMENT.get_template('main.html')
self.response.write(template.render(template_values))
return
url_string = 'logout'
url = users.create_logout_url(self.request.uri)
query = MyUser.query()
template_values = {
"user": user,
'url_string': url_string,
'url': url,
}
# pull the template file and ask jinja to render
# it with the given template values
template = JINJA_ENVIRONMENT.get_template('create_taskboard.html')
self.response.write(template.render(template_values))
def post(self):
new_board_name = self.request.get('new_board_name')
boardId = self.request.get('id')
getBoard = TaskBoard.get_by_id(boardId)
board_name = getBoard.tb_name
getAllUsers = MyUser.query().fetch()
action = self.request.get('button')
if action == 'rename':
for a in list(getAllUsers):
for b in list(a.myuser_board):
if (b.tb_name == board_name):
b.tb_name = new_board_name
a.put()
getBoard.tb_name = new_board_name
getBoard.put()
self.redirect('/view_board?id=' + boardId)
elif action == 'cancel':
self.redirect('/view_board?id=' + boardId)
def post(self):
self.response.headers['Content-Type'] = 'text/html'
if self.request.get('button') == 'Research':
key = ndb.Key('ListUser', 'default')
list_user = key.get()
del list_user.list_user
research = self.request.get('email_address')
research_user = MyUser.query(MyUser.email_address == research)
for i in research_user:
list_user.list_user.append(i)
list_user.put()
self.redirect('/')
if self.request.get('button') == 'Add comment':
post_id = self.request.get('post_id')
comment = self.request.get('comment')
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
my_comment = MyComment(user=myuser, comment=comment, creation_time=datetime.now())
my_comment.put()
list_comment = ListComment.query(ListComment.post_id == post_id)
for i in list_comment:
i.list_comment.append(my_comment)
i.list_comment = sorted(i.list_comment, key=lambda comment: comment.creation_time)
i.put()
self.redirect('/')
def post(self):
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
# user_id = self.request.get('id')
# profile_key = ndb.Key('MyUser', user_id)
# profile = profile_key.get()
if self.request.get('button') == 'search':
search_result = []
search_string = self.request.get('search_string').lower()
user_list = MyUser.query().order(MyUser.username).fetch()
for i in user_list:
temp = i.username.startswith(search_string)
if temp:
search_result.append(i)
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.user_id())
myuser = myuser_key.get()
template_values = {
'url': users.create_logout_url(self.request.uri),
'user': user,
'myuser': myuser,
'upload_url': blobstore.create_upload_url('/upload'),
'search_result': search_result
}
template = JINJA_ENVIRONMENT.get_template('list.html')
self.response.write(template.render(template_values))
def get(self):
self.response.headers['Content-Type'] = 'text/html'
boardId = self.request.get('id')
user = users.get_current_user()
myuser_key = ndb.Key('MyUser', user.email())
myuser = myuser_key.get()
getBoard = TaskBoard.get_by_id(boardId)
name_of_board = getBoard.tb_name
creator = getBoard.creator
allUsers = MyUser.query().fetch()
template_values = {
'myuser': myuser,
'board_name': name_of_board,
'creator': creator,
'users': allUsers,
'board_id': boardId
}
template = JINJA_ENVIRONMENT.get_template('invite.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.email())
myuser = myuser_key.get()
board_id = self.request.get('id')
invited_user = self.request.get('invited_user')
getBoard = TaskBoard.get_by_id(board_id)
board_name = getBoard.tb_name
get_member = MyUser.get_by_id(invited_user)
action = self.request.get('button')
if action == 'invite':
newMember = TaskBoardProperty(tb_name=board_name, tb_id=board_id)
get_member.myuser_board.append(newMember)
get_member.put()
getBoard.tb_member.append(invited_user)
getBoard.put()
self.redirect('/')
elif action == 'cancel':
self.redirect('/view_board?id=' + board_id)
def post(self):
self.response.headers['Content-Type'] = 'text/html'
template = JINJA_ENVIRONMENT.get_template('main.html')
action = self.request.get('button')
if action == 'Search':
tweet_username_list = []
tweet_text_list = []
tweet_search = self.request.get('tweet_search')
if tweet_search == '':
tweet_username_list = []
tweet_text_list = []
else:
username_query = MyUser.query().fetch()
tweet_content_query = TweetModel.query().fetch()
for user in username_query:
if any(word in user.username
for word in tweet_search.split()):
tweet_username_list.append(user.username)
tweet_text_list.append("")
for tweet in tweet_content_query:
if all(word in tweet.tweet_text
for word in tweet_search.split()):
tweet_username_list.append(tweet.tweet_username)
tweet_text_list.append(tweet.tweet_text)
template_values = {
'tweet_username_list': tweet_username_list,
'tweet_text_list': tweet_text_list
}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
if action == 'Back':
self.redirect('/')
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 delete(self, Id):
"""Delete a student with key == Id"""
student = MyUser.get( db.Key(encoded=Id) )
if student != None:
classes = get_student_classes(student)
for c in classes:
c.remove_student(student)
if student.isLocal():
student.delete()
def put(self,Id):
"""Save a student with key == Id"""
student = MyUser.get( db.Key(encoded=Id) )
if student:
jsn = json.decoder.JSONDecoder()
model = jsn.decode( self.request.get('model'))
student.from_json( model )
student.put()
else:
raise Exception('Saving of student failed')
def get(self):
admin = self.get_current_admin()
if not admin:
self.redirect('/')
return
query = MyUser.all().filter('roles = ', 'teacher')
teachers = query.fetch(1000)
template_values = {'teachers':teachers}
write_template(self, admin, 'admin_start.html', template_values)
def get_author(self,i = None):
if i == None:
i = 0
author = MyUser.get( self.authors[i] )
return author
