def test_read_user(self): print "__________read user test_________" u = User(name="ujlikes") u = u.findByName() print u print u.salt print u.password_sha
def post(self): name = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') error = {} # let's check if user already exists user = User.by_name(name) if user: error['name'] = "User already exists" # let's check if a name it's been introduced and its format name_ok = name and validate(name, '^[a-zA-Z0-9_-]{3,20}$') if not name_ok: error['name'] = "That's not a valid user name" # let's check there is a password and its format password_ok = password and validate(password, '^.{3,20}$') if not password_ok: error['password'] = "******" # let's check the verify password is the same as the password if verify != password: error['verify'] = "Your passwords didn't match" # not needed, but if there is an email let's check its format if email != '': if not validate(email, '^[\S]+@[\S]+.[\S]+$'): error['email'] = "That's not a valid email" # if everything went right, let's introduce our new friend if not error: pw_hash = make_pw_hash(name, password) user = User(name=name, password=pw_hash, email=email) user.put() # now we logged the user in self.login(user) self.redirect('/') # if something went wrong, let's render again showing the error self.render('sign-up.html', name=name, email=email, error=error)
def test_read_user(self): print '__________read user test_________' u = User(name='ujlikes') u = u.findByName() print u print u.salt print u.password_sha
def post(self): self.response.headers['Content-Type'] = 'text/plain; charset=utf-8' user = User() try: jsonUser = json.loads(self.request.body) user.parse(jsonUser) if user.isValid(): if user.isUnique(): user.created = datetime.today() user.save() # Save user in db! self.response.write('You are created!\n') else: self.response.write('We know you already.\n') # Trying to add notification ids. loaded_user = user.loadme() loaded_user_changed = False for reg_id in user.registration_ids: if reg_id not in loaded_user.registration_ids: loaded_user.registration_ids.append(reg_id) loaded_user_changed = True if loaded_user_changed: loaded_user.save() self.response.write('We updated your person.\n') self.response.write('Success!\n') else: self.response.write('Failed!\n') self.response.write('User not valid.\n') self.response.write(user.hash) self.response.write(user.type) except Exception, e: self.response.write('Failed!\n') self.response.write(e)
def fb_login(): if request.method != "POST": return "Error", 404 user = User.get_by_id(request.form["userID"]) response = {} response["status"] = "existing" if not user: user = User(id=request.form["userID"], userID=request.form["userID"], name=request.form["first_name"] + " " + request.form["last_name"], email=request.form["email"], rating=2.5, number_ratings=1) user.put() response["status"] = "new" if Admin.get_by_id(user.key.id()): session["admin"] = True else: session["admin"] = False session['first_name'] = request.form["first_name"] session['last_name'] = request.form["last_name"] session['email'] = request.form["email"] logged_in(user) return json.dumps(response)
def post(self): self.username = self.request.get("username") self.password = self.request.get("password") self.verify = self.request.get("verify") self.email = self.request.get("email") self.signup_params = dict(username = self.username, email = self.email) form_error = False if not validusername(self.username): self.signup_params['uname_error'] = "That's not a valid username!" form_error = True if not validemail(self.email): self.signup_params['email_error'] = "That's not a valid email!" form_error = True if not validpw(self.password): self.signup_params['pw_error'] = "That's not a valid password!" form_error = True elif self.password != self.verify: self.signup_params['verify_error'] = "Your passwords don't match!" form_error = True if form_error: self.render('signup.html', **self.signup_params) else: user = User.get_by_name(self.username) if user: self.signup_params['uname_error'] = "That username already exists" self.render('signup.html', **self.signup_params) else: new_user = User.register(self.username, self.password, self.email) new_user.put() self.set_login_cookie(new_user) self.done()
def test_create_user(self): print '__________create user test_________' u = User(name='testbli', password_sha='testbli', email='*****@*****.**', activationCode='111') u.create()
def loadUserDataById(self, user_id): self.transactions.clear() self.categories.clear() self.family_users.clear() conn = pymysql.connect(host=HOST, user=USER, password=PASSWORD, db=DB, charset='utf8') cursor = conn.cursor() sql = "SELECT * FROM `users` WHERE `ID` = '%s'" % (user_id) cursor.execute(sql) result = cursor.fetchone() self.user = User(result[0], result[1], result[2], result[3], result[4], result[5]) sql = "SELECT * FROM `families` WHERE `ID` = '%d'" % ( self.user.family_id) cursor.execute(sql) result = cursor.fetchone() self.family = Family(result[0], result[1], result[2], result[3], result[4]) sql = "SELECT * FROM `categories` WHERE `Owner_ID` = '%d' OR `Owner_ID` = '0'" % ( self.user.family_id) cursor.execute(sql) result = cursor.fetchall() for s in result: self.categories.append(Category(s[0], s[1], s[2])) sql = "SELECT * FROM `users` WHERE `Family_ID` = '%d'" % ( self.user.family_id) cursor.execute(sql) result = cursor.fetchall() for s in result: self.family_users.append(User(s[0], s[1], s[2], s[3], s[4], s[5])) sql = "SELECT * FROM `transactions` WHERE `Family_ID` = '%d' ORDER BY `Datetime` DESC" % ( self.user.family_id) cursor.execute(sql) result = cursor.fetchall() for s in result: if self.family.safemode == 1 and self.user.status == 3: b_user = self.getFamilyUserById(s[4]) if b_user.status != 3: continue else: self.transactions.append( Transaction(s[0], s[1], s[2], s[3], s[4], s[5], s[6])) else: self.transactions.append( Transaction(s[0], s[1], s[2], s[3], s[4], s[5], s[6])) cursor.close() conn.close()
def test_give_me_the_money_should_return_available_funds_from_all_accounts( self): # account_1 = Mock() # type(account_1).balance = PropertyMock(return_value=50) # account_2 = Mock() # type(account_2).balance = PropertyMock(return_value=100) account_1 = Mock() account_1.get_balance.return_value = 50 account_2 = Mock() account_2.get_balance.return_value = 100 user = User("Janusz", 40, [account_1, account_2]) self.assertEqual(user.give_me_the_money(), 150)
def addUser(request): # syncWithDB() global users if 'name' in request.args: name = str(request.args['name']) else: return "Error: No name field provided. Please specify an name." if request.method == 'GET': """return the information for some user""" user = User(name) users.append(user) user.saveToDB() return "User created"
def view_me(): user = User.get_by_id(session["user_id"]) if request.method == "POST": return render_template("tsktsk.html") review = Review(rating=int(request.form["rating"]), reason=request.form["reason"], user=user_id, reviewer=session["user_id"], flagged=False) review.put() update_user_rating(user_id, int(request.form["rating"])) sold_offers = [] sold_items = Item.query(Item.seller_id == session["user_id"], Item.sold == True) for item in sold_items: temp_offer = Offer.query(Offer.item == item.key.id()).get() sold_offers.append(temp_offer) purchased_offers = Offer.query(Offer.confirmed == True, Offer.bidder == session["user_id"]) notifications = Notification.query( Notification.user == session["user_id"]).order(-Notification.time) return render_template("me.html", user=user, sold_offers=sold_offers, purchased_offers=purchased_offers, notifications=notifications)
def update_user_rating(user_id, rating): user = User.get_by_id(user_id) user.number_ratings += 1.0 user.rating = user.rating / ( (user.number_ratings - 1.0) / user.number_ratings) + rating / (user.number_ratings) user.put()
def add_item(self): State[STATE_KEY_ELEMENT] = None self.add_edit_dialog.init_value() if self.add_edit_dialog.exec(): try: user = User.create({ 'is_admin': self.add_edit_dialog.isAdmin.isChecked(), 'name': self.add_edit_dialog.userName.text(), 'login': self.add_edit_dialog.userLogin.text(), 'password': self.add_edit_dialog.userPassword.text(), }) except Exception as e: # todo: хорошо бы конечно оповщение о том что пошло не так - но не в этой жизни... GLog.error("ui.UsersForm.add_item :: error :%s" % e) return row_number = self.table.rowCount() self.table.insertRow(row_number) self.table.setItem(row_number, 0, QTableWidgetItem(str(user.ID))) self.table.setItem(row_number, 1, QTableWidgetItem(user.name)) self.table.setItem(row_number, 2, QTableWidgetItem(user.login)) self.table.setItem(row_number, 3, QTableWidgetItem('Да' if user.admin else 'Нет'))
def registration_action(): page_title = 'Регистрация' error = None # Проверяем данные if not request.form['email']: error = 'Требуется ввести Email' if not request.form['password']: error = 'Требуется ввести пароль' if not request.form['password2']: error = 'Требуется ввести повтор пароля' if request.form['password'] != request.form['password2']: error = 'Пароли не совпадают' if Storage.is_user_registred(request.form['email']): error = 'Пользователь с таким email уже зарегистрирован' pattern_password = re.compile(r'^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!#%*?&]{8,20}$') if not pattern_password.match(request.form['password']): error = 'Пароль должен быть от 8-ми до 20 символов, содержать хотя бы одно число, ' \ 'хотя бы одну латинскую букву в нижнем и верхнем регистре, хотя бы один спец символ' # В случае ошибки рендерим тот же шаблон, но с текстом ошибки if error: return render_template('pages/registration.html', page_title=page_title, error=error) # Добавляем пользователя Storage.add_user(User(None, request.form['email'], request.form['password'])) # Перенаправляем на главную return redirect(url_for('home'))
def registration_action(): page_title = 'Регистрация | Auth Example' error = None # Проверяем данные if not request.form['email']: error = 'Требуется ввести Email' if not request.form['password']: error = 'Требуется ввести пароль' if not request.form['password2']: error = 'Требуется ввести повтор пароля' if request.form['password'] != request.form['password2']: error = 'Пароли не совпадают' # В случае ошибки рендерим тот же шаблон, но с текстом ошибки if error: return render_template('pages/registration.html', page_title=page_title, error=error) # Добавляем пользователя Storage.add_user( User(None, request.form['email'], request.form['password'])) # Делаем вид, что добавление всегда без ошибки # Перенаправляем на главную return redirect(url_for('home'))
def get(self): cur_user = users.get_current_user() if cur_user: existing_user = User.find(cur_user) if not existing_user.get(): # New user user_entity = User(user = cur_user) user_entity.put() greeting = ('Welcome! %s (<a href = "%s">sign out</a>)' % (cur_user.nickname(), users.create_logout_url('/login'))) else: greeting = ('Welcome back, %s (<a href = "%s">sign out</a>)' % (cur_user.nickname(), users.create_logout_url('/login'))) else: greeting = ('<a href="%s">Sign in</a>' % users.create_login_url("/login")) self.response.out.write("<html><body>%s</body></html>" % greeting)
def login(): fields = [] fields.append( Field(name="email", title="Email", the_type='email', identifier='email', placeholder="Email")) fields.append( Field(name='password', title="Password", the_type="password", identifier='password', placeholder='Password')) title = "Login " form = Form(fields=fields, title=title) if request.method == 'GET': return render_template('login.html', login_form=form) try: user = User.get_by_id(request.form['email']) if user: if user.password == request.form['password']: print "pop" return logged_in(user) else: form.error = "User or Password was Incorrect" return render_template('login.html', login_form=form) else: form.error = "User or Password was Incorrect" return render_template('login.html', login_form=form) except KeyError as err: form.error = "Email or Password Was Not Filled Out Correctly" return render_template('login.html', login_form=form)
def find_and_enrich_following_for_user(username): friend_value = "#FRIEND#{}".format(username) resp = dynamodb.query( TableName="quick-photos", IndexName="InvertedIndex", KeyConditionExpression="SK = :sk", ExpressionAttributeValues={":sk": { "S": friend_value }}, ScanIndexForward=True, ) keys = [{ "PK": { "S": "USER#{}".format(item["followedUser"]["S"]) }, "SK": { "S": "#METADATA#{}".format(item["followedUser"]["S"]) }, } for item in resp["Items"]] friends = dynamodb.batch_get_item( RequestItems={"quick-photos": { "Keys": keys }}) enriched_friends = [ User(item) for item in friends["Responses"]["quick-photos"] ] return enriched_friends
def check_login_status(self): cookie = self.get_cookie('user_id') if cookie and verify_cookie(cookie): user_id = int(cookie.split('|')[0]) user = User.get_by_id(user_id) else: user = None return user
def create_admins(): users = User.query() for user in users: admin = Admin(id=user.key.id(), admin_id=user.key.id()) admin.put() return "Admin Created"
def unfollow(twitter, handle): user = User.all().filter('screen_name =', handle).get() if user is None: logging.warning('User %s sent a stop DM but is not on the datastore' % (handle, )) return user.active = False user.put() send_stop_dm(twitter, handle)
def create(self) -> User: return User( username=slugify(self.fake.name()), email=self.fake.email(), password=self.fake.password(), first_name=self.fake.first_name(), last_name=self.fake.last_name(), phone=self.fake.last_name() )
def get(self): userid_cookie = self.request.cookies.get('userid') if not userid_cookie: self.response.write("Welcome Stranger!") else: userid = int(userid_cookie.split("|")[0]) user = User.get_by_id(userid) if self.hasher.check_secure_val(userid_cookie): self.response.write("Welcome "+user.username+" !")
def signin(self,email,passwd): email = email.lower() passwd=tomd5(passwd) result = db.select(TABLE_USER,where='email=$email',vars=locals()) if result: r=result[0] user = User() user.email=r['email'] user.nickname=r['nickname'] user.cellphone=r['cellphone'] user.status = r['status'] pwindb=r['passwd'] #TODO compare char by char? if pwindb == passwd: return user return None
def dm(self, bodies): text_body = [body.decode() for type, body in bodies if type == 'text/plain'][0] sender = re.search('twitter.com/([^ \n\r\t]+)', text_body).groups()[0] text_lines = text_body.split('\n') dm_lines = [] for line in text_lines: if line.find(sender) == -1: dm_lines.append(line) else: break dm_body = ''.join(dm_lines).strip() \ .replace('\n', ' ') \ .replace('\t', ' ') \ .replace('\r', ' ') twitter = login_twitter_bot() logging.debug(dm_body) if dm_body == STOP_KEYWORD: unfollow(twitter, sender) elif dm_body == RESTART_KEYWORD: refollow(twitter, sender) elif dm_body == HELP_KEYWORD: send_help_dm(twitter, sender) elif dm_body == WHERE_KEYWORD: user = User.all().filter('screen_name =', sender).get() if user is None: logging.warning('An unknown user sent a DM (%s)' % (sender, )) else: send_where_dm(twitter, user) elif dm_body == ABOUT_KEYWORD: send_about_dm(twitter, sender) elif dm_body == FORECAST_KEYWORD: send_forecast_dm(twitter, sender) else: user = User.all().filter('screen_name =', sender).get() if user is None: logging.warning('An unknown user sent a DM (%s)' % (sender, )) else: relocate(twitter, dm_body, user) user.put()
def send_forecast_dm(twitter, handle): location = None try: location = User.all().filter('screen_name =', handle).get().location except: logging.error('User or location not found!') return date = location.next_rain_datetime + datetime.timedelta(hours=location.timezone) twitter.send_direct_message(screen_name=handle, text='Pronosticado lluvia para el '+str(date.day)+' a las '+str(date.hour)) logging.debug('User %s asked for forecast. Sent.'%(handle, ))
def signup(): return login() fields = [] fields.append( Field(name="email", title="Email", the_type='email', identifier='email', placeholder="Email")) fields.append( Field(name="name", title="Name", the_type='name', identifier='name', placeholder="Name")) fields.append( Field(name='password', title="Password", the_type='password', identifier='password', placeholder='Password')) title = "Signup" form = Form(fields=fields, title=title) if request.method == 'GET': return render_template('signup.html', signup_form=form) try: exists = User.get_by_id(request.form['email']) if exists: form.error = "Email Taken" return render_template('signup.html', signup_form=form) else: user = User(email=request.form['email'], id=request.form['email'], password=request.form['password'], name=request.form['name']) user.put() return signed_up(user) except KeyError as err: form.error = "Email or Password Was Not Filled Out Correctly" return render_template('signup.html', signup_form=form)
def send_success_dm(twitter, handle): location = None try: location = User.all().filter('screen_name =', handle).get().location except: logging.error("Error getting %s's data."%(handle, )) return text = "Te avisaremos cuando llueva por tus pagos, en %s! Cancela el servicio mandando '%s'." %(location.name, STOP_KEYWORD) twitter.send_direct_message(screen_name=handle, text=text) logging.debug("Successfully found %s" % (handle, ))
def post(self): eid = self.request.get('id', default_value='') self.response.write('<h1>'+eid+'</h1>') key = self.request.get('key', default_value='') if eid is not None and eid != '': msg = Message.get_by_id(int(eid)) elif key is not None and key != '': msg = ndb.Key(urlsafe=key).get() else: self.err('Neither id or key is passed!\n') return if msg is None: self.err('Loading message failed!\n') return # Send to phone notification! usr = User() usr.hash = msg.recipient usr = usr.loadme() if usr is None: self.err('User-Recipient not found!'); return data = {'type': 'message', 'sender': msg.sender} notfication = GCM('AIzaSyD-z2JuoBkD51RyRHG6ULoWX2gE84apP7M') response = notfication.json_request(registration_ids=usr.registration_ids, data=data, collapse_key=None, delay_while_idle=False, time_to_live=None, retries=5) self.response.headers['Content-Type'] = 'application/json; charset=utf-8' self.debug(response) # Mark message as pushed. msg.pushed = datetime.now() msg.put()
def initialize(self, *args, **kwargs): webapp2.RequestHandler.initialize(self, *args, **kwargs) uid = self.read_sec_cookie('userid') # Debugging code #logging.debug('Read userid of {} from cookie'.format(uid)) #if uid: #t1 = User.by_id(int(uid)) #logging.debug('User.by_id({}) = {}'.format(uid, t1)) #t2 = uid and t1 #logging.debug('uid and User.by_id({}) = {}'.format(uid, t2)) self.user = uid and User.by_id(int(uid))
def get_active_user(): """ Inspects the session data to look up the currently logged in user. Returns a User instance if someone is logged in, or None otherwise. """ try: user_dict = load_from_session(SessionKeys.CURRENT_USER) user = User(**user_dict) return user except KeyError: return None
def find_user(self,username,password): if not username or not self.usernameregex.match(username) or not password or not self.passwordregex.match(password): return None query_result = User.query(User.username == username).fetch(1) if len(query_result)==0: return None user = query_result[0] password_input = hashlib.sha256(password).hexdigest() if not user.hashed_password == password_input: return None return user.key.id()
def get_user_by_id(id: int): """Найти пользователя по id :param id: идентификатор пользователя :type id: int :return: пользователь :rtype: User""" user_data = db.execute('SELECT * FROM users WHERE id=?', (id,)).fetchone() if user_data: return User(id=user_data[0], email=user_data[1], password=user_data[2]) else: return None
def defineUser( self, name, first, last, email, organization, identity_id=None, description=None, displayname=None, sshpubstring=None, url=None, docurl=None, ): ''' Defines a new User object for usage elsewhere in the API. :param str name: The unique VC3 username of this user :param str first: User's first name :param str last: User's last name :param str email: User's email address :param str organization: User's institutional affiliation or employer :return: User A valid User object :rtype: User ''' u = User(name=name, state='new', first=first, last=last, email=email, organization=organization, identity_id=identity_id, description=description, displayname=displayname, sshpubstring=sshpubstring, url=url, docurl=docurl) u.storenew = True self.log.debug("Creating user object: %s " % u) return u
def init_db(): db.connect(reuse_if_open=True) db.create_tables([File, FileState, User]) FileState.create(state="Загружается", r_accessible=False) FileState.create(state="Загружен") FileState.create(state="Кодируется", r_accessible=False) FileState.create(state="Закодирован") FileState.create(state="Удален", r_accessible=False, d_accessible=False) pkey = generate_key() u = User.create(auth_token=uuid4(), pkey=pkey) app.logger.info("First user: %s" % u.auth_token) db.commit()
def create_user(self, user: UserCreate) -> User: user_data = asdict(user) user_data.pop('password') return User( **user_data, id=random.randint(1, 100), transactions=[ Transaction(id=1, amount=Decimal(1000)), Transaction(id=2, amount=Decimal(2000)), Transaction(id=3, amount=Decimal(3000)), ], )
def fetch_user_and_photos(username): resp = dynamodb.query( TableName='quick-photos', KeyConditionExpression="PK = :pk AND SK BETWEEN :metadata AND :photos", ExpressionAttributeValues={ ":pk": { "S": "USER#{}".format(username) }, ":metadata": { "S": "#METADATA#{}".format(username) }, ":photos": { "S": "PHOTO$" }, }, ScanIndexForward=True) user = User(resp['Items'][0]) user.photos = [Photo(item) for item in resp['Items'][1:]] return user
def user(self, obj): user_id = obj.get('id', None) if user_id is None: raise MessageError("No user id provided.") try: return { "type": "user", "id": user_id, "user": User.from_id(self.session.db.users, user_id) } except ValueError as e: raise MessageError("No user found for id '%s'." % user_id)
def get(self): userid_cookie = self.request.cookies.get('userid') if userid_cookie and len(userid_cookie) > 0: userid = int(userid_cookie.split("|")[0]) user = User.get_by_id(userid) if not user: self.response.headers.add_header('Set-Cookie','userid=;Path=/') self.response.write("Welcome!") else: if self.hasher.check_secure_val(userid_cookie): self.response.write("Welcome "+user.username+" !") else: self.response.write("Welcome Cookie-less Stranger!")
def fake_item(environment="development"): """Create fake item.""" print green("Fake items") with rw_transaction() as session: user = User.get_mock_object() item = Item.get_mock_object() item.user_uuid = user.uuid print "Inserting user {}".format(user.to_primitive()) print "Inserting item {}".format(item.to_primitive()) model_user = ModelUser(**user.to_primitive()) model_item = ModelItem(**item.to_primitive()) session.add(model_user) session.add(model_item)
def get_user_by_email_and_password(email: str, passwordHash: str): """Найти пользователя по email и паролю :param email: электронная почта :type email: str :param passwordHash: хэш пароля :type passwordHash: str :return: пользователь :rtype: User """ user_data = db.execute('SELECT * FROM users WHERE email=?', (email,)).fetchone() if user_data and check_password_hash(user_data[2], passwordHash): return User(id=user_data[0], email=user_data[1], password=user_data[2]) else: return None
def get_user_by_email(email: str) -> User: """Найти пользователя по email :param email: имейл пользователя :type email: str :return: пользователь :rtype: User""" user_data = db.execute('SELECT * FROM users WHERE email=?', (email, )).fetchone() if user_data: return User(id=user_data[0], email=user_data[1], password=user_data[2]) else: return None
def post(self): username = self.request.get('username') password = self.request.get('password') verify = self.request.get('verify') email = self.request.get('email') c_username = self.check(username, "^[a-zA-Z0-9_-]{3,20}$") c_password = self.check(password, "^.{3,20}$") c_email = self.check(email,"^[\S]+@[\S]+\.[\S]+$") error = Error() user = getUser(username) if not user == None: error.name_error = "duplicate user name. please choose another." error.error = True if(password != verify): error.ver_error = "Password does not match" error.error = True if c_username == None: error.name_error = "Invalid Username" error.error = True if c_password == None: error.pwd_error = "Invalid Password" error.error = True if(email != "" and c_email == None): error.email_error = "Invalid email address" error.error = True if error.error: self.render_register(username, "", "", email,error) else : #save user in database user_class = USER if username == ADMINISTRATOR: user_class = ADMIN user = User(username=username, password=hash_pw(username,password), email=email, user_class=user_class) user.put() #set login cookie #redirect to index page self.redirect('/')
def post(self): user_key_list = self.request.get_all('users') message = self.request.get('message') users = User.get(user_key_list) twitter = login_twitter_bot() logging.debug("Sending messages to these users: "+str([u.screen_name for u in users])) logging.debug("The message being sent is: "+message) for user in users: try: twitter.send_direct_message(screen_name=user.screen_name, text=message) except: pass
def post(self): subject = self.request.get('subject') content = self.request.get('content') # let's check we have a subject and a content if subject and content: post = Post( subject=subject, content=content, user=User.by_id(self.uid()) ) # post creation post.put() self.redirect('/') # if something is wrong let's show the error else: error = 'Sorry, we need both, title and content.' self.render_new_post(subject, content, error)
def post(self): self.response.headers['Content-Type'] = 'application/json; charset=utf-8' counter = 0 userlist = json.loads(self.request.body, object_hook=as_user) self.response.write('[') for u in userlist: for p in u.phones: usr = User.query(User.hash == p).get() if usr is not None: if counter > 0: self.response.write(',') self.response.write(print_user(u.lookup_key, usr)) counter += 1 self.response.write(']')
def follow(twitter, handle): user_data = follow_user_and_get(twitter, handle) if user_data is None: return user = User.all().filter('screen_name =', handle).get() if user is None: user = User(screen_name=handle) else: user.active = True if user.location is not None: user.put() send_success_dm(twitter, handle) return relocate(twitter, user_data.location, user) user.put()
def post(self): name = self.request.get('username') password = self.request.get('password') error = {} # let's check if user already exists user = User.by_name(name) if not user: error['name'] = "User doesn't exist" # and now the password else: password_ok = password and valid_pw(name, password, user.password) if not password_ok: error['password'] = "******" # if everything is right, let's log in the user if not error: self.login(user) self.redirect('/') # if something is wrong, let's render again showing the error self.render('log-in.html', name=name, error=error)
def post(self, post_id): post = Post.get_by_id(int(post_id)) content = self.request.get('content') # let's check if user is logged in if self.user: # and there is something in the content field if content: comment = Comment( post=post, user=User.by_id(self.uid()), content=content ) comment.put() self.render_post(post) else: error = "Your comment can't be empty" self.render_post(post, error) # user not logged in, let's go to the login page else: self.redirect('/login')
def get(self): all_places = list(Location.all()) rainy_places = self._get_locations(all_places) twitter = login_twitter_bot() logging.debug("The rainy places are: "+str([location.name for location in rainy_places])) for place in all_places: if place in rainy_places: users = list(User.all(keys_only=True).filter('location =', place).filter('active =', True)) message = self._format_message(place) user_len = len(users) for i in range(0, user_len / RainNotification.DM_PER_REQUEST + 1): slice = users[i*RainNotification.DM_PER_REQUEST:(i + 1)*RainNotification.DM_PER_REQUEST] if len(slice) > 0: QueueHandler.queue_notify(message, slice, i*10) else: place.last_broadcast_rain = False db.put(all_places)
def get_user(self, user_obj): try: return User.from_twitter(self.session.db.users, user_obj['id_str']) except ValueError: return User.create_from_twitter(self.session.db.users, user_obj)
def test_entity_manipulation(self): switchToTestDatabase() #creating a user u=User(login='******',password='******') print User.create(u) , '\n' self.assertTrue(u.findByLogin()!= None) #finding & updating a user u=User(login='******') u=u.findByLogin() print 'user before update: ', u print 'changing password to strong' u.password='******' u.update() u=u.findByLogin() print u self.assertEqual(u.password,'strong') print 'changing password to VERYstrong' u.password='******' u.update() u=u.findByLogin() print u self.assertEqual(u.password,'VERYstrong') #try to update a non existing user raised=False try : u=User(login='******',password='******') u.update() except Exception : print 'catch an Illegal Attempt' print '\ntrying to update jose, but he don\'t exist' raised=True self.assertTrue(raised) self.assertEqual(u.findByLogin(),None) deleteTestDatabase()
def get(self, phoneHash): self.response.write('Requested phone hash is :\"'+ escape(phoneHash) +'\"\n') user = User.query(User.hash == escape(phoneHash)).get() self.response.headers['Content-Type'] = 'application/json; charset=utf-8' self.response.write(user.to_json())
def persistUser(self,username,email,password): user = User() user.username = username user.hashed_password = hashlib.sha256(password).hexdigest() user.email = email return user.put().id()
def test_create_user(self): print "__________create user test_________" u = User(name="testbli", password_sha="testbli", email="*****@*****.**", activationCode="111") u.create()