def get(self):
state = self.request.get('state')
code = self.request.get('code')
error = self.request.get('error')
if not error:
logging.info('User accepted authorization, state %s, code %s', state, code)
access = facebookService.requestAccessToken(code)
token = access["access_token"]
user = userService.getByFacebookToken(token)
if user:
logging.info('User registered with token')
session = get_current_session()
if session.is_active():
session.terminate()
session['profile'] = user
else:
logging.info('User not registered %s', token)
session = get_current_session()
if session.is_active():
session.terminate()
faceuser = facebookService.getUserByToken(token)
logging.info('Faceuser %s', faceuser)
user = self.getUserJSON(faceuser, token)
user = userService.save(user)
session['profile'] = user
if state == 'landingpage':
self.redirect('/home')
if state == 'signup':
self.redirect('/photos/' + user.username)
else:
logging.info('User declined authorization, error %s', error)
return
def post(self):
enforce_login(self)
upload_files = self.get_uploads(
'file') # 'file' is file upload field in the form
blob_info = upload_files[0]
epub = model.ePubFile(blob=blob_info, blob_key=blob_info.key())
epub.put()
entry = model.LibraryEntry(epub=epub,
user=get_current_session().get("account"))
entry.put()
unpacker = unpack.Unpacker()
existing, error = unpacker.unpack(epub)
if error is None:
epub_key = epub.key() if existing is None else existing.key()
logging.info("Indexing epub with key %s" % epub_key)
taskqueue.add(queue_name='index',
url='/index',
countdown=2,
params={
'key': epub_key,
'user': get_current_session().get("account")
})
epub.get_cover()
self.redirect("/book/" + str(epub.key().id()))
else:
db.delete(entry)
blobstore.delete(epub.blob.key())
db.delete(epub)
error = "Invalid EPUB file" if error.find(
"File is not a zip") > 0 else error
respondWithMessage(self, "Upload error: " + error)
def is_logged(rhandler=None):
session = get_current_session()
if session.has_key('user'):
return session['user']
else:
if rhandler is not None:
fbcookie = facebook.get_user_from_cookie(rhandler.request.cookies)
if fbcookie:
graph = facebook.GraphAPI(fbcookie["access_token"])
profile = graph.get_object("me")
query = User.all().filter('fb_ui =', profile['id']).fetch(1);
if len( query ) == 1:
session = get_current_session()
user = query[0]
if session.is_active():
session.terminate()
session.regenerate_id()
session['user'] = user
#update access_token.....
if user.fb_access_token != fbcookie["access_token"]:
user.fb_access_token = fbcookie["access_token"]
user.put();
if session.has_key('user'):
return session['user']
else:
return False
def get(self):
#check if it needs logout
if self.request.get('logout'):
session = get_current_session()
if session.is_active():
session.terminate()
professor = None
links = []
#check if has user data
if self.request.get('key_name'):
professor = Professor.get_by_key_name(self.request.get('key_name'))
if professor:
# close any active session the user has since he is trying to login
session = get_current_session()
if session.is_active():
session.terminate()
#start new session
session['user'] = professor
session = get_current_session()
if session.is_active():
professor = session['user']
links = Link.all().filter('professor =', professor).fetch(100)
self.render_template('web/home_logged.html',{'professor':professor,'links':links})
else:
self.render_template('web/home.html',{})
def authenticated_request_method(self, *args, **kw):
from gaesessions import get_current_session
session = get_current_session()
self.user = None
self.fb = Facebook(creds['AppSecret'], creds['AppID'])
if session.has_key('fb_auth_state') and session['fb_auth_state'] == self.request.get('state'):
if self.fb.exchange_code_for_auth_token(self.request):
session.terminate()
session = get_current_session()
session['uid'] = 'F' + self.fb.uid
self.user = UserFactory.getFacebookUser(self.fb)
else:
if session.has_key('uid'):
self.user = UserFactory.getFacebookUserById(session['uid'])
elif not self.fb.check_authentication(self.request):
if session.is_active():
session.terminate()
import hashlib
md5 = hashlib.md5()
md5.update("cam is cool")
session['fb_auth_state'] = md5.hexdigest()
else:
if not session.has_key('uid'):
session['uid'] = 'F' + self.fb.uid
self.user = UserFactory.getFacebookUser(self.fb)
func(self, *args, **kw)
def post(self):
enforce_login(self)
upload_files = self.get_uploads('file') # 'file' is file upload field in the form
blob_info = upload_files[0]
epub = model.ePubFile(blob = blob_info, blob_key = blob_info.key())
epub.put()
entry = model.LibraryEntry(epub = epub, user = get_current_session().get("account"))
entry.put()
unpacker = unpack.Unpacker()
existing, error = unpacker.unpack(epub)
if error is None:
epub_key = epub.key() if existing is None else existing.key()
logging.info("Indexing epub with key %s" % epub_key)
taskqueue.add(queue_name = 'index', url='/index', countdown=2, params={
'key':epub_key,
'user':get_current_session().get("account")
})
epub.get_cover()
self.redirect("/book/"+str(epub.key().id()))
else:
db.delete(entry)
blobstore.delete(epub.blob.key())
db.delete(epub)
error = "Invalid EPUB file" if error.find("File is not a zip")>0 else error
respondWithMessage(self, "Upload error: "+error)
def get(self):
session = get_current_session()
isAdmin = session.get('isAdmin', False);
if not isAdmin:
self.redirect('/404/')
users = db.GqlQuery("SELECT * FROM User ORDER BY username, firstName, secondName").fetch(100)
message = session.get('message', '')
session = get_current_session()
username = cgi.escape(session.get('register_username', ''), quote=True)
firstName = cgi.escape(session.get('register_firstName', ''), quote=True)
secondName = cgi.escape(session.get('register_secondName', ''), quote=True)
classString = cgi.escape(session.get('register_classString', ''), quote=True)
school = cgi.escape(session.get('register_school', ''), quote=True)
email = cgi.escape(session.get('register_email', ''), quote=True)
gender = cgi.escape(session.get('register_gender', ''), quote=True)
groupId = cgi.escape(session.get('register_group_id', ''), quote=True)
template_values = {'users': users, 'message': message, 'username': username,
'firstName': firstName, 'secondName': secondName,
'classString': classString, 'school': school,
'email': email, 'gender': gender, 'groupId': groupId}
template = JINJA_ENVIRONMENT.get_template('admin.html')
self.response.write(template.render(template_values))
session['message'] = ""
session['register_username'] = ""
session['register_firstName'] = ""
session['register_secondName'] = ""
session['register_classString'] = ""
session['register_school'] = ""
session['register_email'] = ""
session['register_gender'] = ""
session['register_group_id'] = ""
def getSession(self, request, allowSessionCreation=True):
if allowSessionCreation:
return get_current_session()
else:
s = get_current_session()
if s.is_active():
return s
else:
return None
def getSession(self, request, allowSessionCreation=True):
if allowSessionCreation:
return get_current_session()
else:
s = get_current_session()
if s.is_active():
return s
else:
return None
def get(self): Core.IS_LOGIN = 0 Core.UNIVERSITY_ID = -1 Core.DOMAIN = "" Core.EMAIL = "" Core.STAFF_ID = "" Core.FIRSTNAME = "" Core.LASTNAME = "" get_current_session().terminate() self.redirect(users.create_logout_url(self.request.uri))
def post(self):
try:
q = self.request.get('q')
include = self.request.get('include')
logging.info("Searching for " + q)
query = "(name:%s OR html:%s)" % (q, q)
book = self.request.get('book_filter')
query = "book:%s AND %s" % (book,
query) if book is not None and len(
book.strip()) > 0 else query
sort_opts = search.SortOptions(match_scorer=search.MatchScorer())
opts = search.QueryOptions(limit=100,
snippeted_fields=['html'],
sort_options=sort_opts)
results = []
for indexName in ["private", "public"]:
if include is not None and len(
include.strip()) > 0 and include.find(indexName) == -1:
results.append({'count': -1, 'results': [], 'show': False})
continue
index_results = []
index = search.Index(indexName)
active_q = "owners:%s AND %s" % (get_current_session().get(
"account"), query) if indexName == "private" else query
search_query = search.Query(query_string=active_q,
options=opts)
search_results = index.search(search_query)
for doc in search_results:
internal = db.get(doc.doc_id)
if internal is not None:
logging.info("Got expressions %s" % doc.expressions)
index_results.append({
"snippets": doc.expressions,
"internal": internal
})
results.append({
'count': search_results.number_found,
'results': index_results,
'show': True
})
template_values = {
"current_user": get_current_session().get("account"),
"private_results": results[0]['results'],
"private_count": results[0]['count'],
"private_show": results[0]['show'],
"public_results": results[1]['results'],
"public_count": results[1]['count'],
"public_show": results[1]['show']
}
path = os.path.join(os.path.dirname(__file__),
'html/search_results.html')
self.response.out.write(template.render(path, template_values))
except search.Error:
respondWithMessage(self, "Search error")
def get(self):
enforce_login(self)
session = get_current_session()
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
template_values = {
"current_user" : get_current_session().get("account"),
"account" : account,
"fbName" : "n/a" if account.facebookInfo is None else json.loads(account.facebookInfo)["name"]
}
path = os.path.join(os.path.dirname(__file__), 'html/account.html')
self.response.out.write(template.render(path, template_values))
def post(self):
userid = self.request.get('userid')
passwd = self.request.get('passwd')
if userid == "" or passwd == "":
template = JINJA.get_template('login.html')
self.response.write(
template.render({
'the_title':
'Please Login',
'UserNameError':
'Please enter a Username or Password'
}))
else:
session = get_current_session()
session['userid'] = userid
queryCnames = ndb.gql(
"SELECT * FROM confirmedAccounts WHERE userid = :1", userid)
cNames = queryCnames.fetch()
if cNames == []:
template = JINJA.get_template('login.html')
self.response.write(
template.render({
'the_title':
'Please Login',
'UserNameError':
'Please enter a valid username'
}))
else:
for i in cNames:
if userid == i.userid and passwd == i.passwd:
session = get_current_session()
session['userid'] = self.request.get('userid')
self.redirect('/page1')
elif passwd != i.passwd:
template = JINJA.get_template('login.html')
self.response.write(
template.render({
'the_title':
'Please Login',
'wrongPassword':
'******'
}))
def post(self):
form = SignInForm(self.request.POST)
if not form.validate():
path = os.path.join(os.path.dirname(__file__))
path_length = path.__len__()
final_path = path + '/views/htmls/member_login_form.html'
#print final_path
data = {
'form': form,
}
self.response.out.write(template.render(final_path, data))
else:
login_check = login_member(self)
email = self.request.get("email")
password = self.request.get("password")
hashed_password = get_hash(password)
filters = {
"email": email,
"password": hashed_password,
}
session = get_current_session()
session.clear()
results, results_exist = datastore_results("Member", filters = filters, inequality_filters = None, order = None, fetch_total = 1000, offset = 0, mem_key = None)
if results_exist:
session = get_current_session()
session['member'] = True
session['email'] = email
if login_check:
### check for first name, if first name, go to main page
session = get_current_session()
session['member'] = True
email = session['email']
filters = {
"email": email,
}
results, results_exist = datastore_results("Member", filters = filters, inequality_filters = None, order = None, fetch_total = 1, offset = 0, mem_key = None)
first_name = None
if results_exist:
for result in results:
first_name = result.first_name
if first_name is None:
self.redirect('/?' + urllib.urlencode({'member_info': True}))
else:
self.redirect('/?' + urllib.urlencode({'home_page': True}))
else:
self.redirect('/?' + urllib.urlencode({'member_login': True}))
def post(self):
if(self.request.get('delete') == 'delete'):
leerlingen = db.GqlQuery("SELECT * FROM Leerling")
for leerling in leerlingen:
leerling.delete()
session = get_current_session()
klassen = db.GqlQuery("SELECT * FROM Klas")
for klas in klassen:
klas.delete()
session = get_current_session()
self.response.out.write(webpages.header(session))
self.response.out.write("<p>Deleted all entries <a href='/insert/leerling'>terug (insert nieuwe data)</a></p></body></html>")
self.response.out.write(webpages.footer())
def get(self):
result = self.user_login()
filter_option = cgi.escape(self.request.get('shows'))
if not filter_option:
session = get_current_session()
filter_option = session.get("filter")
else:
session = get_current_session()
session["filter"] = filter_option
result['filter'] = filter_option
if result['user'] is None:
self.go_to_login()
else:
self.go_to_home(result)
def get(self):
utils.session_bounce(self)
#grab session
session = get_current_session()
camera_keys = session.get("cameras")
cameras = db.get(camera_keys)
logging.info(get_current_session())
template_values = {
"cameras" : cameras
}
utils.respond(self,'templates/password.html',template_values)
def post(self):
email = self.request.get('email')
password = self.request.get('password')
user_group = self.request.get('user_group')
remember_me = self.request.get('remember-me')
session = get_current_session()
session.regenerate_id()
if user_group == 'seller':
seller = Seller.all().filter('email = ', email).get()
if seller is not None and seller.password == password:
uid = seller.key().id()
if remember_me:
session['sid'] = seller.key().id()
else:
session.set_quick('sid', seller.key().id())
self.redirect("/list-transactions")
elif user_group == 'buyer':
buyer = Buyer.all().filter('email = ', email).get()
print buyer.password
print password
if buyer is not None and buyer.password == password:
uid = buyer.key().id()
if remember_me:
session['bid'] = buyer.key().id()
else:
session.set_quick('bid', buyer.key().id())
self.redirect("/")
def get(self):
session = get_current_session()
session.terminate()
if users.get_current_user():
self.redirect(users.create_logout_url("/"))
else:
self.redirect("/")
def get(self):
session = get_current_session()
frob = self.request.get('frob')
if not frob:
self.response.out.write("no frob")
return
nickname = session.get("nickname", 0)
if not nickname:
self.response.out.write("no nickname")
return
userinfo = UserInfo.gql("WHERE nickname=:1", nickname).get()
if not userinfo:
self.response.out.write("no user")
return
flickr_api_key = userinfo.flickr_api_key
flickr_api_secret = userinfo.flickr_api_secret
flickr = flickrapi.FlickrAPI(
flickr_api_key,
flickr_api_secret,
store_token=False)
try:
token = flickr.get_token(frob)
e = TokenEntity.gql("WHERE nickname=:1", nickname).get()
if not e:
e = TokenEntity()
e.username = nickname
e.token = token
e.put()
#session['flickr_token'] = token
except Exception as e:
print "Unexpected error:", e.message
self.redirect('/setting')
def get(self):
if is_logged_in() == False:
self.showLogin()
return
session = get_current_session()
oauth_data = session.get("oauth_data")
api = get_twitter_api()
friends_ids = api.friends_ids()
cur_page = 1 if "page" not in self.request.GET else int(self.request.GET["page"])
page_ids = []
for i in range((cur_page - 1) * 100, min(cur_page * 100, len(friends_ids)) - 1):
page_ids.append(friends_ids[i])
friends = api.lookup_users(page_ids)
friends = sorted(
friends, key=lambda u: datetime.datetime(1, 1, 1) if hasattr(u, "status") == False else u.status.created_at
)
template_values = {
"oauth_data": oauth_data,
"friends_ids": page_ids,
"friends": friends,
"total_pages": len(friends_ids) / 100,
"cur_page": cur_page,
"has_list": "has_list" in session,
}
template = jinja_environment.get_template("index.html")
self.response.out.write(template.render(template_values))
def clear_election():
"""
Clears the election from admin session data.
"""
session = get_current_session()
if session.has_key('_election'):
del session['_election']
def plus_one_constraints(self, post_id):
logging.debug("put_post_plus_one")
if check_login(self):
session = get_current_session()
email = session["email"]
filters = {"post_id": post_id}
results, results_exist = datastore_results(
"PlusMinusConstraints",
filters=filters,
inequality_filters=None,
order=None,
fetch_total=1,
offset=0,
mem_key=None,
)
points = 0
if results_exist:
for result in results:
points = result.points
# print points
if points > 0:
return False
else:
return True
else:
self.redirect("/")
def post(self):
### Session verification code ###
session = get_current_session()
try:
if not session['key'] or session['key'] == '':
self.redirect('/?exception=NoSession')
except KeyError:
self.redirect('/?exception=NoSession')
#################################
receipient = self.request.get('receipient')
title = self.request.get('title')
body = self.request.get('body')
for receipients in User.all().filter("nick =", receipient).run(limit=1):
receipient_key = str(receipients.key())
try:
newmessage = Message()
newmessage.receipient = receipient_key
newmessage.sender = session['key']
newmessage.title = title
newmessage.body = body
newmessage.status = 0
newmessage.put()
self.redirect('/messages')
except UnboundLocalError:
self.redirect('/messages?exception=ReceipientNotFound')
except AttributeError:
self.redirect('/messages?exception=SenderNotFound')
def post(self):
session = get_current_session()
nickname = helper.sanitizeHtml(self.request.get('nickname'))
password = helper.sanitizeHtml(self.request.get('password'))
if len(nickname) > 1 and len(password) > 1:
password = User.slow_hash(password)
already = User.all().filter("lowercase_nickname =",
nickname.lower()).fetch(1)
if len(already) == 0:
user = User(nickname=nickname,
lowercase_nickname=nickname.lower(),
password=password,
about="")
user.put()
helper.killmetrics("Register", nickname, "do", session, "",
self)
random_id = helper.get_session_id(session)
if session.is_active():
session.terminate()
session.regenerate_id()
session['random_id'] = random_id
session['user'] = user
self.redirect('/')
else:
session[
'register_error'] = "Ya existe alguien con ese nombre de usuario <strong>" + nickname + "</strong>"
self.redirect('/login')
else:
session[
'register_error'] = "Porfavor escribe un username y un password"
self.redirect('/login')
def post(self):
self.session = get_current_session()
password = self.request.get('password')
page = self.request.get('whichPage')
if password == "gZ2BYJxfCY5SiyttS8zl":
# if password == "": # testing
que = db.Query(ScenarioData)
que.order("usernum").order("scenario").order("trialNumber")
d = que.fetch(limit=10000)
que2 = db.Query(User)
que2.order("usernum")
u = que2.fetch(limit=10000)
que3 = db.Query(FinalJudgmentData)
que3.order("usernum").order("scenario")
t = que3.fetch(limit=10000)
if page == 'scenario':
doRender(self, 'data.htm', {'d': d})
elif page == 'user':
doRender(self, 'userData.htm', {'u': u})
else:
doRender(self, 'ajaxTest.htm', {'t': t})
# elif page == 'causalTest':
# doRender(self, 'ajaxCausalTest.htm',
# {'c':c})
else:
doRender(self, 'dataloginfail.htm')
def get(self):
session = get_current_session()
if session.has_key('user'):
user = session['user']
self.response.out.write(template.render('templates/faq.html',
locals()))
def post(self, comment_id):
session = get_current_session()
if session.has_key('user'):
message = helper.sanitizeHtml(self.request.get('message'))
user = session['user']
if len(message) > 0:
try:
parentComment = db.get(comment_id)
comment = Comment(message=message,
user=user,
post=parentComment.post,
father=parentComment)
comment.put()
comment.post.remove_from_memcache()
vote = Vote(user=user, comment=comment, target_user=user)
vote.put()
Notification.create_notification_for_comment_and_user(
comment, parentComment.user)
self.redirect('/noticia/' + str(parentComment.post.key()))
except db.BadKeyError:
self.redirect('/')
else:
self.redirect('/responder/' + comment_id)
else:
self.redirect('/login')
def get(self, nickname):
page = helper.sanitizeHtml(self.request.get('pagina'))
perPage = 6
page = int(page) if page else 1
realPage = page - 1
if realPage > 0:
prevPage = realPage
# this is used to tell the template to include the topic
threads = True
session = get_current_session()
if session.has_key('user'):
user = session['user']
thread_user = User.all().filter('lowercase_nickname =',
nickname.lower()).fetch(1)
if len(thread_user) > 0:
thread_user = thread_user[0]
user_comments = Comment.all().filter(
'user ='******'-created').fetch(perPage,
realPage * perPage)
comments = helper.filter_user_comments(user_comments, thread_user)
if (page * perPage) < Comment.all().filter('user ='******'templates/threads.html', locals()))
else:
self.redirect('/')
def fetch_next_n_artists(self,n,session=None):
if not session:
session = get_current_session()
station = session['station']
# index bookkeeping
idx = session['idx']
# reset station
logging.info('playlist length:'+str(station.sorted_tracks_list.__len__()))
logging.info('beginning idx: '+str(idx))
max_idx = station.sorted_tracks_list.__len__() -1
if idx == max_idx:
idx = 0
new_idx = idx+n
if new_idx > max_idx:
new_idx = max_idx
logging.info('new_index: '+str(new_idx))
session['idx'] = new_idx
if new_idx > 0:
tracks = station.sorted_tracks_list[idx:new_idx]
elif new_idx == 0:
tracks = station.sorted_tracks_list
elif new_idx == -1:
tracks = []
to_send = [t['artist'] for t in tracks]
# store the tracks that have been listened to
listened_to = [t['key'] for t in tracks]
session['listened_to'] = listened_to
return to_send
def post(self):
url = self.request.get('url')
title = sanitizeHtml(self.request.get('title'))
message = sanitizeHtml(self.request.get('message'))
session = get_current_session()
if session.has_key('user') and len(title) > 0:
user = session['user']
# decide if its a message or a link, if its a link we need a try/catch around the save, the link might be invalid
if len(message) == 0:
try:
post = Post(url=url,
title=title,
message=message,
user=user)
post.put()
vote = Vote(user=user, post=post, target_user=post.user)
vote.put()
Post.remove_cached_count_from_memcache()
self.redirect('/noticia/' + str(post.key()))
except db.BadValueError:
self.redirect('/agregar')
else:
post = Post(title=title, message=message, user=user)
post.put()
post.url = "http://" + urlparse(
self.request.url).netloc + "/noticia/" + str(post.key())
post.put()
Post.remove_cached_count_from_memcache()
vote = Vote(user=user, post=post, target_user=post.user)
vote.put()
self.redirect('/noticia/' + str(post.key()))
else:
self.redirect('/')
def GET(self, jrequest, jresponse):
assert isinstance(jrequest, JsonRpcRequest)
assert isinstance(jresponse, JsonRpcResponse)
jresponse.setId()
consumer = oauth2.Consumer(TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET)
client = oauth2.Client(consumer)
resp, content = client.request(REQUET_TOKEN_URL)
if resp['status'] != '200':
raise OAuthError({
"consumer_key": TWITTER_CONSUMER_KEY,
"request token url": REQUET_TOKEN_URL
})
request_token_dict = dict(parse_qsl(content))
try:
request_token = request_token_dict["oauth_token"]
request_token_secret = request_token_dict["oauth_token_secret"]
except KeyError:
raise OAuthError(
"RedirectToAuthorizeUrl failed to obtain request token.")
authorize_url_param = urlencode([("oauth_token", request_token)])
authorize_url = AUTHORIZE_URL + "?" + authorize_url_param
jresponse.setResultValue("authorize_url_param", authorize_url_param)
jresponse.setResultValue("authorize_url", authorize_url)
jresponse.setResultValue("request_token", request_token)
jresponse.setResultValue("request_token_secret", request_token_secret)
jresponse.setResultValue("request_token_dict", request_token_dict)
session = gaesessions.get_current_session()
session[REQUEST_TOKEN_SESSION_KEY] = request_token
session[REQUEST_TOKEN_SECRET_SESSION_KEY] = request_token_secret
jresponse.setRedirectTarget(authorize_url)
def doLogin(username, password):
user = dbUser.User.gql('WHERE username = :username',
username=username).get()
if user is None:
return {
'status':
-1,
'message':
'The username or password you provided does not match our records.'
}
m = md5.new()
m.update(password)
## Passwords in dbUser is stored as MD5
passwordAsMD5 = m.hexdigest()
## Match passed password as MD5 with dbUser password
if user.password != passwordAsMD5:
return {
'status':
-1,
'message':
'The username or password you provided does not match our records.'
}
session = get_current_session()
session['user'] = dict(authenticated=True,
permissionLevel=user.permissionLevel)
# Let's try save a dict
#session['user_premissionLevel'] = user.premissionLevel
return {'status': 1, 'message': 'User logged in'}
def prefetch_posts_list(posts):
prefetch_refprops(posts, Post.user)
posts_keys = [str(post.key()) for post in posts]
# get user, if no user, all already_voted = no
session = get_current_session()
if session.has_key('user'):
user = session['user']
memcache_voted_keys = [
"vp_" + post_key + "_" + str(user.key()) for post_key in posts_keys
]
memcache_voted = memcache.get_multi(memcache_voted_keys)
memcache_to_add = {}
for post in posts:
logging.info("Got a post")
vote_value = memcache_voted.get("vp_" + str(post.key()) + "_" +
str(user.key()))
if vote_value is not None:
post.prefetched_already_voted = vote_value == 1
else:
vote = Vote.all().filter("user ="******"post =", post).fetch(1)
memcache_to_add["vp_" + str(post.key()) + "_" +
str(user.key())] = len(vote)
post.prefetched_already_voted = len(vote) == 1
if memcache_to_add.keys():
memcache.add_multi(memcache_to_add, 3600)
else:
for post in posts:
post.prefetched_already_voted = False
def get(self):
session = get_current_session()
if session.has_key('user'):
user = session['user']
page = helper.sanitizeHtml(self.request.get('pagina'))
perPage = 10
page = int(page) if page else 1
realPage = page - 1
inboxAll = True
if realPage > 0:
prevPage = realPage
if (page * perPage) < Notification.all().filter(
"target_user ="******"target_user ="******"-created").fetch(perPage, perPage * realPage)
prefetch.prefetch_refprops(notifications, Notification.post,
Notification.comment,
Notification.sender_user)
self.response.out.write(
template.render('templates/notifications.html', locals()))
else:
self.redirect('/login')
def get(self):
a_c = self.request.get('code')
logging.warn("Code: %s" % a_c)
ac_payload = {
'code': a_c,
'client_id': endpoints.CLIENT_ID,
'client_secret': endpoints.CLIENT_SECRET,
'redirect_uri': endpoints.REDIRECT_URI,
'grant_type': 'authorization_code'
}
encoded_payload = urllib.urlencode(ac_payload)
logging.info('encoded payload: %s' % encoded_payload)
ac_result = json.loads(
urlfetch.fetch(url=endpoints.CODE_ENDPOINT,
payload=encoded_payload,
method=urlfetch.POST,
headers={
'Content-Type':
'application/x-www-form-urlencoded'
}).content)
logging.info('auth code exchange result: %s' % ac_result)
a_t = ac_result['access_token']
if not validate_access_token(a_t):
self.error(400)
session = get_current_session()
session.regenerate_id()
session['access_token'] = a_t
self.redirect('/profile')
def get_twitter_api():
session = get_current_session()
oauth_data = session.get("oauth_data")
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(oauth_data["oauth_token"], oauth_data["oauth_token_secret"])
api = tweepy.API(auth)
return api
def get(self):
session = get_current_session()
isLogin = session.get('isLogin', False)
isAdmin = session.get('isAdmin', False)
isSystemAdmin = session.get('isSystemAdmin', False)
isMember = session.get('isMember', False)
memberName = session.get('memberName', False)
template_value = { }
if isLogin:
if isAdmin:
template_value['isAdmin'] = True
elif isSystemAdmin:
template_value['isSystemAdmin'] = True
elif isMember:
template_value['isMember'] = True
template_value['memberName'] = memberName
path = os.path.join(os.path.dirname(__file__), 'templates', 'index.html')
else:
path = os.path.join(os.path.dirname(__file__), 'templates', 'login.html')
self.response.out.write(template.render(path, template_value))
def get(self,post_id):
session = get_current_session()
if session.has_key('user'):
user = session['user']
try:
post = Post.all().filter('nice_url =', helper.parse_post_id( post_id ) ).get()
if post == None: #If for some reason the post doesn't have a nice url, we try the id. This is also the case of all old stories
post = db.get( helper.parse_post_id( post_id ) )
comments = Comment.all().filter("post =", post.key()).order("-karma").fetch(1000)
comments = helper.order_comment_list_in_memory(comments)
prefetch.prefetch_comment_list(comments)
display_post_title = True
prefetch.prefetch_posts_list([post])
if helper.is_json(post_id):
comments_json = [c.to_json() for c in comments if not c.father_ref()]
if(self.request.get('callback')):
self.response.headers['Content-Type'] = "application/javascript"
self.response.out.write(self.request.get('callback')+'('+simplejson.dumps({'post':post.to_json(),'comments':comments_json})+')')
else:
self.response.headers['Content-Type'] = "application/json"
self.response.out.write(simplejson.dumps({'post':post.to_json(),'comments':comments_json}))
else:
self.response.out.write(template.render('templates/post.html', locals()))
except db.BadKeyError:
self.redirect('/')
def post(self, post_id):
session = get_current_session()
if session.has_key('user'):
message = helper.sanitizeHtml(self.request.get('message'))
user = session['user']
if len(message) > 0:
try:
post = Post.all().filter(
'nice_url =', helper.parse_post_id(post_id)).get()
if post == None: #If for some reason the post doesn't have a nice url, we try the id. This is also the case of all old stories
post = db.get(helper.parse_post_id(post_id))
post.remove_from_memcache()
comment = Comment(message=message, user=user, post=post)
comment.put()
vote = Vote(user=user, comment=comment, target_user=user)
vote.put()
Notification.create_notification_for_comment_and_user(
comment, post.user)
self.redirect('/noticia/' + post_id)
except db.BadKeyError:
self.redirect('/')
else:
self.redirect('/noticia/' + post_id)
else:
self.redirect('/login')
def get(self):
session = get_current_session()
try:
email = session['email']
permissions_list = session['permissions_list']
except:
self.redirect("/authentication?destination=/invite")
return
if not email and permissions_list:
self.redirect("/authentication?destination=/invite")
return
if not any("Administrator" in s for s in permissions_list):
self.redirect("/authentication?destination=/invite&message=You do not have permission to view this page, if this is in error contact us")
return
login_url = users.create_login_url("/invite")
user = users.get_current_user()
if not user:
self.response.out.write("<a href='%s'>Log in via google</a>" % login_url)
return
data = {
"message": self.request.get("message"),
"permission_dict": settings.PERMISSIONS_DICT,
"logged_in": check_login(),
}
self.response.out.write(template.render(get_template_path(TEMPLATE_URI), data))
def post(self):
url = self.request.get('url')
title = sanitizeHtml(self.request.get('title'))
message = sanitizeHtml(self.request.get('message'))
session = get_current_session()
if session.has_key('user') and len(title) > 0:
user = session['user']
# decide if its a message or a link, if its a link we need a try/catch around the save, the link might be invalid
if len(message) == 0:
try:
post = Post(url=url,title=title,message=message, user=user)
post.put()
vote = Vote(user=user, post=post, target_user=post.user)
vote.put()
self.redirect('/noticia/' + str(post.key()));
except db.BadValueError:
self.redirect('/agregar')
else:
post = Post(title=title,message=message, user=user)
post.put()
post.url = "http://" + urlparse(self.request.url).netloc + "/noticia/" + str(post.key())
post.put()
vote = Vote(user=user, post=post, target_user=post.user)
vote.put()
self.redirect('/noticia/' + str(post.key()));
else:
self.redirect('/')
def can_edit(self):
session = get_current_session()
if session.has_key("user"):
user = session["user"]
if self.user.key() == user.key() or user.admin:
return True
return False
def get(self):
enforce_login(self)
session = get_current_session()
account_key = session.get("account")
account = None if account_key is None else db.get(account_key)
template_values = {
"current_user":
get_current_session().get("account"),
"account":
account,
"fbName":
"n/a" if account.facebookInfo is None else json.loads(
account.facebookInfo)["name"]
}
path = os.path.join(os.path.dirname(__file__), 'html/account.html')
self.response.out.write(template.render(path, template_values))
def get_station_from_session(self): session = get_current_session() try: station = session['station'] return station except KeyError,e: raise self.SessionError(e)
def get(self):
confirm = self.request.get('confirm')
if confirm != "true":
return
epub_key = self.request.get('key')
epub = db.get(epub_key)
account = get_current_session().get("account")
entry = model.LibraryEntry.all().filter("epub = ", epub).filter(
"user ="******"private", "public"]:
index = search.Index(indexName)
opts = search.QueryOptions(limit=1000, ids_only=True)
query = search.Query(query_string="book:%s" % epub_key,
options=opts)
docs = index.search(query)
for doc in docs:
index.remove(doc.doc_id)
blobstore.delete(epub.blob.key())
db.delete(epub)
self.redirect('/list')
else:
self.response.out.write("Not permitted")
def post(self):
session = get_current_session()
if session.get('isLogin', False) == False:
account = self.request.get('a')
password = self.request.get('p')
session['isLogin'] = True
if account == self.ADMIN_ACT and password == self.encode(
self.ADMIN_PWD):
session['isAdmin'] = True
session['memberName'] = "血盟管理員"
self.response.out.write(status_code.LOGIN_SUCCESS)
elif account == self.SYSTEM_ACT and password == self.encode(
self.SYSTEM_PWD):
session['isSystemAdmin'] = True
session['memberName'] = "系統管理員"
self.response.out.write(status_code.LOGIN_SUCCESS)
elif MemberOperation.IsMember(account, password):
if MemberOperation.IsValidation(account):
session['isMember'] = True
session['memberName'] = account
self.response.out.write(status_code.LOGIN_SUCCESS)
else:
session['isLogin'] = False
self.response.out.write(status_code.ACCOUNT_IS_NOT_VALID)
else:
session['isLogin'] = False
self.response.out.write(status_code.ACCOUNT_OR_PASSWORD_WRONG)
else:
self.response.out.write(status_code.ALREADY_LOGIN)
def get(self):
path = 'member_signup.html'
session = get_current_session()
email = session['email'] if 'email' in session else None
form_url = blobstore.create_upload_url("/api/members/finish_signup")
template_values = {'network' : self['network'], 'image' : self['image'], 'form_url' : form_url, 'email': email}
self.write(self.get_rendered_html(path, template_values), 200)
def get(self):
### Session verification code ###
session = get_current_session()
try:
if not session['key'] or session['key'] == '':
self.redirect('/?exception=NoSession')
except KeyError:
self.redirect('/?exception=NoSession')
#################################
unread = UnreadMessages(session['key'])
receipient = self.request.get('receipient')
if not receipient:
self.redirect('/dashboard?exception=MissingMandatoryVariable')
else:
validuser = False
for receipients in User.all().filter("nick =", receipient).run(limit=1):
validuser = True
if not validuser:
self.redirect('/dashboard?exception=UnknownReceipient')
else:
template_values = {
'pagename': 'newmessage',
'receipient': receipient,
'unread': unread,
}
path = os.path.join(os.path.dirname(__file__), 'templates/newmessage.html')
self.response.out.write(template.render(path, template_values))
def get(self):
path = 'list_member.html'
company_id = int(str(self['company_id']))
c = Company.get_by_id(company_id)
if not c:
self.write('no company')
return
session = get_current_session()
user_id = session['me_email']
access_type = self.get_access_type(c, user_id)
q = CompanyMember.all().ancestor(c)
users = [{'name': User.get_by_key_name(company_member.user_id).name, 'influence': company_member.influence, 'expertise': company_member.expertise} for company_member in q]
donuts = 2
donuts -= 1
donut_size = 80-(5*donuts)
score_font_size = 40-(3*donuts)
tooltip_font_size = 14-donuts
template_values = {'company_id': company_id,
'name': c.name,
'influence': c.influence_avg if c.influence_avg else 0.0,
'expertise': c.expertise_avg if c.expertise_avg else [],
'users': users,
'access_type': access_type,
'admin_id': user_id,
'donut_size': donut_size,
'score_font_size': score_font_size,
'tooltip_font_size': tooltip_font_size}
self.write(self.get_rendered_html(path, template_values), 200)
def isUserAuthenticated():
session = get_current_session()
if session and 'user' in session and session['user'][
'authenticated'] == True:
return True
else:
return False
def home(request):
if not helper.Helper().isLoggedin(request):
return redirect('login')
session = get_current_session()
email = request.session.data.keys()[0]
name = session[email].name
# get all the resources
q = models.Resource.all()
results = q.run()
ids = []
resources_with_ID = []
myresources_with_ID = []
for resource in results:
# get all the reservations of this resource.
curr_rsvs = db.GqlQuery("SELECT * FROM Reservation where resource= :1",
str(resource.key().id_or_name())).run()
latest = datetime.datetime(1, 1, 1, 1, 1, 1)
# get the latest reservation time
for rsv in curr_rsvs:
if rsv.reservetime > latest:
latest = rsv.reservetime
resources_with_ID.append(
[resource.key().id_or_name(), resource, latest])
if resource.owner == email:
myresources_with_ID.append([resource.key().id_or_name(), resource])
# sort according to the latest reservation time
resources_with_ID.sort(key=lambda x: x[2], reverse=True)
for temp in resources_with_ID:
if temp[2] == datetime.datetime(1, 1, 1, 1, 1, 1):
temp[2] = 'not reserved'
q = db.GqlQuery("SELECT * FROM Reservation where user= :1", email)
reservations = q.run()
reservations_with_ID = []
for reservation in reservations:
# not show dated reservations
curr_time = datetime.datetime.now() - datetime.timedelta(hours=5)
et = reservation.starttime + datetime.timedelta(
hours=reservation.duration)
if curr_time > et:
continue
# get the resource name of this reservation
q = db.GqlQuery(
"SELECT * FROM Resource where __key__ = KEY('Resource', :1)",
int(reservation.resource))
resource = q.get()
reservations_with_ID.append([
reservation.key().id_or_name(), resource.name,
reservation.reservetime
])
reservations_with_ID.sort(key=lambda x: x[2], reverse=True)
return render_to_response(
'user.html', {
'loggedin': True,
'self_flag': True,
'name': name,
'resources': resources_with_ID,
'myresources': myresources_with_ID,
'reservations': reservations_with_ID
})
def addAudioCVToDB(self, response):
session = get_current_session()
state = session.get('state', "not present")
if (state == "RecordCV"):
logging.info("url %s", self.request.get('data'))
resumeURL = urllib2.unquote(self.request.get('data'))
if resumeURL == "":
resumeURL = "http://tfhackday.appspot.com/static/audionotfound.wav"
candidateId = random.randint(1, 10000)
candidate = Candidate(key_name=str(candidateId),
candidateId=str(candidateId),
date=datetime.datetime.now().date(),
resumelink=db.Link(resumeURL),
status="InScreen")
candidate.put()
htmlBody = "<html> <body> Dear Hiring Manager: When: Friday, January 06, 2012 11:00 AM-11:30 AM (UTC+05:30) Chennai, Kolkata, Mumbai, New Delhi. Where: Banner (on phone) Please let us know if you have any questions. The HR Team "
htmlBody += "<a href='http://tfhackday.appspot.com/AcceptCandidate?id="
htmlBody += str(candidateId) + "'>ACCEPT</a><br><br> "
htmlBody += "<a href='http://tfhackday.appspot.com/RejectCandidate?id=" + str(
candidateId) + "'> REJECT</a> </body></html>"
mail.send_mail(
sender="TribalHelpDesk.com Support <*****@*****.**>",
to=
"HR Desk <*****@*****.**>, Vipul Jhawar <*****@*****.**>",
subject="Candidate ID:" + str(candidateId) + "Interview Schedule",
body="My Body",
html=htmlBody)
def can_edit(self):
session = get_current_session()
if session.has_key('user'):
user = session['user']
if self.user.key() == user.key() or user.admin:
return True
return False
def loginCheck(self,strict):
''' for merchants
This is a general-purpose login checking function
in "strict" mode (strict=True), this script will bounce to the login page if not logged in
if strict=False, headers will be returned that indicate the user isn't logged in, but no bouncing'''
session = get_current_session()
logging.debug(session)
if session.has_key('loggedIn') == False or session['loggedIn'] == False:
if strict == True:
#not logged in, bounce to login page
logging.info('Not logged in. . .Bouncing!')
self.redirect('/merchants/login')
else:
logging.info('Not logged in. . .Sending back headerData')
headerData = {
'loggedIn' : False
}
return headerData
elif session.has_key('loggedIn') == True and session['loggedIn'] == True:
#logged in, grab the useful bits
#this is a hack. . . forgive meeee
uid = session['ownerID']
headerData = {
'loggedIn' : session['loggedIn'],
'ownerID' : uid
}
#return user metadata.
return headerData
return
def get(self):
page = helper.sanitizeHtml(self.request.get('pagina'))
perPage = 20
page = int(page) if page else 1
realPage = page - 1
if realPage > 0:
prevPage = realPage
if (page * perPage) < Post.get_cached_count():
nextPage = page + 1
session = get_current_session()
if session.has_key('user'):
user = session['user']
posts = Post.all().order('-created').fetch(perPage, perPage * realPage)
prefetch.prefetch_posts_list(posts)
i = perPage * realPage + 1
for post in posts:
post.number = i
i = i + 1
if helper.is_json(self.request.url):
posts_json = [p.to_json() for p in posts]
if (self.request.get('callback')):
self.response.headers[
'Content-Type'] = "application/javascript"
self.response.out.write(
self.request.get('callback') + '(' +
simplejson.dumps({'posts': posts_json}) + ');')
else:
self.response.headers['Content-Type'] = "application/json"
self.response.out.write(simplejson.dumps({'posts':
posts_json}))
else:
self.response.out.write(
template.render('templates/main.html', locals()))
def get(self):
session = get_current_session()
if session.has_key('user'):
user = session['user']
self.redirect('/logout')
else:
self.response.out.write(template.render('templates/login.html', locals()))
def respondWithMessage(handler, message):
template_values = {
"current_user": get_current_session().get("account"),
"message": message
}
path = os.path.join(os.path.dirname(__file__), 'html/message.html')
handler.response.out.write(template.render(path, template_values))
