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 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))