def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
data, errors = user_schema.load(json_data)
if errors:
return errors, 400
user = User.query.filter_by(username=data['username']).first()
if user:
return {'message': 'user already exists'}, 400
user = User(
username=json_data['username'],
password = json_data['password']
)
user.save()
result = user_schema.dump(user).data
del result["password"]
token = flask_jwt_extended.create_access_token(identity=result)
result ["token"] = token
return { "status": 'success', 'data': result }, 201
def user_transaction_factory(self, user_cursor):
"""Creates transaction object from mongo cursor"""
u = User()
u.id = str(user_cursor.get("_id"))
u.download_list = user_cursor.get("downloadList")
cuttoff_value = timedelta(
days=self.config.get('data_download_history'))
cuttoff_date = datetime.now() - cuttoff_value
counter = 0
try:
transaction = {}
#e.g {'503a0123b2d700ed1400007b-2013-08-18': ['50a2bca4d789a700ddc7fec1', '50a2bca4d789a700ddc7fec0']}
# create a list of downloaded ids
for doc in u.download_list:
doc_id = str(doc.get('doc_id'))
if doc_id:
transaction_timestamp = datetime.utcfromtimestamp(
int(doc['timestamp'] / 1000 / 86400) * 86400)
# check if data is after cutoff date
if cuttoff_date > transaction_timestamp:
counter += 1
transaction_id = "{0}-{1}".format(
u.id, transaction_timestamp.strftime('%Y-%m-%d'))
# print('Ignoring ..{0}'.format(transaction_timestamp))
if transaction_id in transaction:
transaction[transaction_id].append(doc_id)
else:
doc_list = [doc_id]
transaction = {transaction_id: doc_list}
return transaction
except TypeError as err:
pass
def load_user(user_id):
""" Checks if user is logged in (?) """
# @Grey is this docstring correct?
if query_user(user_id) is not None:
curr_user = User()
curr_user.id = user_id
return curr_user
def getUser(id):
accessType = getDatabase().getUserAccessType(id)
if accessType == "UNAUTHORIZED":
return User.User(id, 0, accessType)
else:
return User.User(id, ConfigurationManager.getDefaultSessionTime(),
accessType)
def test_init():
user1 = User('alice', '123', 'alice@email')
user2 = User('admin', '123', 'admin@email')
db.session.add(user1)
db.session.flush()
db.session.commit()
user2.isAdmin = 1
db.session.add(user2)
db.session.flush()
db.session.commit()
feed1 = Feedback("msg1")
db.session.add(feed1)
db.session.flush()
db.session.commit()
feed2 = Feedback("msg2")
db.session.add(user2)
db.session.flush()
db.session.commit()
rep1 = Report(1, 1, "msg1")
db.session.add(feed1)
db.session.flush()
db.session.commit()
rep2 = Report(1, 1, "msg2")
db.session.add(rep2)
db.session.flush()
db.session.commit()
return "success"
def test_sessionStarted(self):
# Initialize and close the initial database.
self.initialDatabase.execute(
"CREATE TABLE Users (Id char(9),AccessType STRING);")
self.initialDatabase.execute(
"CREATE TABLE Sessions (Id char(9),StartTime BIGINT,EndTime BIGINT);"
)
self.initialDatabase.commit()
self.initialDatabase.close()
# Set the static database, start sessions, and assert the sessions are correct.
DatabaseManager.staticDatabaseManager = DatabaseManager.DatabaseManager(
self.databaseFile)
DatabaseManager.sessionStarted(
Session.Session(User.User("000000001", 10), 5))
DatabaseManager.sessionStarted(
Session.Session(User.User("000000002", 10), 8))
DatabaseManager.sessionStarted(
Session.Session(User.User("000000001", 10), 15))
sessions = DatabaseManager.staticDatabaseManager.database.execute(
"SELECT * FROM Sessions;").fetchall()
self.assertEqual(sessions[0], ("000000001", 5, 0),
"Session is incorrect.")
self.assertEqual(sessions[1], ("000000002", 8, 0),
"Session is incorrect.")
self.assertEqual(sessions[2], ("000000001", 15, 0),
"Session is incorrect.")
def test_sessionEnded(self):
# Mock the Time module.
currentTime = 0
class MockTimeModule:
def getCurrentTimestamp(self):
return currentTime
DatabaseManager.Time = MockTimeModule()
# Initialize and close the initial database.
self.initialDatabase.execute(
"CREATE TABLE Users (Id char(9),AccessType STRING);")
self.initialDatabase.execute(
"CREATE TABLE Sessions (Id char(9),StartTime BIGINT,EndTime BIGINT);"
)
self.initialDatabase.commit()
self.initialDatabase.close()
# Create the database, start and end sessions, and assert the sessions are correct.
CuT = DatabaseManager.DatabaseManager(self.databaseFile)
CuT.sessionStarted(Session.Session(User.User("000000001", 10), 5))
currentTime = 7
CuT.sessionEnded(Session.Session(User.User("000000001", 10), 5))
CuT.sessionStarted(Session.Session(User.User("000000002", 10), 8))
currentTime = 9
CuT.sessionEnded(Session.Session(User.User("000000002", 10), 8))
CuT.sessionStarted(Session.Session(User.User("000000001", 10), 15))
sessions = CuT.database.execute("SELECT * FROM Sessions;").fetchall()
self.assertEqual(sessions[0], ("000000001", 5, 7),
"Session is incorrect.")
self.assertEqual(sessions[1], ("000000002", 8, 9),
"Session is incorrect.")
self.assertEqual(sessions[2], ("000000001", 15, 0),
"Session is incorrect.")
def api_register_user(*, email, name, passwd):
if not name or not name.strip():
raise APIValueError('name')
if not email or not _RE_EMAIL.match(email):
raise APIValueError('email')
if not passwd or not _RE_SHA1.match(passwd):
raise APIValueError('passwd')
users = yield from User.findAll("email=?",[email])
if len(users) > 0:
raise APIValueError('register:failed', 'email', 'Email is already in use.')
uid = next_id()
sha1_passwd = '%s:%s' % (uid, passwd)
user = User(id=uid, name=name.strip(), email=email, passwd=hashlib.sha1(sha1_passwd.encode('utf-8')).hexdigest(),image='http://www.gravatar.com/avatar/%s?d=mm&s=120' % hashlib.md5(email.encode('utf-8')).hexdigest())
yield from user.save()
# make session cookie:
r = web.Response()
r.set_cookie(COOKIE_NAME, user2cookie(user, 86400), max_age=86400, httponly=True)
user.passwd = '*******'
r.content_type = 'application/json'
r.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return r
def onAddUser(self):
data = Database()
user = User()
user.name = self.editName.text()
user.username = self.editUsername.text()
user.passWord = self.editPass.text()
try:
data.insertUser(user)
except sqlite3.IntegrityError:
msg = QtWidgets.QMessageBox()
msg.setIcon(QtWidgets.QMessageBox.Warning)
msg.setText("Your username has already existed !!!")
msg.setInformativeText("Please choose another username !!!")
msg.setStandardButtons(QtWidgets.QMessageBox.Ok)
msg.exec()
return
self.addUserIntoTable(user)
data.closeDatabase()
self.editName.clear()
self.editPass.clear()
self.editUsername.clear()
def test_save(loop):
yield from orm.create_pool(loop, user='******', password='******', db='awesome')
u = User(name='hi', email='*****@*****.**',
passwd='hi', image='about:blank')
# pdb.set_trace()
yield from u.save()
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
user = User.query.filter_by(username=json_data['username']).first()
if user:
return {'message': 'Username not available'}, 400
user = User.query.filter_by(
emailadress=json_data['emailadress']).first()
if user:
return {'message': 'Email address already exists'}, 400
api_key = self.generate_key()
user = User.query.filter_by(api_key=api_key).first()
if user:
return {'message': 'API key already exists'}, 400
user = User(
api_key=api_key,
firstname=json_data['firstname'],
lastname=json_data['lastname'],
emailadress=json_data['emailadress'],
password=json_data['password'],
username=json_data['username'],
)
db.session.add(user)
db.session.commit()
result = User.serialize(user)
return {"status": 'success', 'data': result}, 201
def register(fullname,username,password):
user=User(full_name=fullname,user_name=username,password=password)
user.save()
wallet = Wallet.create(customer_id=user)
transaction=Transaction.create(customer_id=user,timestamp=datetime.now())
print("Registration complete")
def setUp(self):
DatabaseManager.staticDatabaseManager = DatabaseManager.DatabaseManager(
":memory:")
DatabaseManager.setUserAccessType("000000000", "AUTHORIZED")
DatabaseManager.setUserAccessType("000000001", "UNAUTHORIZED")
DatabaseManager.setUserAccessType("000000002", "ADMIN")
self.testUser = User.User("000000000", 1, "AUTHORIZED")
self.testUnauthorizedUser = User.User("000000001", 0, "UNAUTHORIZED")
self.testAdminUser = User.User("000000002", 1, "ADMIN")
def onCellClick(self, row, col):
user = User()
user.name = self.tableUser.item(row, 0).text()
user.username = self.tableUser.item(row, 1).text()
user.passWord = self.tableUser.item(row, 2).text()
self.editName.setText(user.name)
self.editUsername.setText(user.username)
self.editPass.setText(user.passWord)
def api_get_users(*, page='1'):
page_index = get_page_index(page)
num = yield from User.findNumber()
p = Page(num, page_index)
if num == 0:
return dict(page=p, users=())
users = yield from User.findAll(orderBy='created_at desc', limit=(p.offset, p.limit))
for u in users:
u.passwd = '******'
return dict(page=p, users=users)
def api_get_users(*, page='1'):
page_index = get_page_index(page)
num = yield from User.findNumber()
p = Page(num, page_index)
if num == 0:
return dict(page=p, users=())
users = yield from User.findAll(orderBy='created_at desc',
limit=(p.offset, p.limit))
for u in users:
u.passwd = '******'
return dict(page=p, users=users)
def test():
yield from orm.create_pool(loop,
user='******',
password='******',
database='awesome')
u = User(name='Test',
email='*****@*****.**',
passwd='1234567890',
image='about:blank')
yield from u.save()
def get(self):
flags = ''
userName = self.request.get("user")
user = User.query(User.uName == userName).get()
Friends = user.friend
for f in Friends:
friend = User.query(User.uName == f).get()
# friends=[]
# friends.append(friend)
flag = friend.flag
flags += flag + ','
response = flags
self.response.write(response)
def get(self):
flags=''
userName=self.request.get("user")
user=User.query(User.uName==userName).get()
Friends=user.friend
for f in Friends:
friend=User.query(User.uName==f).get()
# friends=[]
# friends.append(friend)
flag=friend.flag
flags+=flag+','
response=flags
self.response.write(response)
def login():
""" Login page """
form = LoginForm()
if form.validate_on_submit():
user = query_user(form.username.data)
if user is not None and form.password.data == user['password']:
curr_user = User()
curr_user.id = form.username.data
login_user(curr_user, remember=form.remember_me.data)
return redirect(url_for('main'))
flash('Invalid username or password')
return redirect(url_for('login'))
return render_template('log.html', form=form)
def get(self):
token = self.request.cookies.get("token")
email = ndb.Key('Session', token).get().userKey.id()
user = User.get_by_id(email)
friends = []
for friend in user.friend:
fuser = User.query(User.uName == friend).get()
friends.append(fuser)
template_values = {
'UserName': user.uName,
'friends': friends,
}
template = JINJA_ENVIRONMENT.get_template('home.html')
self.response.write(template.render(template_values))
def get(self):
token = self.request.cookies.get("token")
email = ndb.Key('Session',token).get().userKey.id()
user=User.get_by_id(email)
friends=[]
for friend in user.friend:
fuser=User.query(User.uName==friend).get()
friends.append(fuser)
template_values = {
'UserName': user.uName,
'friends':friends,
}
template = JINJA_ENVIRONMENT.get_template('home.html')
self.response.write(template.render(template_values))
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# Validate and deserialize input
data, errors = user_schema.load(json_data)
if errors:
return errors, 422
user = User.query.filter_by(email=data['email']).first()
if user:
return {'message': 'User already exists'}, 400
user = User(
email=json_data['email'],
password=json_data['password']
)
#
db.session.add(user)
db.session.commit()
#
access_token = create_access_token(identity=user.email, fresh=True)
refresh_token = create_refresh_token(user.email)
#
result = user_schema.dump(user).data
#
return { "status": 'success', 'user': result, 'tokens': {'access_token': access_token, 'refresh_token': refresh_token}},202
def post(self):
# requires json body on req
# inputs: username + password
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
# check data for errors
data, errors = user_schema.load(json_data)
if errors:
return errors, 422
# check if user already exists
user = User.query.filter_by(username=data['username']).first()
if user:
return {'message': 'User already exists'}, 400
# save encrypted password
hashed_password = generate_password_hash(data['password'],
method='sha256')
# create user obj in db
user = User(public_id=str(uuid.uuid4()),
username=json_data['username'],
password=hashed_password)
# add to db
db.session.add(user)
db.session.commit()
result = user_schema.dump(user).data
return {"status": 'success', 'data': result}, 201
def cookie2user(cookie_str):
'''
Parse cookie and load user if cookie is valid.
'''
if not cookie_str:
return None
try:
L = cookie_str.split('-')
if len(L) != 3:
return None
uid, expires, sha1 = L
if int(expires) < time.time():
return None
user = yield from User.find(uid)
if user is None:
return None
s = '%s-%s-%s-%s' % (uid, user.passwd, expires, _COOKIE_KEY)
if sha1 != hashlib.sha1(s.encode('utf-8')).hexdigest():
logging.info('invalid sha1')
return None
user.passwd = '******'
return user
except Exception as e:
logging.exception(e)
return None
def authenticate(*, email, passwd):
if not email:
raise APIValueError('email', 'Invalid email.')
if not passwd:
raise APIValueError('passwd', 'Invalid password.')
users = yield from User.findAll('email=?', [email])
if len(users) == 0:
raise APIValueError('email', 'Email not exist.')
user = users[0]
#check password
sha1 = hashlib.sha1()
sha1.update(user.id.encode('utf-8'))
sha1.update(b':')
sha1.update(passwd.encode('utf-8'))
if user.passwd != sha1.hexdigest():
raise APIValueError('passwd', 'Invalid password.')
r = web.Response()
r.set_cookie(COOKIE_NAME,
user2cookie(user, 86400),
max_age=86400,
httponly=True)
user.passwd = '******'
print(user)
r.content_type = 'application/json'
r.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return r
def onAddUser(self, event = None):
if self.numberTempUserAdd > 9:
messagebox.showwarning("Warning","Bạn chỉ có thể thêm tạm 10 username \n Hãy Sửa ID để lưu lại những loại tạm trên", parent = self)
return
userTemp = User(name = "#",username=str(self.numberTempUserAdd),passWord="******")
self.addUserIntoTree(userTemp)
self.numberTempUserAdd += 1
def cookie2user(cookie_str):
'''
Parse cookie and load user if cookie is valid.
'''
if not cookie_str:
return None
try:
L = cookie_str.split('-')
if len(L) != 3:
return None
uid, expires, sha1 = L
if int(expires) < time.time():
return None
user = yield from User.find(uid)
if user is None:
return None
s = '%s-%s-%s-%s' % (uid, user.passwd, expires, _COOKIE_KEY)
if sha1 != hashlib.sha1(s.encode('utf-8')).hexdigest():
logging.info('invalid sha1')
return None
user.passwd = '******'
return user
except Exception as e:
logging.exception(e)
return None
def send_money(user):
money=float(input("Enter the amount to be sent--->"))
user1=Wallet.select().where(Wallet.customer_id==user).get()
comments=input("Enter comments\n--------------------------------------\n")
bal=user1.balance
if money>bal :
print("YOU'RE BROKE!! ")
print("*"*30,"\n")
else:
receiver_username=input("Enter the user name of the receiver--->")
receive_user=User.select().where(User.user_name==receiver_username).get()
user2=Wallet.select().where(Wallet.customer_id==receive_user).get()
bal1=user1.balance-money
bal2=user2.balance+money
query1 = Wallet.update(balance=bal1).where(Wallet.customer_id==user)
n1 = query1.execute()
query2 = Wallet.update(balance=bal2).where(Wallet.customer_id==receive_user)
n2 = query2.execute()
entry=Transaction(customer_id=user,transaction_amount=money,type_transaction="Withdraw",timestamp=datetime.now(),comments=comments)
entry.save()
entry=Transaction(customer_id=receive_user,transaction_amount=money,type_transaction="Deposit",timestamp=datetime.now(),comments=comments)
entry.save()
print("*"*30,"\n")
def onAccept(self):
if len(self.editUsername.text()) != 0 and " " not in list(
self.editUsername.text()):
self.user = User()
self.user.name = self.editName.text()
self.user.username = self.editUsername.text()
self.user.passWord = self.editPass.text()
data = Database()
try:
data.insertUser(self.user)
except sqlite3.IntegrityError:
msg = QtWidgets.QMessageBox()
msg.setIcon(QtWidgets.QMessageBox.Warning)
msg.setText("Your username has already existed !!!")
msg.setInformativeText("Please choose another username !!!")
msg.setStandardButtons(QtWidgets.QMessageBox.Ok)
msg.exec()
self.isAccept = -1
return
self.isAccept = 1
else:
msg = QtWidgets.QMessageBox()
msg.setIcon(QtWidgets.QMessageBox.Warning)
msg.setText(
"Your username cannot be empty or has space in there !!!")
msg.setInformativeText("Please choose another username !!!")
msg.setStandardButtons(QtWidgets.QMessageBox.Ok)
msg.exec()
self.isAccept = -1
def add_info():
"""Saves users registration information in the db"""
# Get user information from registration form input
# FIXME: need to add users level & ride pref
name = request.form.get('fname')
email = request.form.get('email')
password = request.form.get('password')
# Query to see if users email and password are already in the db
user = User.query.filter_by(email=email).first()
# If they are in the db redirect to log in. If not save info to db
if user:
flash('User email already has an account')
return redirect('/')
else:
new_user = User(fname=fname,
lname=lname,
email=email,
password=password)
flash('Welcome')
db.session.add(new_user)
db.session.commit()
session['logged_in'] = new_user.user_id
for category_id in checkboxes:
new_cat = CatUser(user_id=new_user.user_id,
category_id=category_id)
db.session.add(new_cat)
db.session.commit()
return redirect('/')
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
data, errors = user_schema.load(json_data)
if errors:
return errors, 422
user = User.query.filter_by(username=data['username']).first()
if user:
return {'message': 'Username already exists'}, 400
user = User.query.filter_by(email=data['email']).first()
if user:
return {'message': 'Email already exists'}, 400
#create user
user = User(session_id=self.getRandomSession_id(),
firstname=data['firstname'],
lastname=data['lastname'],
email=data['email'],
username=data['username'],
password=data['password'])
#add to db
db.session.add(user)
db.session.commit()
result = user_schema.dump(user).data
return {"status": 'success', 'data': result}, 201
def post(self):
result = ""
json_data = request.get_json(force=True)
header = request.headers["Authorization"]
if not header:
result = self.username_and_and_password_signin(json_data)
else:
user = User.query.filter_by(api_key=header).first()
result = User.serialize(user)
if user:
result = User.serialize(user)
else:
result = self.username_and_and_password_signin(json_data)
return {"status": 'success', 'data': result}, 201
def post(self, *args):
#auth=request.authorization
json_data = request.get_json(force=True)
# json_data=auth
if not json_data:
return {'message': 'No input data provided'}, 400
preuser = User.query.filter_by(id=json_data['id']).first()
if preuser:
return {'message': 'email already exist'}, 400
user = {'name': json_data['name'], 'email': json_data['id']}
encrpted_pass = generate_password_hash(json_data['password'],
method='sha256')
encrpted_public_id = str(uuid.uuid4())
newuser = User(id=json_data['id'],
name=json_data['name'],
password=encrpted_pass,
public_id=encrpted_public_id)
token = jwt.encode(
{
'public_id': newuser.public_id,
'exp':
datetime.datetime.utcnow() + datetime.timedelta(minutes=45)
}, 'Elegance-1234')
db.session.add(newuser)
db.session.commit()
return {
"message": "Success",
"data": user,
"token": token.decode('UTF-8'),
'create': "User is added"
}, 201
def authenticate(*, email, passwd):
if not email:
raise APIValueError('email', 'Invalid email.')
if not passwd:
raise APIValueError('passwd', 'Invalid password.')
users = yield from User.findAll('email=?', [email])
if len(users) == 0:
raise APIValueError('email', 'Email not exist.')
user = users[0]
#check password
sha1 = hashlib.sha1()
sha1.update(user.id.encode('utf-8'))
sha1.update(b':')
sha1.update(passwd.encode('utf-8'))
if user.passwd != sha1.hexdigest():
raise APIValueError('passwd', 'Invalid password.')
r = web.Response()
r.set_cookie(COOKIE_NAME, user2cookie(user, 86400), max_age=86400, httponly=True)
user.passwd = '******'
print(user)
r.content_type = 'application/json'
r.body = json.dumps(user, ensure_ascii=False).encode('utf-8')
return r
def index(request):
#logging.info('index: __template__')
users = yield from User.findAll()
return {
'__template__': 'test.html',
'users': users
}
def onCreateAccount(self):
# sqlite3.IntegrityError
if not self.entryNameUser.get():
messagebox.showwarning("Empty !!!!",
message="Họ tên không thể để trống")
return
if not self.entryAccount.get():
messagebox.showwarning("Empty !!!!",
message="Username không thể để trống")
return
if " " in self.entryAccount.get():
messagebox.showwarning(
"Error !!!!", message="Username không được có khoảng cách")
return
if not self.entryPassWord.get():
messagebox.showwarning("Empty !!!!",
message="Password không thể để trống")
return
user = User(name=self.entryNameUser.get(),
username=self.entryAccount.get(),
passWord=self.entryPassWord.get())
try:
self.data.insertUser(user)
except sqlite3.IntegrityError:
messagebox.showwarning("Opps !!!!",
message="Username bạn chọn đã tồn tại !!!!")
self.master.entryUserName.insert(0, user.username)
self.master.entryPass.insert(0, user.passWord)
self.master.listUser = self.data.getUserList()
self.dialog.destroy()
def post(self):
username=self.request.get("uname")
uemail=self.request.get("email")
upwd=self.request.get("pwd")
if username == '' or uemail=='' or upwd=='':
self.redirect('/error')
else:
user=User.get_by_id(uemail)
if user:
self.redirect('/error')
else:
newUser=User(id=uemail,uName=username,email=uemail,pwd=upwd)
token = security.generate_random_string(length=20)
session = Session(id=token)
session.userKey=newUser.put()
session.put()
self.response.set_cookie(key='token', value=token, path='/')
self.redirect('/home')
def post(self):
userName=self.request.get('user')
friendName=self.request.get('friend')
user=User.query(User.uName==userName).get()
find_friend=User.query(User.uName==friendName).get()
uList=user.friend
fList=find_friend.friend
if friendName in uList:
pass
else:
uList.append(friendName)
if userName in fList:
pass
else:
fList.append(userName)
user.friend=uList
find_friend.friend=fList
user.put()
find_friend.put()
response=userName+' and '+friendName+' are friend now'
# response=uList
self.response.write(response)
def post(self):
send = self.request.get("send")
rec = self.request.get("rec")
mess = self.request.get("mess")
friend=User.query(User.uName==send).get()
friend.flag=True
friend.put()
newMessage=Message(sender=send,receiver=rec,message=mess)
newkey=newMessage.put()
message=Message.query(ndb.OR(ndb.AND(Message.receiver==rec,Message.sender==send),ndb.AND(Message.receiver==send,Message.sender==rec))).order(Message.timestamp).fetch(40)
response='Message Send Success!'
# for m in message:
# response+=m.str()+'\n'
self.response.write(response)
def get(self):
token = self.request.cookies.get("token")
email = ndb.Key('Session',token).get().userKey.id()
user=User.get_by_id(email)
Email=self.request.get('search')
searchfriend=User.get_by_id(Email)
if searchfriend:
result=searchfriend.uName
related_people=searchfriend.friend
flag=True
else:
result='Not find Match Users'
flag=False
related_people=''
template_values = {
'UserName': user.uName,
'result':result,
'Flag':flag,
'friends':related_people,
}
template = JINJA_ENVIRONMENT.get_template('search.html')
self.response.write(template.render(template_values))
def post(self):
talker=self.request.get("talker")
user=self.request.get('user')
friend=User.query(User.uName==talker).get()
friend.flag=False
friend.put()
message=Message.query(ndb.OR(ndb.AND(Message.receiver==talker,Message.sender==user),ndb.AND(Message.receiver==user,Message.sender==talker))).order(Message.timestamp).fetch(40)
response=''
for m in message:
response+=m.str()+'\n'
print(talker)
print(user)
print(message)
self.response.write(response)
def add_staff(request):
if request.POST:
p = request.POST
email = request.POST.get('i_email', '')
password = request.POST.get('i_pass', random_string(8))
user = User()
if request.db_session.query(User)\
.filter_by(email=email)\
.filter_by(user_type_id=request.user.user_type_id).first():
user.errors.append(
{'field': 'email', 'message': 'User with such email already exists.'})
if user.no_errors():
user.email = email
# here encryption is made in validator if validation is passed
user.set_password(password)
user.first_name = p.get('i_first_name', '')
user.last_name = p.get('i_last_name', '')
user.phone = phone_number_from_request(request.POST, 'i_phone')
user.m_phone = phone_number_from_request(request.POST, 'i_m_phone')
user.user_type = request.user.user_type
if request.user.is_focus:
company_id = request.POST.get('f_company_name', '')
if company_id != "0":
user.company = request.db_session.query(Company).filter_by(id=company_id).first()
user.user_type_id = 2
else:
user.company = request.user.company
user.local_tz = request.POST.get('f_tz', None)
address = address_from_request(request.POST)
if user.no_errors() and address.no_errors():
request.db_session.add_all([user, address])
user.address = address
mail.send_mail('Account registration',
'Welcome to %s \n'
'Your registration information: \n'
'Email: %s\n'
'Password: %s\n' % (
request.META['HTTP_HOST'], email, password),
settings.DEFAULT_FROM_EMAIL,
[email],
fail_silently=False)
request.db_session.commit()
# return HttpResponseRedirect(reverse('profiles.views.perms_by_id', args=(user.id,)))
response = json_response_content('success', 'New worker was added successfully')
response['redirect_url'] = reverse('profiles.views.perms_by_id', args=(user.id,))
else:
request.db_session.rollback()
response = json_response_content('error', 'Some error occured during user creation')
for error in user.errors:
response['errors'].append(error)
for error in address.errors:
response['errors'].append(error)
else:
request.db_session.rollback()
response = json_response_content('error', 'Some error occured during user creation')
request.db_session.rollback()
for error in user.errors:
response['errors'].append(error)
return JsonResponse(response)
company_names = request.db_session.query(Company).all()
return render_to_response('profile_add.html',
{'operation': 'add', 'company_names': company_names, 'timezones': pytz.common_timezones},
context_instance=RequestContext(request))
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
import urllib
import webapp2
import jinja2
from webapp2_extras import security
from Model import User, Message, Session
from google.appengine.ext import ndb
JINJA_ENVIRONMENT = jinja2.Environment(
loader=jinja2.FileSystemLoader([os.path.dirname(__file__),os.path.dirname(__file__)+"/templates"]))
#init User
tom=User(id='*****@*****.**',uName='Tom',email='*****@*****.**',pwd='123',friend=['Jerry','Lucy','Emma'])
jerry=User(id='*****@*****.**',uName='Jerry',email='*****@*****.**',pwd='123',friend=['Tom','Lucy','Emma'])
lucy=User(id='*****@*****.**',uName='Lucy',email='*****@*****.**',pwd='123',friend=['Tom','Jerry','Emma'])
emma=User(id='*****@*****.**',uName='Emma',email='*****@*****.**',pwd='123',friend=['Tom','Lucy','Jerry'])
tom.put()
jerry.put()
lucy.put()
emma.put()
#init Message
m1=Message(sender="Jerry",receiver="Tom",message="hello tom!")
m2=Message(sender="Tom",receiver="Jerry",message="Hi Jerry! what's up?")
m3=Message(sender="Tom",receiver="Emma",message="Hi Emma! what's up?")
key_m1=m1.put()
# print('call put')
key_m2=m2.put()
# print('call put')
def test(loop):
yield from orm.create_pool(loop, user='******', password='******', db='awesome')
#u = User(name='yao', email='*****@*****.**', passwd='1234567890', image='about:blank')
rs = yield from User.findNumber('email')
print(rs)
def test(loop):
yield from orm.create_pool(loop=loop,user='******', password='******', db='awesome')
u = User(name='Test', email='*****@*****.**', passwd='1234567890', image='about:blank')
yield from u.save()
