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