def test_forum_questions():
"""
Tests whether forum questions are properly added and referenced
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Adding user to empty database")
u1 = User(first_name='u1', last_name='u1', username='******', email='*****@*****.**', password='******', school='KU', grade='col_jun', state='KS')
db.session.add(u1)
db.session.commit()
messages.append("Adding 2 forum questions under the created user's username")
forumq1 = ForumQuestion(author_username='******', content='This is a test post')
forumq2 = ForumQuestion(author_username='******', content='This is another test post')
db.session.add(forumq1)
db.session.add(forumq2)
db.session.commit()
try:
messages.append("Testing whether there are 2 forum questions referenced by user")
assert len(list(u1.forum_questions)) == 2
except:
messages.append("There are not two referenced forum questions")
return (False, messages)
try:
messages.append("Testing whether the referenced forum questions are equivalent")
assert list(u1.forum_questions) == [forumq1, forumq2]
except:
messages.append("Different content")
return (False, messages)
return (True, messages)
def register():
form = RegisterForm()
if form.validate_on_submit():
if User.query.filter_by(email=form.email.data).first():
print(User.query.filter_by(email=form.email.data).first())
# User already exists
flash("You've already signed up with that email, log in instead!")
return redirect(url_for('login'))
hash_and_salted_password = generate_password_hash(
form.password.data, method='pbkdf2:sha256', salt_length=8)
new_user = User(
email=form.email.data,
name=form.name.data,
password=hash_and_salted_password,
)
db_session.add(new_user)
db_session.commit()
login_user(new_user)
return redirect(url_for("get_all_posts"))
return render_template("register.html",
form=form,
current_user=current_user)
def register():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None)
password = request.json.get('password', None)
if not username:
return jsonify({"msg": "Missing username parameter"}), 400
if not password:
return jsonify({"msg": "Missing password parameter"}), 400
maybe_user = User.query.filter_by(username=username).first()
if maybe_user:
return jsonify({"msg": "Username already registered"}), 409
new_user = User(username=username, password=password)
# Create sample document
if os.path.isfile(DOCUMENTS_FOLDER + "/document-SAMPLE.document"):
sample_document = get_document("SAMPLE")
id = uuid4()
dbDocument = DBDocument(id=id, name="Document", user=new_user, model=model_name)
save_document(sample_document, id)
db.session.add(dbDocument)
db.session.add(new_user)
db.session.commit()
# Identity can be any data that is json serializable
access_token = create_access_token(identity=username)
return jsonify(access_token=access_token, status="success", username=username), 200
def test_forum_posts():
"""
Tests whether forum posts are properly added and referenced
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Adding user to empty database")
u1 = User(first_name='u1', last_name='u1', username='******', email='*****@*****.**', password='******', school='Blue Valley West', grade='hs_jun', state='KS')
db.session.add(u1)
db.session.commit()
messages.append("Adding a user-referenced forum question to database")
forumq1 = ForumQuestion(author_username='******', content='This is a test post')
db.session.add(forumq1)
db.session.commit()
messages.append("Adding 2 forum posts to database, referenced by both username and forum question id")
forumpost1 = ForumPost(author_username='******', forum_question_id=forumq1.id, content='Test forum reply')
forumpost2 = ForumPost(author_username='******', forum_question_id=forumq1.id, content='Test forum reply 2')
db.session.add(forumpost1)
db.session.add(forumpost2)
db.session.commit()
try:
messages.append("Testing whether there are 2 forum posts referenced by username")
assert len(list(u1.forum_posts)) == 2
except:
messages.append("There are not 2 referenced forum posts by username")
return (False, messages)
try:
messages.append("Testing whether there are 2 forum posts referenced by forum question id")
assert len(list(forumq1.forum_posts)) == 2
except:
messages.append("There are not 2 referenced forum posts by forum question id")
return (False, messages)
return (True, messages)
def createUser(login_session):
newUser = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
session.add(newUser)
session.commit()
user = session.query(User).filter_by(email=login_session['email']).one()
return user.id
def _add_ctf_member(self, user, ctf):
member = self._get_member(user.id)
if not member:
member = User(user_id=user.id, name=user.name)
if not ctf in member.ctfs:
member.ctfs.append(ctf)
member.save()
return member
def create_user(db: Session, user: UserCreate) -> User:
""" Create a new entry in the database user table """
user_data = user.dict()
user_data["password"] = hash_password(user.password)
db_user = User(**user_data)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def greet(message):
user_id = message.from_user.id
user = session.query(User).get(user_id)
if user is None:
user = User(id=user_id)
session.add(user)
session.commit()
bot.reply_to(
message,
"Hello, %s! \n Send '/jobs' to get offers" % message.chat.username)
def addUser(netid, name, year):
# below is my shitty code for the secret admirers issue
# your code's not shitty homie ily <3
user = User(netid=netid,
name=name,
year=year,
visible=True,
secretAdmirers=0)
# user = User(netid=netid, name=name, year=year, visible=True)
db.session.add(user)
db.session.commit()
def create_user(user_in: UserIn):
user = User(first_name=user_in.first_name,
last_name=user_in.last_name,
user_name=user_in.user_name,
email=user_in.email,
password=user_in.password)
try:
user.save()
return user
except:
return False
def createUser():
newUser = User(name=login_session['username'],
email=login_session['email'],
picture=login_session['picture'])
DB_session.add(newUser)
DB_session.commit()
try:
user = DB_session.query(User).filter_by(
email=login_session['email']).one()
return user.id
except NoResultFound:
return None
def registerUser(name, email, passwd):
user = db.query(User).filter_by(name=name).first()
if not user:
user = db.query(User).filter_by(email=email).first()
if not user:
user = User(name=name, email=email)
user.set_passwd(passwd)
db.add(user)
db.commit()
return None
return 'This email has already been registered!'
return 'This name is already been changed!'
def create_or_get_user(username):
session = Session()
user = session.query(User).filter_by(username=username).first()
if not user:
user = User(username=username)
session.add(user)
session.commit()
user_id = user.id
session.close()
return user_id
def create_login():
from forms import register_form
form = register_form(request.form)
if request.method == 'POST' and form.validate():
user = User()
form.populate_obj(user)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
login_user(user)
return redirect(url_for('index'))
return render_template("reg.html", form=form)
def test_unique_email():
"""
Tests whether only unique email addresses are allowed
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Attempting to add 2 users with same email address to the empty database")
u1 = User(first_name='u1', last_name='u1', username='******', email='*****@*****.**', password='******', school='KU', grade='col_jun', state='KS')
db.session.add(u1)
db.session.commit()
u2 = User(first_name='u2', last_name='u2', username='******', email='*****@*****.**', password='******', school='KU', grade='col_jun', state='KS')
try:
db.session.add(u2)
db.session.commit()
except:
db.session.rollback()
try:
messages.append("Testing whether the number of database users is 1")
assert len(list(User.query.all())) == 1
except:
messages.append("Not one user in database")
return (False, messages)
return (True, messages)
def register_new_user(form_email, form_pw, form_data):
"""Funkcja rejestrująca nowego użytkownika, parametry funkcji z wtforms."""
unique_value = str(uuid.uuid4())
new_user = User(
email=form_email.email.data,
password=bcrypt.hashpw(form_pw.password.data.encode('UTF_8'),
bcrypt.gensalt()),
token_id=serializer.dumps([form_email.email.data, unique_value]),
name=form_data.name.data,
last_name=form_data.last_name.data,
city=form_data.city.data,
zip_code=form_data.zip_code.data,
street=form_data.street.data,
house_number=form_data.house_number.data,
flat_number=form_data.flat_number.data)
return new_user
def register():
creds = request.get_json()
user = Session.query(User).filter_by(
email=creds.get('email'), password=creds.get('password')).first()
if user:
abort(409, 'User exists.')
try:
new_user = User(email=creds.get('email'),
password=creds.get('password'))
Session.add(new_user)
Session.commit()
return 'Success!'
except Exception as e:
print(e)
Session.rollback()
abort(500)
def build_sample_db():
db.create_all()
db.drop_all()
db.create_all()
user = User()
user.first_name = 'admin'
user.last_name = 'admin'
user.login = '******'
user.email = user.login + "@example.com"
user.password = generate_password_hash('admin')
db.session.add(user)
db.session.add(RequestType(type='User'))
db.session.add(RequestType(type='Bot'))
db.session.add(Technique(name='chi_square'))
db.session.add(Technique(name='Kolmogorov-Smirnov'))
db.session.commit()
def update_user_by_chat_id(chat_id, first_name, last_name, username):
"""
Обновление информации о пользователе
"""
try:
us = User.objects.get(chat_id=chat_id)
except DoesNotExist:
us = User(chat_id=chat_id)
us.first_name = first_name
us.last_name = last_name
us.username = username
try:
us.save()
except Exception:
pass
def register():
email = request.form['email']
test = User.query.filter_by(email=email).first()
if test:
return jsonify(message='That email already exists'), 409
else:
first_name = request.form['first_name']
last_name = request.form['last_name']
password = request.form['password']
user = User(first_name=first_name,
last_name=last_name,
password=password)
db.session.add(user)
db.session.commit()
return jsonify(message='User created successfully'), 201
def post(self):
orig_user = self.request.get("username")
username = cgi.escape(orig_user, quote=True)
password = cgi.escape(self.request.get("password"), quote=True)
verify = cgi.escape(self.request.get("verify"), quote=True)
email = cgi.escape(self.request.get("email"), quote=True).strip()
name = validate_username(username)
passw = validate_password(password)
ver = validate_verify(password, verify)
mail = validate_email(email)
res = {
"username": username,
"error_name": "" if name else "That's not a valid username.",
"password": password,
"error_pass": "" if passw else "That wasn't a valid password.",
"verify": verify,
"error_ver":
"" if not passw or ver else "Your passwords didn't match.",
"mail": email,
"error_mail": "" if mail else "That's not a valid email."
}
exists = False
if name:
# check if user exists in the User db
users = db.GqlQuery("SELECT * FROM User WHERE username=:1",
username)
user_len = 0
for user in users:
user_len += 1
exists = user_len != 0
if name and passw and ver and mail and not exists:
user = User(username=username,
password=enc.hash_passw(password),
email=email)
user.put()
user_key = str(user.key().id())
hidden_key = enc.encode(user_key)
cookie_val = str("user_id=%s|%s; Path=/" % (user_key, hidden_key))
self.response.headers.add_header('Set-Cookie', cookie_val)
self.redirect('/')
else:
if exists:
res["error_name"] = "Username '%s' already taken." % username
self.render("registration.html", **res)
def signup():
if request.method == 'GET':
pass
elif request.method == 'POST':
username = request.form.get('username')
email = request.form.get('email')
exists_username = db.session.query(
db.session.query(User).filter_by(username=username).exists()).scalar()
exists_email = db.session.query(
db.session.query(User).filter_by(email=email).exists()).scalar()
if exists_username and exists_email:
return jsonify(dict(code=0, error="Username e email já existem"))
if exists_username and not exists_email:
return jsonify(dict(code=0, error="Username já existe"))
if not exists_username and exists_email:
return jsonify(dict(code=0, error="Email já existe"))
new_user = User(un=username,
e=email,
pw=request.form.get('password'),
gender=int(request.form.get('gender')),
dob=request.form.get('dob_string'),
tribe_id=int(request.form.get('tribe_id')),
cz=int(request.form.get('city_zone_id'))
)
db.session.add(new_user)
db.session.flush()
if not exists(join(USER_IMAGES_FOLDER, str(new_user.id))):
makedirs(join(USER_IMAGES_FOLDER, str(new_user.id)))
if new_user.gender == 1:
image = Image.open(join(USER_IMAGES_FOLDER, 'female.png')).convert('RGB')
else:
image = Image.open(join(USER_IMAGES_FOLDER, 'female.png')).convert('RGB')
image.save(join(USER_IMAGES_FOLDER, str(new_user.id) + "\\0.jpg"), optimize=True, quality=85,
format='JPEG')
try:
db.session.commit()
return jsonify(dict(code=1))
except exc.SQLAlchemyError:
return jsonify(dict(code=0, error="Erro no servidor, por favor tente mais tarde"))
def register():
user_data = request.get_json()
# 判断获取结果
if not user_data:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
name = user_data.get('name')
title = user_data.get('title')
organization = user_data.get('organization')
email = user_data.get('email')
password = user_data.get('password')
if not re.match(
r"^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$",
email):
return jsonify(errno=RET.PARAMERR, errmsg="邮箱格式不正确")
# 检查参数的完整性
if not all([name, title, organization, email, password]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 判断用户是否已经注册
try:
user = User.query.filter_by(email=email).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据库异常')
else:
# 判断查询结果
if user:
return jsonify(errno=RET.DATAEXIST, errmsg='邮箱号已注册')
user = User()
user.name = name
user.title = title
user.organization = organization
user.email = email
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
# 如果提交数据发生异常,需要进行回滚
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存用户信息失败')
return jsonify(errno=RET.OK, errmsg='OK',
data=user.to_dict()) # 登录成功，重定向到登录页
def registration():
flash("Поздавляю вас с регистарцией на нашем сайте")
if request.method == "POST":
from db_models import User, Password, db
login = request.form.get('login', '')
pasw = request.form.get('password', '')
if not User.query.filter_by(login=login).first():
print("i'm where!")
new_user = User(login=login)
pas = Password(pas=pasw, user=new_user)
#db.session.add(Password(pas=pasw, user=User(login=login)))
db.session.add(user)
db.session.add(pas)
db.session.commit()
session['known'] = True
session['name'] = login
return redirect(url_for("user"))
return render_template("registration.html")
def test_non_completed_user_not_in_db():
"""
Tests whether a User object with incomplete parameters is denied from database
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Creating user with incomplete parameters")
u1 = User(first_name='u1', last_name='u1', username='******', password='******')
try:
messages.append("Attempting to add incomplete user to database")
db.session.add(u1)
db.session.commit()
except:
messages.append("Incomplete user not added to database; exception thrown")
db.session.rollback()
try:
messages.append("Testing whether a query list for users returns empty")
assert User.query.all() == []
except:
messages.append("User query nonempty")
return (False, messages)
return (True, messages)
def setup_flask():
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024
app.config['JWT_SECRET_KEY'] = "supersecretkeyhastochange"
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = f'sqlite:///{DB_PATH}'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
CORS(app)
Compress(app)
jwt = JWTManager(app)
# init DB
with app.app_context():
db.init_app(app)
if not os.path.exists(DB_PATH):
db.create_all()
admin = User(username="******", password="******")
if db.session.query(User).filter_by(username='******').count() < 1:
db.session.add(admin)
db.session.commit()
return app
def test_password_verification():
"""
Tests the password verification method
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Adding a user with known password to the empty database")
u1 = User(first_name='u1', last_name='u1', username='******', email='*****@*****.**', password='******', school='KU', grade='col_jun', state='KS')
db.session.add(u1)
db.session.commit()
try:
messages.append("Verfiying the known password")
assert u1.test_password('password') == True
except:
messages.append("Verification failed")
return (False, messages)
try:
messages.append("Testing verification of incorrect passwords")
assert u1.test_password('diffpassword') == False
except:
messages.append("Verification failed")
return (False, messages)
return (True, messages)
def test_user_posts():
"""
Tests whether user post objects are properly added and referenced
:return: tuple (boolean, message list)
"""
messages = []
messages.append("Adding user to empty database")
u1 = User(first_name='u1', last_name='u1', username='******', email='*****@*****.**', password='******', school='Blue Valley West', grade='hs_jun', state='KS')
db.session.add(u1)
db.session.commit()
messages.append("Adding 2 user posts under the created user's username")
p1 = UserPost(author_username='******', content='Test post')
p2 = UserPost(author_username='******', content='Test post 2')
db.session.add(p1)
db.session.add(p2)
db.session.commit()
try:
messages.append("Testing whether there are 2 user posts referenced by user")
assert len(list(u1.user_posts)) == 2
except:
messages.append("There are not 2 referenced user posts by username")
return (False, messages)
return (True, messages)
CORS(app)
Compress(app)
jwt = JWTManager(app)
from shared import db
from db_models import User, Document as DBDocument
with app.app_context():
db.init_app(app)
import os.path
if not os.path.exists(DB_NAME):
db.create_all()
admin = User(username="******", password="******")
db.session.add(admin)
db.session.commit()
from myseq2seq.seq2seq import seq2seq_model
from myseq2seq.document import Document as Document, Sentence
from myseq2seq.scorer import Scorer
from myseq2seq.keyphrase_extractor import DomainSpecificExtractor
@app.route('/api/auth/login', methods=['POST'])
def login():
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None)
def login_oauth():
if "access_token" not in session:
return redirect(url_for("index"))
params = {
"site": "ru.stackoverflow",
"order": "desc",
"sort": "reputation",
"key": STACKEXCHANGE_CLIENT_KEY,
"access_token": session['access_token']
}
r = requests.get(STACKEXCHANGE_OAUTH_ME_ENDPOINT, data=params)
data = json.loads(r.text)
account_id = -1
user_id = -1
display_name = ""
role = ""
reputation = -1
profile_image = ""
link = ""
if data.get("items", None) is not None:
for item in data["items"]:
if item.get("account_id", None) is not None:
account_id = item["account_id"]
if item.get("user_id", None) is not None:
user_id = item["user_id"]
if item.get("display_name", None) is not None:
display_name = item["display_name"]
if item.get("user_type", None) is not None:
role = item["user_type"]
if item.get("reputation", None) is not None:
reputation = item["reputation"]
if item.get("profile_image", None) is not None:
profile_image = item["profile_image"]
if item.get("link", None) is not None:
link = item["link"]
if account_id < 0 or user_id < 0 or display_name == "":
logging.error("OAuth response: %s. Url: %s" % (r.text, r.url))
logging.error("account_id: %s, user_id: %s, display_name: %s" % (str(account_id), str(user_id), display_name))
return redirect(url_for("no_way"))
adder = DBModelAdder()
adder.start()
user = User.get_by_account_id(account_id)
if user is None:
adder.add(User(account_id,
user_id,
display_name,
reputation,
profile_image,
link,
role))
else:
if user.username != display_name:
user.username = display_name
if user.role != role:
user.role = role
if user.reputation != reputation:
user.reputation = reputation
if user.profile_image != profile_image:
user.profile_image = profile_image
if user.profile_link != link:
user.profile_link = link
adder.add(user)
adder.done()
session["account_id"] = account_id
return redirect(url_for("index"))
