def create_user(self, username, password, regions, perm='REGION'):
valid_regions = [
region.id for region in Dao.get_all_regions(self.mongo_client)
]
for region in regions:
if region not in valid_regions:
print 'Invalid region name:', region
regions = [region for region in regions if region in valid_regions]
if len(regions) == 0 and perm == 'REGION':
raise InvalidRegionsException("No valid region for new user")
salt, hashed_password = gen_password(password)
the_user = M.User(id="userid--" + username,
admin_regions=regions,
username=username,
salt=salt,
hashed_password=hashed_password,
admin_level=perm)
return self.insert_user(the_user)
def get_photos(self):
self.photos_from_model = []
self.users_from_model = []
no_of_photos = random.randint(2, 10)
for tag in self.tags:
try:
print('getting photos from tag {0}...'.format(tag))
self.photos = self.operation.get_photos_by_tag(tag)
except TypeError:
print('oops! someting went wrong while fetching photos')
# get details for each photo
for photo in self.photos:
photo_details = self.operation.get_photo_details(photo['code'])
if (photo_details):
photo_instance = model.Photo().from_json(photo_details)
self.repository.merge_photo(photo_instance)
self.photos_from_model.append(photo_instance)
user_details = self.operation.get_user_details(
photo_instance.owner_username.replace('\'', ''))
if (user_details):
user_instance = model.User().from_json(user_details)
self.repository.merge_user(user_instance)
self.users_from_model.append(user_instance)
self.filter_photos()
if (len(self.photos_from_model) < no_of_photos):
no_of_photos = len(self.photos_from_model)
self.photos_from_model = random.sample(self.photos_from_model,
no_of_photos)
self.users_from_model = self.spam_validator.validate_users(
self.users_from_model)
return self.photos_from_model
def user_update(user_id=0):
if user_id:
user_db = model.User.get_by_id(user_id)
else:
user_db = model.User(name='', username='')
if not user_db:
flask.abort(404)
form = UserUpdateForm(obj=user_db)
for permission in user_db.permissions:
form.permissions.choices.append((permission, permission))
form.permissions.choices = sorted(set(form.permissions.choices))
if form.validate_on_submit():
if not util.is_valid_username(form.username.data):
form.username.errors.append('This username is invalid.')
elif not model.User.is_username_available(form.username.data,
user_db.key):
form.username.errors.append('This username is already taken.')
else:
form.populate_obj(user_db)
if auth.current_user_key() == user_db.key:
user_db.admin = True
user_db.active = True
user_db.put()
return flask.redirect(
flask.url_for(
'user_list',
order='-modified',
active=user_db.active,
))
return flask.render_template(
'user/user_update.html',
title=user_db.name or 'New User',
html_class='user-update',
form=form,
user_db=user_db,
api_url=flask.url_for('api.admin.user', user_key=user_db.key.urlsafe())
if user_db.key else '')
def POST(self):
i = web.input(email='')
web.header('Content-Type', 'application/json')
user = model.User()
user_id = user.matched_id(email=i.email)
if user_id:
status = user.status(user_id) # 获取当前状态
temp_password = status['password_hash'][
0:8] # 使用原来密码的“MD5值前8位”作为临时密码
# 发送邮件
subject = '请尽快修改您的密码——来自论坛网站'
message = '''尊敬的%s：
您的临时密码是"%s"，请用该密码登录后，尽快修改密码，谢谢！
''' % (status['username'], temp_password)
try:
web.sendmail(settings.SITE_SMTP_USERNAME, i.email, subject,
message)
except Exception, e: # 发送失败
print e
else: # 发送成功
if user.update(user_id, password=temp_password): # 设置临时密码
return json.dumps({'result': True})
def new_user(n_username, n_password, type):
'''Function to add a new admin user to the database'''
cursor = cnn.cursor()
query = ('''SELECT * FROM user WHERE username = %s''')
cursor.execute(query, (n_username, ))
val = cursor.fetchone()
if val is not None:
# return print("SYSTEM ERROR: Username already exist")
return False
else:
new_usr = model.User(n_username, n_password)
new_usr.user_type = type
cursor = cnn.cursor()
query1 = ('''INSERT INTO user VALUES(NULL,%s,%s,%s)''')
cursor.execute(query1, (
new_usr.username,
new_usr.password,
new_usr.user_type,
))
cnn.commit()
print("SYSTEM INFO: New user created successfully")
return True
def testGroup1Answers(self):
user1 = model.User(name=model.UserName('user-1'))
user1.put()
answer = model.TestAnswer(user=user1.key, expected='pair', got='pair')
result = model.TestResult(parent=user1.key, answers=[answer])
result.put()
# Expect that "pair" for a user in group 1 to be categorized as "dm-imm".
# See static/data/word-categories.json.
self.assertEqual('dm-imm', result.answers[0].category)
self.assertTrue(result.answers[0].correct)
answer = model.TestAnswer(user=user1.key,
expected='save',
got='recover')
result.answers.append(answer)
result.put()
readback = result.key.get()
self.assertEqual('dm-imm', readback.answers[0].category)
self.assertTrue(readback.answers[0].correct)
self.assertEqual('nt-imm', readback.answers[1].category)
self.assertFalse(readback.answers[1].correct)
def create_user_db(auth_id,
name,
username,
email='',
verified=False,
password='',
**props):
"""Saves new user into datastore"""
if password:
password = util.password_hash(password)
email = email.lower()
user_db = model.User(name=name,
email=email,
username=username,
auth_ids=[auth_id] if auth_id else [],
verified=verified,
token=util.uuid(),
password_hash=password,
**props)
user_db.put()
task.new_user_notification(user_db)
return user_db
def register():
if request.method == 'GET':
return render_template('register.html')
else:
username = request.form.get('username')
user = model_session.query(model.User).filter_by(username=username).first()
if user != None:
flash('This username is already taken.')
return redirect(url_for('register'))
else:
password = request.form.get('password')
verify_password = request.form.get('verify_password')
if verify_password == password:
new_user = model.User(username=username)
new_user.set_password(password)
model_session.add(new_user)
model_session.commit()
model_session.refresh(new_user)
return redirect(url_for('login'))
else:
flash('Passwords do not match!')
return redirect(url_for('register'))
def scrap_users(self):
self.log('Scrapping & Validating users...')
user_amount = random.randint(3, 10)
for media in self.unfilteredMediaList:
user = self.operation.get_user_details(media.owner_username.replace('\'',''))
if (user):
user_instance = model.User().from_json(user)
self.repository.persist_user(user_instance)
self.userList.append(user_instance)
# Validate user.
self.userList = self.spam_validator.validate_users(self.userList)
if (user_amount > len(self.userList)):
user_amount = len(self.userList)
self.userList = random.sample(self.userList, user_amount)
if(len(self.userList) == 0):
self.log('could not get valid users.')
return False
return True
def adduser(userdata):
# only take allowed input, and ensure it's all there
entries = ('username', 'fullname', 'color', 'email')
try:
user = m.User(**{k: userdata[k] for k in entries})
except KeyError:
return failure('Unvollständiger Account!')
# validate input TODO – not mission-critical here but would be nice
# check duplicates
if m.User.query.filter_by(username=user.username).count():
return failure('Nutzername ist bereits belegt!')
if m.User.query.filter_by(email=user.email).count():
return failure('Die Email-Adresse ist bereits bekannt!')
db.session.add(user)
try:
db.session.commit()
socketio.emit('user changed', user.export())
return success()
except:
return failure('Datenbankeintrag gescheitert!')
def register():
current_request = flask.request
if current_request.method == "GET":
return flask.render_template("register.html")
elif current_request.method == "POST":
#todo: register valid user
email = current_request.form.get("email")
username = current_request.form.get("username")
password = current_request.form.get("password")
user_exist = db.query(model.User).filter_by(username=username).first()
email_exist = db.query(model.User).filter_by(email=email).first()
if user_exist:
print("User already exists")
elif email_exist:
print("Email already exists")
else:
new_user = model.User(username=username, email=email, password=hash_password(password))
db.add(new_user)
db.commit()
return flask.redirect(flask.url_for("register"))
def POST(self):
i = web.input(title='', content='', upload_file={}, bankuai='', url='')
fn = ''
subpath = 'static/video2/'
if i['upload_file'].filename == '':
if i.url == '':
return titled_render().failed('没有视频不能发表新帖')
else:
fn = i.url
else:
fn = subpath + i['upload_file'].filename
f = open(fn, 'w')
f.write(i['upload_file'].file.read())
f.close()
bn = 1
u = 'https://35.231.12.128:8888/'
if bn == 1 and i['upload_file'].filename.split('.')[-1] != 'mkv':
cmd = 'ffmpeg -i ' + fn + ' -vcodec h264 -s 320*240 -f mp4 ' + 'static/%s' % i[
'upload_file'].filename + '.mp4'
'''r=os.system(cmd)
if r!=0:
print '转码失败'
os.system('rm -rf '+'static/%s'%i['upload_file'].filename)
return titled_render().failed('似乎是不支持的视频格式或文件格式损坏，请使用编解码工具确认文件信息')
'''
thr = Thread(target=os.system, args=cmd)
thr.start()
#call_cmd(cmd)
fn = u + fn + '.mp4'
else:
fn = u + fn
post_id = model.Post().new(i.title, i.bankuai, i.content, fn,
model.User().current_id())
if post_id:
raise web.seeother("/view/%d" % post_id)
else:
return titled_render().failed('你不应该到达这里')
def test_user(self):
"""test the user table"""
USER_ARGS = {
"email":
"*****@*****.**",
"name":
"Test A. B. User",
"password":
"******",
"creation_time":
model.str_to_dt("2017-01-01T12:12Z"),
"misc_data":
'{"teacher": "Cavanaugh"}',
}
# create and add user
user = model.User(**USER_ARGS)
db_session.add(user)
db_session.commit()
# fetch user
results = model.User.query.filter_by(email=USER_ARGS['email']).all()
self.assertEqual(len(results), 1)
def process_acct():
form = CreateForm(request.form)
print "$$$$", form.validate_on_submit()
if form.validate_on_submit():
email = request.form["email"]
password = request.form["password"]
hashed_password = pbkdf2_sha512.encrypt(
password, salt=b'64', rounds=100000, salt_size=16)
# Checks that user isn't creating a duplicate account
user = m_session.query(model.User).filter_by(email=email).first()
if user is not None:
flash("That account already exists. Please log in.")
return redirect("/login")
else:
new_user_acct = model.User(email=email, password=hashed_password)
m_session.add(new_user_acct)
m_session.commit()
flash("Your account has been succesfully added.")
f_session["email"] = email
return redirect("/input/banking")
else:
flash("Please enter a valid email and password.")
return redirect("/create")
def handle(self, _msg):
msg = Message(**_msg) # TODO: create own message object
# TODO: log msg in db
user = self.db.usr.get_by_id(msg.from_.id)
if not user:
user = model.User(id=msg.from_.id, first_name=msg.from_.first_name)
user.update(msg.from_)
try:
if msg.text and msg.text.startswith('/'):
control = self.get_control(msg.text[1:], user)
control.send(user.id)
elif msg.reply_to_message and str(user.id) == config.master:
self.resend(msg)
pass # TODO: log
elif str(user.id) != config.master:
if msg.forward_from:
control = self.get_control(strings.cmd_user + str(user.id),
self.db.usr.get_by_id(config.master))
control.send(config.master)
self.bot.forwardMessage(config.master, user.id, msg.message_id)
pass # TODO: log
else:
self.bot.sendMessage(user.id, strings.errmsg_unknown_cmd,
reply_to_message_id=msg.message_id)
except Exception as e:
traceback.print_exc()
text = strings.errmsg_err + '\n'
text += str(type(e)) + '\n'
text += str(e)
if str(user.id) == config.master:
error = msg
else:
error_msg = self.bot.forwardMessage(config.master, user.id, msg.message_id)
error = Message(**error_msg)
self.bot.sendMessage(config.master, text, reply_to_message_id=error.message_id)
self.db.usr.update(user)
def get(self):
return_url = self.request.get('source', self.request.uri)
# Creating the response assuming the user is not logged in.
response = {}
response['url'] = users.create_login_url(
User.Url('record_login', redirect=return_url))
response['email'] = None
response['user'] = None
user = users.get_current_user()
if user:
# Updating with user data.
response['url'] = users.create_logout_url(return_url)
response['email'] = user.email()
user_record = LookupUserByEmail(user.email())
if not user_record:
user_record = model.User(id=MakeUserId(user.email()),
email=user.email(),
created=datetime.now())
user_record.put()
response['user'] = ndb_json.AsDict(user_record)
self.SendJson(response)
def sign_up():
form = SignUpForm()
if form.validate_on_submit():
user = model.session.query(
model.User).filter(model.User.email == form.email.data).first()
if user != None:
user_email = user.email
if user_email == form.email.data:
flash("email already exists")
return redirect(url_for("form"))
if user == None:
fname = form.fname.data
lname = form.lname.data
email = form.email.data
password = form.password.data
new_user = model.User(id=None,
email=email,
password=password,
fname=fname,
lname=lname)
model.session.add(new_user)
model.session.commit()
return redirect("/")
return render_template("sign_up.html", title="Sign Up Form", form=form)
def __init__(self):
self.view = view.View()
self.model = model.Model()
self.user = model.User()
def on_post(self, req, resp):
data = json.loads(req.stream.read().decode('utf-8'))
try:
existing_user = session.query(model.User).\
filter(model.User.email == data['email']).\
first()
if existing_user is not None:
req.context['result'] = {'error': "duplicate_user"}
return
except SQLAlchemyError:
session.rollback()
raise
try:
if 'nick_name' not in data:
data['nick_name'] = ""
user = model.User(email=data['email'],
password=auth.get_hashed_password(
data['password']),
first_name=data['first_name'],
last_name=data['last_name'],
nick_name=data['nick_name'],
sex=data['gender'],
short_info=data["short_info"])
session.add(user)
session.commit()
except SQLAlchemyError:
session.rollback()
req.context['result'] = {
'error': "Nelze vytvořit uživatele, kontaktuj prosím orga."
}
raise
try:
profile = model.Profile(
user_id=user.id,
addr_street=data['addr_street'],
addr_city=data['addr_city'],
addr_zip=data['addr_zip'],
addr_country=data['addr_country'].lower(),
school_name=data['school_name'],
school_street=data['school_street'],
school_city=data['school_city'],
school_zip=data['school_zip'],
school_country=data['school_country'].lower(),
school_finish=int(data['school_finish']),
tshirt_size=data['tshirt_size'].upper(),
referral=data.get('referral', "{}"))
except BaseException:
session.delete(user)
session.commit()
req.context['result'] = {
'error': "Nelze vytvořit profil, kontaktuj prosím orga."
}
raise
try:
session.add(profile)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
try:
notify = model.UserNotify(
user=user.id,
auth_token=util.user_notify.new_token(),
notify_eval=data['notify_eval']
if 'notify_eval' in data else True,
notify_response=data['notify_response']
if 'notify_response' in data else True,
notify_ksi=data['notify_ksi']
if 'notify_ksi' in data else True,
notify_events=data['notify_events']
if 'notify_events' in data else True,
)
except BaseException:
session.delete(profile)
session.commit()
session.delete(user)
session.commit()
req.context['result'] = {
'error':
"Nelze vytvořit notifikační záznam, kontaktuj prosím orga."
}
raise
try:
session.add(notify)
session.commit()
except SQLAlchemyError:
session.rollback()
raise
try:
util.mail.send(
user.email,
'[KSI-WEB] Potvrzení registrace do Korespondenčního semináře '
'z informatiky', 'Ahoj!<br/>Vítáme tě v Korespondenčním '
'semináři z informatiky Fakulty informatiky Masarykovy '
'univerzity. Nyní můžeš začít řešit naplno. Stačí se přihlásit'
' na https://ksi.fi.muni.cz pomocí e-mailu a zvoleného hesla. '
'Přejeme ti hodně úspěchů při řešení semináře!<br/><br/>KSI')
except SQLAlchemyError:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type,
exc_value,
exc_traceback,
file=sys.stderr)
session.close()
req.context['result'] = {}
def index():
''' Give out the form for preordering '''
form = forms.DiscountForm()
out = {'status': False, 'msg': ''}
if form.validate_on_submit():
# check if there is a user with the given email
user = model.User.get_user_by_email(session=SESSION,
emailid=form.data.get('email'))
if user is not None:
out['msg'] = ("There is already a user registered for "
"discount with this email")
APP.logger.warn("Another attempt for discount of user: %s",
user.email)
return flask.jsonify(out), 400
# add to the database
user = model.User(
name=form.data.get('name'),
email=form.data.get('email'),
contact=form.data.get('cellphone'),
address=form.data.get('address'),
token_used=False,
)
SESSION.add(user)
try:
SESSION.commit()
except SQLAlchemyError as e:
out['msg'] = 'Could not insert in database, some problem'
APP.logger.error("Problem inserting in database for user: %s",
user.email)
return flask.jsonify(out), 500
out['status'] = True
# get the user token from database and show it to the user
user = model.User.get_user_by_email(session=SESSION,
emailid=form.data.get('email'))
# try sending the email
try:
# get the html email body
EMAIL_BODY = flask.render_template('email.html', token=user.token)
print EMAIL_BODY
sg = sendgrid.SendGridAPIClient(
apikey=APP.config['SENDGRID_API_KEY'])
from_email = Email(APP.config['SENDGRID_DEFAULT_FROM'])
to_email = Email(form.data.get('email'))
subject = 'Ethereal Ray: Discount Coupon Code'
content = Content("text/html", EMAIL_BODY)
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
except Exception as e:
APP.logger.error('Failed sending email for %s',
form.data.get('email'))
APP.logger.error("The error was: %s", e)
out['msg'] = ('Failed to send email but, registered for discount'
'token is %s' % user.token)
if response.status_code >= 300:
out['msg'] = ('Failed to send email but, registered for discount'
'token is %s' % user.token)
return flask.jsonify(out), int(response.status_code)
out['msg'] = 'Successfully stored the token and email sent'
return flask.jsonify(out), 200
if flask.request.is_xhr:
out['success'] = False
out['msg'] = 'Form Validation Failed'
out['error_fields'] = {}
for fieldName, errorMessages in form.errors.items():
APP.logger.info("field: %s, error: %s", fieldName, errorMessages)
out['error_fields'][fieldName] = errorMessages
return flask.jsonify(out), 400
return flask.render_template('index.html', form=form)
def sign_in(input_user, input_pass):
operator = model.User(input_user, input_pass)
current_user = authenticate(operator)
return current_user
def titled_render(subtitle=''):
subtitle = subtitle + ' - ' if subtitle else ''
return render({'title': subtitle + settings.SITE_NAME, 'make_html': util.make_html,
'trim_utf8': util.trim_utf8, 'menu': util.menu(model.User())})
def GET(self):
if model.User().current_id(): # 用户已登录
return titled_render('发帖').add()
else:
return titled_render().failed('操作受限，请先<a href="/login">登录</a>')
def CreateUserWithToken(username, token):
user = model.User(id=username, name=model.UserName(username))
user.csrf_token = model.UserCSRFToken(token=token)
user.put()
def GET(self):
if model.User().current_id(): # 用户已登录
# 取消cookie
web.setcookie('user_id', '', -1)
raise web.seeother('/')
response.headers["Expires"] = 0
response.headers["Pragma"] = "no-cache"
return response
# Custom filter
app.jinja_env.filters["usd"] = usd
# Configure session to use filesystem (instead of signed cookies)
app.config["SESSION_FILE_DIR"] = mkdtemp()
app.config["SESSION_PERMANENT"] = False
app.config["SESSION_TYPE"] = "filesystem"
Session(app)
# Configure CS50 Library to use SQLite database
db = SQL("sqlite:///finance.db")
Utable = model.User()
Stable = model.Stock()
Htable = model.History()
@app.route("/")
@login_required
def index():
"""Show portfolio of stocks"""
# Get some values
user_id = session["user_id"]
porto = Stable.get_portfolio(user_id)
total = 0
total_stocks = 0
# Makes json for portfolio
def PutUser(self, username):
return model.User(id=username, name=model.UserName(username)).put()
def testCategorization(self):
user1_key = model.User(name=model.UserName('user-1')).put()
user2_key = model.User(name=model.UserName('user-2')).put()
word_categories = model.GetWordCategoriesJsonData()
def MakeCompletedResults(userkey):
all_answers = [
model.TestAnswer(user=userkey, expected=word, got='grapes')
for word in word_categories.keys()
]
result = model.TestResult(parent=userkey, answers=all_answers)
self.assertTrue(result.AllWordsAnswered())
return result
user1_results = MakeCompletedResults(user1_key)
user2_results = MakeCompletedResults(user2_key)
wordpair_answers = {
flavor: GetExpectedAnswersForTest(flavor)
for flavor in ['a', 'b', 'c', 'd']
}
def VerifyCategoryForTestFlavor(flavor, test1_category, test2_category,
results):
# Get all the answers the user was tested on.
answers_to_category = {
answer.expected: answer.category
for answer in results.answers
}
# Intersect that list with the wordpair data of a particular flavor.
words_tested = set(wordpair_answers[flavor]).intersection(
answers_to_category.keys())
# Verify the intersection isn't empty.
self.assertTrue(words_tested)
# Verify each word from that wordpair flavor has the expected category.
for word in words_tested:
if word_categories[word][2] == 'test-1':
expected_category = test1_category
else:
expected_category = test2_category
self.assertEqual(
expected_category, answers_to_category[word],
'word=%s expected_category=%s got=%s' %
(word, expected_category, answers_to_category[word]))
# Verify that, for a user in group 1, the words from 'wordpairs-a.json'
# that appear in test-1 are categorized as 'dm-imm', and words that appear
# in test-2 are 'dm-del'.
VerifyCategoryForTestFlavor('a', 'dm-imm', 'dm-del', user1_results)
# Verify that, for a user in group 2, the words from 'wordpairs-a.json'
# that appear in test-1 are categorized as 'nt-del', and words that appear
# in test-2 are 'nt-imm'.
VerifyCategoryForTestFlavor('a', 'nt-del', 'nt-imm', user2_results)
VerifyCategoryForTestFlavor('b', 'nt-imm', 'nt-del', user1_results)
VerifyCategoryForTestFlavor('b', 'dm-del', 'dm-imm', user2_results)
VerifyCategoryForTestFlavor('c', 'dm-imm', 'dm-del', user1_results)
VerifyCategoryForTestFlavor('c', 'nt-del', 'nt-imm', user2_results)
VerifyCategoryForTestFlavor('d', 'nt-imm', 'nt-del', user1_results)
VerifyCategoryForTestFlavor('d', 'dm-del', 'dm-imm', user2_results)
import model
import orm
orm.start_mappers()
engine = create_engine(
r'sqlite:///D:\newDesktop\大三下courses\SADP\lab2\test\EnglishPalDatabase.db') # modify the path
orm.metadata.drop_all(engine)
orm.metadata.create_all(engine)
get_session = sessionmaker(bind=engine)
# add two users
session = get_session()
try:
session.add(model.User(username='******', password='******', start_date='2021-05-14'))
session.add(model.User(username='******', password='******', start_date='2021-05-15'))
session.commit()
except:
print('Duplicate insertions.')
print(session.query(model.User).count())
for u in session.query(model.User).all():
print(u.username)
session.close()
# add a few new words
session = get_session()
import six
import model
from model import User
if __name__ == '__main__':
u1 = model.User(
dict(email='*****@*****.**',
preference=dict(
color='red',
size='xxxxxl',
)))
print u1
print u1.email
print u1.preference.color
print u1.preference.size
u2 = model.User(
dict(email='*****@*****.**',
pps=[
dict(color='red', size='m'),
dict(color='yellow', size='s'),
]))
for v in u2.pps:
print v.color, v.size
u3 = model.User(
dict(email='*****@*****.**',
xxx=dict(
a=[
dict(color='red1', size='m1'),
dict(color='yellow1', size='s1'),
