def lambda_handler(event, context):
try:
usr = user.deserialize(event["user"])
#usr = user.deserialize(event["user"])
password = event["password"]
except:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
if not all(x is not None for x in [usr, password]):
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
try:
if usr.role == "citizen":
_usr = user.User.create_new_user(usr.name, usr.email, password,
usr.role, usr.address, usr.city,
usr.postnr)
_usr.token = get_auth_token(_usr)
return respond("200", _usr.serialize())
else:
_usr = user.User.create_new_user(usr.name, usr.email, password,
usr.role)
_usr.token = get_auth_token(_usr)
return respond("200", _usr.serialize())
except Exception as ex:
raise ex
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
def lambda_handler(event, context):
try:
id = event["id"]
except:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
if not id:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
usr = user.Contact.get(id)
if not usr or usr.id == -1:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
else:
return respond("200", usr.serialize())
def createUser(self, username, serial, hash, nonce):
results = yield self.userData.findByHash(hash)
if nonce in [None, '']:
if results:
raise Exception('duplicate user hash!')
usr = user.User(hash)
usr.id = None
usr.username = username
usr.serial = serial
usr.hash = hash
usr.nonce = nonce
usr.profiles = []
yield self.userData.store(usr)
for i in range(3):
profile = user.Profile(i)
profile.id = -1
usr.profiles.append(profile)
defer.returnValue(usr)
else:
# modification
results = yield self.userData.findByNonce(nonce)
if not results:
raise Exception('User not found for nonce: %s' % nonce)
usr = results[0]
usr.hash = hash
usr.serial = serial
usr.username = username
usr.nonce = None
yield self.userData.store(usr)
defer.returnValue(usr)
def devtools_for_user(id):
if not muser.User.exists(id):
abort(404)
cuser = muser.getCurrentUser()
id = int(id)
if not cuser.isDev():
abort(403)
user = muser.User(id)
data = request.json
if data["action"] == "update-role":
user.setDetail("role", data["role"])
return "ok"
elif data["action"] == "override-delete":
if user.isDeleted():
user.setDetail("reputation", 0)
return "ok"
else:
return "account not deleted", 400
elif data["action"] == "reget-reputation":
user.regetRep(data["global"])
return "ok"
return "no action found", 400
def preferences_for_user(id):
if not muser.User.exists(id):
abort(404)
cuser = muser.getCurrentUser()
id = int(id)
if id < 0 and not cuser.isMod():
abort(403)
if not (cuser.isMod() or id == cuser.id):
abort(403)
user = muser.User(id)
data = request.json
VALID_PREFERENCES = [
"darkTheme", "autoSave", "mail:community", "mail:research",
"pinnedNav", "betaTester", "gdpr:hideHomeCourseRecommendations"
]
if data["key"] not in VALID_PREFERENCES:
return jsonify({"result": "error", "error": "Ungültige Einstellung"})
user.setPref(data["key"], data["value"])
return jsonify({"result": "ok"})
def order_test():
conf = config.Config()
conf.load('./unit/test.xml')
print conf.to_string()
print("%s,%d", conf.mongo_ip, conf.mongo_port)
conn = pymongo.Connection(host=conf.mongo_ip,
port=conf.mongo_port,
network_timeout=10)
print 'connection ok'
try:
db = mongodb.WxDatabase(conn)
db_user = user.User(db.get_collection(conf.user))
except IException as e:
e.detail()
return None
print 'user coll ok'
db_user.update('zhengyang', 0, '18757571517', 'xl area')
db_user.update('zhengyang', 0, '18757571517', 'xf street')
db_user.update('jianglili', 0, '15268526565', 'xl area')
db_user.update('jianglili', 0, '15268526565', 'xf street')
cursor = db_user.coll.find({})
for ele in cursor:
print ele
wx_mongo.WxMongo().start()
omgn = OrderMgn()
omgn.init()
access_text = {'openid': 'zhengyang'}
access_input = json.dumps(access_text)
print omgn.get_order_html(access_input)
def add_user(email, password, name, role):
conn = psycopg2.connect(connect_str)
cursor = conn.cursor()
salt = get_salt()
hashed_password = hash_password(password, salt)
try:
cursor.execute("SELECT * FROM users WHERE email = %s", [email])
exist = cursor.fetchone()
# if exist:
# return None
cursor.execute("INSERT INTO users VALUES (DEFAULT, %s, %s, %s, %s, %s) RETURNING id, name, email, role;",
(hashed_password, salt, name, email, role))
usr = cursor.fetchone()
except Exception as ex:
return ex
conn.commit()
cursor.close()
conn.close()
return user.User(usr[0], usr[1], usr[2], usr[3])
def convert_dict_in_obj_list(list_obj, type_obj):
new_list = []
if type_obj == 'user':
for obj in list_obj:
new_list.append(
user.User(obj['id'], obj['name'], obj['msg_cursor']))
if type_obj == 'important_message':
for obj in list_obj:
new_list.append(
important_message.ImportantMessage(obj['message'],
obj['channel'],
obj['user']))
if type_obj == 'yt_vid':
for obj in list_obj:
new_list.append(yt_vid.Video(obj['link'], obj['name']))
if type_obj == 'quote':
for obj in list_obj:
new_list.append(quote.Quote(obj['creator'], obj['quote']))
return new_list
def send_digest():
digestables = Group.Group().get_digestables()
for groupid in digestables:
group = Group.Group(groupid)
user = User.User(group.userID)
digestable = group.get_digestable()
if not digestable:
continue
feeds = {}
for feedid, entryid in digestable:
if not feeds.get('feed%s' % feedid, None):
feeds['feed%s' % feedid] = Feed.Feed(feedid)
feeds['feed%s' % feedid].entries.append(Entry.Entry(entryid))
html = render_template("email.html", feeds=feeds.values(), group=group)
# Create message container - the correct MIME type is multipart/alternative.
msg = MIMEMultipart('alternative')
msg['Subject'] = "Email digest: %s (issue: %s)" % (group.description,
group.issue)
msg['From'] = '*****@*****.**'
msg['To'] = user.email
text = 'switch to html'
msg.attach(MIMEText(text, 'plain'))
msg.attach(MIMEText(html, 'html'))
s = smtplib.SMTP('localhost')
s.sendmail(msg['From'], msg['To'], msg.as_string())
s.quit()
group.update_sent()
print('sent digest to: %s. %s' % (user.email, group.description))
return ('', 204)
def user_test():
conf = config.Config()
conf.load('./unit/test.xml')
print("%s,%d", conf.mongo_ip, conf.mongo_port)
conn = pymongo.Connection(host=conf.mongo_ip, port=conf.mongo_port, network_timeout=10)
print 'connection ok'
try:
db = mongodb.WxDatabase(conn)
user_coll = user.User(db.get_collection(conf.user))
except IException as e:
e.detail()
return None
print '*****subscribe test*****'
user_coll.subscribe('105789992')
user_coll.subscribe('105789993')
for item in user_coll.coll.find():
print item
print '*****unsubscribe test*****'
user_coll.unsubscribe('105789992')
user_coll.unsubscribe('105789993')
for uitem in user_coll.coll.find():
print uitem
print '*****update test*****'
user_coll.update('105789994', 0, '18757571518', 'streat'
)
user_coll.update('105789994', 1, '18757571518', 'city')
for aitem in user_coll.coll.find():
print aitem
print 'user[%s] find in coll is %s' % ('105789994', user_coll.find('105789994'))
user_coll.drop();
def insertUser(self):
session = user.DBSession()
try:
#尝试先发送邮件
EmailHandler.sendEmail(self, self.userid, self.email)
new_user = user.User(userid=self.userid,
username=self.username,
password=self.password,
email=self.email,
auth=False)
session.add(new_user)
session.commit()
self.set_status(201)
result = {
'success': True,
'message': '成功创建账户,并已发送确认邮件',
'status': 201,
'token': pc.encrypt(self.userid)
}
self.write(json.dumps(result))
except Exception:
self.set_status(403)
result = {
'success': False,
'message': '创建账户失败，用户名与邮箱不能重复',
'status': 403
}
self.write(json.dumps(result))
finally:
session.close()
def lambda_handler(event, context):
try:
id = event["id"]
except Exception as ex:
raise ex
return respond("400", user.User(-1, "", "", "").serialize())
if not id:
return respond("401", user.User(-1, "", "", "").serialize())
ctz = user.Citizen.get(id)
if not ctz or ctz.id == -1:
return respond("402", user.User(-1, "", "", "").serialize())
else:
return respond("200", ctz.serialize())
def userbookmarks(username):
if not username:
return redirect('/recent', 302)
user = User.User(username=username)
if user.ID:
amount, start = amountstart()
b = Bookmark.Bookmark()
bookmarks = b.get_bookmarks(userID=user.ID, amount=amount, start=start)
f = Feed.Feed()
feedentries = f.get_by_bookmarks(bookmarks) if f.get_by_bookmarks(
bookmarks) else []
feeds = {}
for feedid, entryid, d in feedentries:
if not feeds.get('feed%s' % feedid, None):
feeds['feed%s' % feedid] = Feed.Feed(feedid)
feeds['feed%s' % feedid].entries.append(Entry.Entry(entryid))
return render_template("recent.html",
feeds=feeds.values(),
amount=amount,
menu=usermenu(),
title='Bookmarks by: %s' % username,
path="/%s/bookmarks" % username,
nextstart=int(start) + int(amount),
prevstart=max(int(start) - int(amount),
-1)), 200, {
'Cache-Control': 's-maxage=1'
}
def test_userpage(self):
u = user.User(1)
with self.app as c:
with c.session_transaction() as sess:
sess['das_hash'] = u.das_hash
response = c.get('/user')
assert '<div class="grid_container">'.encode(
'utf-8') in response.data
def lambda_handler(event, context):
try:
email = event['email']
password = event['password']
except:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
if not all(x is not None for x in [email, password]):
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
usr = user.User.attempt_login(email, password)
if not usr or usr.id == -1:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
else:
usr.token = get_auth_token(usr)
return respond("200", usr.serialize())
def lambda_handler(event, context):
try:
dvc: device.AlexaDevice = deserialize(event["device"])
if dvc.devicetype == "alexadevice":
dvc: device.Device = device.Device.get_from_object(dvc.user_id)
usr = dvc.get_owner()
return respond("200", usr.serialize())
# TODO: Add more devices
else:
return respond("400",
user.User(-1, "", "", "userAdmin").serialize())
except:
return respond("401", user.User(-1, "", "", "userAdmin").serialize())
def create_group():
user = User.User()
if user.verify(session.get('das_hash', None)):
aggregation = 'email' if request.form.get(
'aggregation') == 'true' else ''
group = Group.Group(description=request.form.get('description'),
aggregation=aggregation,
frequency=request.form.get('frequency'),
userID=user.ID)
def login():
if request.method == "POST":
user = User.User()
if user.do_login():
session['das_hash'] = user.das_hash
return redirect('https://rss.xiffy.nl/recent', 302)
else:
print('boe')
return render_template("login.html")
def userpage():
user = User.User()
if not user.verify(session.get('das_hash', None)):
return render_template("login.html")
group = Group.Group()
groups = group.get_groups(userID=user.ID)
return render_template("userpage.html",
user=user,
groups=groups,
menu=usermenu())
def userGenerator():
for i in range(0, 200):
u = user.User('user' + str(i))
u.setName('user' + str(i))
u.setGender(randomGender())
u.setAge(randint(18, 90))
u.setVehicle(randomVeichle())
u.setFavouriteCategories(randomCategories())
u.setJob(randomJob())
print(u)
def usermenu():
user = User.User()
payload = ''
if user.verify(session.get('das_hash', None)):
groups = Group.Group().get_groups(userID=user.ID)
if not groups:
groups = []
payload = render_template('menu/usermenu.html',
user=user,
groups=groups)
return "%s %s" % (payload, all_feeds())
def register():
username = request.form['username']
password = request.form['password']
customer = user.User()
result = customer.sign_up(username, password)
token = result[0]
msg = result[1]
if token:
print(msg)
return render_template('login.html')
else:
print(msg)
return render_template('register.html')
def lambda_handler(event, context):
contacts = user.Contact.get_all()
return_string = "["
if not contacts:
return respond("400", user.User(-1, "", "", "userAdmin").serialize())
else:
for ctc in contacts:
return_string += ctc.serialize() + ","
return_string = return_string[:-1] + "]"
return respond("200", return_string)
def findByHash(self, hash):
sql = ('SELECT id,username,serial,hash,reset_nonce,updated_on '
'FROM users WHERE deleted = 0 AND hash = %s')
rows = yield self.dbController.dbRead(0, sql, hash)
results = []
for row in rows:
usr = user.User(row[3])
usr.id = row[0]
usr.username = row[1]
usr.serial = row[2]
usr.hash = row[3]
usr.nonce = row[4]
usr.updatedOn = row[5]
results.append(usr)
defer.returnValue(results)
def findByUsername(self, username):
sql = ('SELECT player_id,name,serial5,hash5 '
'FROM weblm_players WHERE approved="yes" AND name = %s')
rows = yield self.dbController.dbRead(0, sql, username)
results = []
for row in rows:
usr = user.User(row[3])
usr.id = row[0]
usr.username = row[1]
usr.serial = row[2]
usr.hash = row[3]
usr.nonce = None
#usr.updatedOn = row[5]
results.append(usr)
defer.returnValue(results)
def lambda_handler(event, context):
try:
usr = usr = user.deserialize(str(event["user"]))
except:
return respond("400", event["user"])
if not user:
return respond("400", event["user"])
try:
usr.delete()
return respond("200",
user.User(-1, "", "", "citizenAdmin").serialize())
except:
return respond("400", event["user"])
def findByHash(self, hash):
#log.debug('EVO: UserData.findByHash: %s' % hash)
sql = ('SELECT player_id,name,serial6,hash6 '
'FROM weblm_players WHERE approved="yes" AND hash6 = %s')
rows = yield self.dbController.dbRead(0, sql, hash)
results = []
for row in rows:
usr = user.User(row[3])
usr.id = row[0]
usr.username = row[1]
usr.serial = row[2]
usr.hash = row[3]
usr.nonce = None
#usr.updatedOn = row[5]
results.append(usr)
defer.returnValue(results)
def start(self):
conf = config.Config()
self.conn = pymongo.Connection(host=conf.mongo_ip,
port=conf.mongo_port,
network_timeout=10)
self.db = mongodb.WxDatabase(self.conn)
self.user = user.User(self.db.get_collection(conf.user))
self.stat = stat.Stat(self.db.get_collection(conf.stat))
self.menu = menu.Menu(self.db.get_collection(conf.menu))
self.week_now = menu.WeekNow(self.db.get_collection(conf.week_now))
self.week_time = menu.WeekTime(self.db.get_collection(conf.week_time))
self.admin = admin.Admin(self.db.get_collection(conf.admin))
self.cache = cache.Cache(self.db.get_collection(conf.cache))
self.order = order.Order(self.db.get_collection(conf.order))
self.shopping = order.Shopping(self.db.get_collection(conf.shopping))
def get(self, id):
#sql = ('SELECT id,username,serial,hash,reset_nonce,updated_on '
# 'FROM users WHERE deleted = 0 AND id = %s')
sql = ('SELECT player_id,name,serial5,hash5 '
'FROM weblm_players WHERE approved ="yes" AND id = %s')
rows = yield self.dbController.dbRead(0, sql, id)
results = []
for row in rows:
usr = user.User(row[3])
usr.id = row[0]
usr.username = row[1]
usr.serial = row[2]
usr.hash = row[3]
usr.nonce = None
#usr.updatedOn = row[5]
results.append(usr)
defer.returnValue(results)
def login(email, password):
conn = psycopg2.connect(connect_str)
cursor = conn.cursor()
cursor.execute("SELECT id, password, salt FROM users WHERE email = %s", [email])
usr = cursor.fetchone()
conn.commit()
cursor.close()
conn.close()
if not usr:
return None
if check_password(password, usr[1], usr[2]):
return get_user(usr[0])
else:
return user.User(-1, "", "", "")
