def seed_db():
db.session.add(
models.User(username="******",
email="*****@*****.**",
password="******"))
db.session.add(
models.User(username="******",
email="*****@*****.**",
password="******"))
db.session.commit()
def register(self, request):
data = (request.data).dict()
person = models.Person()
person.first_name = data["first_name"]
person.last_name = data["last_name"]
person.phone_no = data["phone_no"]
person.email = data["email"]
person.image = None
person.password = make_password(data["password"])
if data["user_type"] == '1':
user = models.User()
person.user_type = 1
user.address = data["address"]
user.save()
person.user_id = user.id
person.organizer_id = None
elif data["user_type"] == '2':
organizer = models.Organizer()
person.user_type = 2
organizer.address = data["address"]
organizer.organization = data["organization"]
organizer.experience = data["experience"]
organizer.cnic = data["cnic"]
organizer.save()
person.organizer_id = organizer.id
person.user_id = None
person.save()
serializer = serializers.PersonSerializer(person)
return Response(status=status.HTTP_200_OK, data=serializer.data)
def register():
try:
item = json.loads(request.data)
username = item.get('username', '')
if username == '':
raise Exception(u'The username is blank')
if models.User.query.filter_by(username=username).count() > 0:
raise Exception(u'The username already exists')
password = item.get('password', '')
if len(password) < 5 or len(password) > 16:
raise Exception(u'Password must be 6-16 characters')
user = models.User(username='', password='')
user.from_dict(item)
user.get_session.commit()
return view.response(total=1,
fields={
'username': user.username,
'token': user.token
})
except Exception as e:
models.session.rollback()
return view.response(status=500, messages=[e.message])
def authenticate(self, request):
jwt_value = request.META.get('HTTP_AUTHORIZATION')
if jwt_value:
try:
# jwt提供了通过三段token,取出payload的方法，并且有校验功能
payload = jwt_decode_handler(jwt_value)
except jwt.ExpiredSignature:
raise AuthenticationFailed("已过期")
except jwt.InvalidTokenError:
raise AuthenticationFailed("用户非法")
except Exception as e:
raise AuthenticationFailed(str(e))
# 因为payload就是用户信息的字典
print(payload)
# 要得到user对象
# 1.去查数据库
user = models.User.objects.get(pk=payload.get('user_id'))
# 2. 不查库
user = models.User(id=payload.get('user_id'), username=payload.get('username'))
return user, jwt_value
# 没有值，直接抛异常
raise AuthenticationFailed('您没有携带认证信息')
def register_user():
""" Registers a yummy recipes user """
if not request.get_json():
abort(400)
request_data = request.get_json()
# validate the user
validation_errors = ValidateUser.validate_user_on_reg(request_data)
# check if errors occurred
if validation_errors:
return jsonify({"errors": validation_errors}), 422
# check if user already exists
existing_user = models.User.query.filter_by(
email=format_email(request_data["email"])).first()
if existing_user:
return jsonify({
"errors":
[f"Email address \'{request_data['email']}\' already in use"]
}), 422
# register the user
user = models.User(format_email(request_data["email"]),
request_data["firstname"], request_data["lastname"],
request_data["password"])
user.save_user()
return jsonify({
"messages":
["You have been successfully registered and you can now login"],
"data":
user.user_details
}), 201
def create_user(db: Session, user: schemas.UserCreate):
fake_hashed_password = user.password + "notreallyhashed"
db_user = models.User(email=user.email,
name=user.name,
hashed_password=fake_hashed_password)
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
def populate_users():
for user in users["users"]:
user_ORM = models.User(email=user["email"],
username=user["username"],
password=user["password"],
name=user["name"],
latitude=user["latitude"],
longitude=user["longitude"])
db.session.add(user_ORM)
db.session.commit()
def post(self, *args, **kwargs):
post_data = self.post_data()
username = post_data.get('username')
user = models.User.query.filter_by(username=username).first()
if not user:
user = models.User(username=username)
db.session.add(user)
db.session.commit()
session['id'] = user.id
return self.redirect_view('home')
def create(self, db, *, obj_in: schemas.UserCreate) -> models.User:
db_obj = models.User(
email=obj_in.email,
hashed_password=get_password_hash(obj_in.password),
full_name=obj_in.full_name,
is_superuser=obj_in.is_superuser,
)
db.add(db_obj)
db.commit()
db.refresh(db_obj)
return db_obj
def create_user(
session: "db.Session",
email,
password,
badge=None,
username=None,
description=None,
newsletter_opt_in=False,
) -> "models.User":
"""Creates a User and adds them to the database"""
# Hash the password
password = generate_password_hash(password)
if not badge or not re.search(r"^[0-9][a-z0-9*&+=-]+[a-z0-9*!]$", badge):
badge = generate_badges(session, single=True)
username = (username if username else choice([
"Aradel Summergaard",
"Brennen Blackcloud",
"Coal Roarkwin",
"Dimona Odinstar",
"Jessa Na Ni",
"Leo Sunshadow",
"Lulu Firststone",
"Maeoni Viper",
"Namine Hymntide",
"Noah Redmoon",
"Odette Diamondcrest",
"Orrick Gilstream",
"Rin Northfell",
"Saria Guideman",
"Victoria Glassfire",
"Echo Greystorm",
"Jericho Kill",
"Astrea",
"Koji Wolfcub",
"Harold Westraven",
"Sembali Grimtongue",
"Rimea Careworn",
"Xander Heartsblood",
"Fiona Mercywind",
"James Endersight",
]))
user = models.User(
email=email,
password=password,
badge=badge,
username=username,
description=description,
newsletter_opt_in=newsletter_opt_in,
)
session.add(user)
session.commit()
return user
def validate(self, data):
user = api_models.User(**data)
password = data.get('password')
errors = dict()
try:
validate_password(password=password, user=user)
except django_core_exceptions.ValidationError as e:
errors['password'] = list(e.messages)
if errors:
raise rest_serializers.ValidationError(errors)
return data
def post(self, request, *args, **kwargr):
token = kwargr.get("token", None)
if token is not None:
try:
logger.info(token)
decoded = jwt.decode(token.encode(),
config('EMAIL_VERIFICATION_SECRET'),
leeway=10,
algorithms=['HS256'])
user = models.User(email=decoded['email'],
name=decoded['name'])
if request.data.get("password") == None:
return Response({"error": "Password not found in request"},
status=status.HTTP_400_BAD_REQUEST)
serializer = serializers.UserProfileSerializer(
data={
"email": decoded['email'],
"name": decoded['name'],
"password": request.data.get("password")
})
if serializer.is_valid():
user = serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
except jwt.ExpiredSignatureError:
return Response(
{"error": "Request timeout. Please start over"},
status=status.HTTP_408_REQUEST_TIMEOUT)
except (jwt.exceptions.DecodeError, JSONDecodeError,
ValueError) as e:
logger.exception("Token value error exception. Token : %s", e)
return Response({"error": "Invalid token"},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception("Token exception : %s", e)
return Response(
{"error": "Some error occured please try again"},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"error": "Token not found"},
status=status.HTTP_422_UNPROCESSABLE_ENTITY)
def create_users(count):
results = []
for _ in range(count):
username = fake.simple_profile()['username']
username += fake.pystr(max_chars=15 - len(username))
u = models.User(
email=fake.email(),
username=username,
first_name=fake.first_name(),
last_name=fake.last_name(),
password=fake.password(),
)
u.save()
results.append(u)
return results
def create_user(db: Session, user: schemas.UserCreate):
hpassword = hash_password(user.password)
db_user = models.User(email=user.email,
password=hpassword,
username=user.username,
name=user.name,
surname=user.surname,
role=user.role,
dateofbirth=user.dateofbirth)
db.add(db_user)
db.commit()
db.refresh(db_user)
print(db_user.email)
url = 'http://0.0.0.0:8003/notificationsconfirm/' + db_user.email + '&' + str(
1)
response = requests.post(url)
return db_user
def _initialize(self):
"""
Sub PJT 1에서 만든 Dataframe을 이용하여 DB를 초기화합니다.
"""
print("[*] Loading data...")
df = self._load_dataframes()
print("[*] Initializing stores...")
models.Store.objects.all().delete()
stores = df["stores"]
stores_bulk = [
models.Store(id=store.id,
store_name=store.store_name,
area=store.area,
tel=store.tel,
address=store.address,
latitude=store.latitude,
longitude=store.longitude,
category=store.category,
classification=store.classification,
price_mean=store.price_mean)
for store in stores.itertuples()
]
models.Store.objects.bulk_create(stores_bulk)
print("[+] Stores Complete")
print("[*] Initializing users...")
models.User.objects.all().delete()
users = df['users']
users_bulk = [
models.User(id=user.id,
gender=user.gender,
age=user.age,
grade=user.grade,
vendor=user.vendor,
refresh_token=user.refresh_token)
for user in users.itertuples()
]
models.User.objects.bulk_create(users_bulk)
print("[+] Users Complete")
print("[*] Initializing reviews...")
models.Review.objects.all().delete()
reviews = df['reviews']
reviews_bulk = [
models.Review(id=review.id,
store=models.Store.objects.get(id=review.store),
user=models.User.objects.get(id=review.user),
score=review.score,
content=review.content,
reg_time=review.reg_time,
taste=review.taste,
service=review.service,
price_satisfaction=review.price_satisfaction,
interior=review.interior)
for review in reviews.itertuples()
]
models.Review.objects.bulk_create(reviews_bulk)
print("[+] Reviews Complete")
print("[*] Initializing Menu...")
models.Menu.objects.all().delete()
menu = df['menu']
menu_bulk = [
models.Menu(id=m.id,
store=models.Store.objects.get(id=m.store),
menu_name=m.menu_name,
price=m.price) for m in menu.itertuples()
]
models.Menu.objects.bulk_create(menu_bulk)
print("[+] Menu Complete")
print("[*] Initializing BHour...")
models.BHour.objects.all().delete()
b_hours = df['bhours']
bhour_bulk = [
models.BHour(id=b_hour.id,
store=models.Store.objects.get(id=b_hour.store),
type=b_hour.type,
week_type=b_hour.week_type,
mon=b_hour.mon,
tue=b_hour.tue,
wed=b_hour.wed,
thu=b_hour.thu,
fri=b_hour.fri,
sat=b_hour.sat,
sun=b_hour.sun,
start_time=b_hour.start_time,
end_time=b_hour.end_time,
etc=b_hour.etc) for b_hour in b_hours.itertuples()
]
models.BHour.objects.bulk_create(bhour_bulk)
print("[+] BHour Complete")
print("[+] Done")
def follow_suggestions(self, category='business') -> list:
suggestions = get_follower_suggestions(self.api, category)
users = [models.User(u, self.api) for u in suggestions]
return users
def users_create(user: schemas.UserCreate, db: Session = Depends(get_db)) -> dict:
user = models.User(username=user.username, email=user.email)
db.add(user)
db.commit()
db.refresh(user)
return user
def fake_decode_token(token):
return models.User(name=token + "fakedecoded", email="*****@*****.**")
def add_user_(user_name):
return models.User(name=user_name).put().get()
def test_invalid_user(kwarg):
with pytest.raises(pydantic.error_wrappers.ValidationError):
models.User(**kwarg)
def send_mail(recipient, subject, body):
msg = MIMEMultipart()
msg['From'] = app.config['EMAIL_SENDER']
msg['To'] = recipient
msg['Subject'] = subject
message = body
msg.attach(MIMEText(message))
mailserver = smtplib.SMTP(app.config['SMTP_URL'], app.config['SMTP_PORT'])
mailserver.ehlo()
mailserver.starttls()
mailserver.ehlo()
mailserver.login(app.config['SMTP_USER'], app.config['SMTP_USER'])
mailserver.sendmail(app.config['EMAIL_SENDER'], recipient, msg.as_string())
mailserver.quit()
from api import routes
if app.config['DEBUG']:
from api import models
with models.pony.orm.db_session:
admin = models.User.get(email='*****@*****.**')
if admin is None:
print(generate_password_hash('admin').decode("utf-8"))
admin = models.User(
email='*****@*****.**',
password=generate_password_hash('admin').decode("utf-8"),
active=True,
admin=True)
models.pony.orm.commit()
def kakao_login(self, request):
access_token = request.data.get("access_token", "access_token")
vendor = request.data.get("provider", "provider")
profile_request = requests.get(
'https://kapi.kakao.com/v2/user/me',
headers={'Authorization': f'Bearer {access_token}'})
profile_json = profile_request.json()
kakao_account = profile_json['kakao_account']
kakao_id = profile_json['id']
if models.User.objects.filter(id=kakao_id, vendor=vendor).exists():
user = models.User.objects.filter(id=kakao_id, vendor=vendor).get()
user = {
'id': user.id,
'gender': user.gender,
'age': user.age,
'nickname': user.nickname,
'grade': user.grade,
'vendor': user.vendor
}
token = jwt.encode(
{
'user': user,
'exp':
datetime.datetime.now() + datetime.timedelta(hours=3),
'access_token': access_token
},
settings.SECRET_KEY,
algorithm='HS256')
token = token.decode('utf-8')
return JsonResponse({'token': token}, status=200)
else:
nickname = kakao_account['profile'].get('nickname', None)
age_range = kakao_account.get('age_range', '20~29')
age = (int(age_range.split('~')[0]) +
int(age_range.split('~')[1])) / 2
age = round(2020 - age)
gender = kakao_account.get('gender', None)
if gender is not None:
if gender == 'female':
gender = '여'
else:
gender = '남'
models.User(id=kakao_id,
gender=gender,
age=age,
nickname=nickname,
grade=0,
vendor=vendor,
refresh_token=None).save()
user = models.User.objects.filter(id=kakao_id).get()
user = {
'id': user.id,
'gender': user.gender,
'age': user.age,
'nickname': user.nickname,
'grade': user.grade,
'vendor': user.vendor
}
token = jwt.encode(
{
'user': user,
'exp':
datetime.datetime.now() + datetime.timedelta(hours=3),
'access_token': access_token
},
settings.SECRET_KEY,
algorithm='HS256')
token = token.decode('utf-8')
return JsonResponse({'token': token}, status=200)
def RegisterUser():
d = request.get_json()
try:
email = d['email']
password = d['password']
except KeyError:
return 'Missing fields in request form', 400
# Test password
password_test = zxcvbn(password)
if password_test['score'] < 3:
return json.dumps({
'message':
password_test['feedback']['warning'] + ' ' +
''.join(password_test['feedback']['suggestions'])
}), 422
if 'first_name' in d:
first_name = d['first_name']
else:
first_name = ''
if 'last_name' in d:
last_name = d['last_name']
else:
last_name = ''
# See if email is valid
valid_email = False
if re.match(
'^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$',
email) is not None:
email_user, email_domain = email.split('@')
try:
dns.resolver.query(email_domain, 'MX')
valid_email = True
except dns.resolver.NXDOMAIN:
pass
if valid_email:
if pony.orm.exists(u for u in models.User if u.email == email):
return 'Conflict, a user already exist with same email', 409
enc_password = generate_password_hash(password).decode("utf-8")
user = models.User(email=email,
password=enc_password,
first_name=first_name,
last_name=last_name,
admin=False,
active=False,
balance=0.,
organization_role=0)
pony.orm.commit()
resp = Response(json.dumps({'user_id': user.id}), status=201)
resp.headers['Location'] = '/users/{}'.format(user.id)
subject = "Activate your ERP-CRM account"
body = """Hello,\n\nYou successfully registered to ERP-CRM!\n\nYour account isn't activated yet, please follow this link to activate it:\n /account?email_verification_token={}\nYou will be asked first to login with your credentials.\n""".format(
generate_confirmation_token(user.email))
send_mail(email, subject, body)
return resp
# else:
#
else:
return 'Email is not valid', 400
def test_valid_user(kwarg):
assert kwarg == models.User(**kwarg).dict(exclude_unset=True)