def init_db(db: Session) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_email(db, email=settings.USER_ADMIN_EMAIL)
if not user:
user_in = schemas.UserCreate(
email=settings.USER_ADMIN_EMAIL,
firstname=settings.USER_ADMIN_FIRSTNAME,
password=settings.USER_ADMIN_PASSWORD,
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in)
user = crud.user.get_by_email(db, email=settings.USER_TEST_EMAIL)
if not user:
user_in = schemas.UserCreate(
email=settings.USER_TEST_EMAIL,
firstname=settings.USER_TEST_FIRSTNAME,
password=settings.USER_TEST_PASSWORD,
is_superuser=False,
)
user = crud.user.create(db, obj_in=user_in)
def init_db(db: Session) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_email(db, email=settings.FIRST_SUPERUSER)
if not user:
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
type_="admin",
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
student_email = "*****@*****.**"
user = crud.user.get_by_email(db, email=student_email)
if not user:
user_in = schemas.UserCreate(
email=student_email,
password=settings.FIRST_SUPERUSER_PASSWORD,
type_="student",
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
student_email = "*****@*****.**"
user = crud.user.get_by_email(db, email=student_email)
if not user:
user_in = schemas.UserCreate(
email=student_email,
password=settings.FIRST_SUPERUSER_PASSWORD,
type_="student",
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
def init_db(db: Session) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_email(db, email=settings.FIRST_SUPERUSER)
print("INITIAL USER", user)
if not user:
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
other_user = crud.user.get_by_email(
db,
email="*****@*****.**"
)
print("OTHER USER", other_user)
if not other_user:
user_in = schemas.UserCreate(
email="*****@*****.**",
password='******',
is_superuser=False,
)
other_user = crud.user.create(db, obj_in=user_in) # noqa: F841
lines = []
print("USERS", user.__dict__, other_user.__dict__)
print("GENERATING DATA")
for current_user in [user, other_user]:
print("\t FOR USER ", current_user.__dict__)
for line_num in range(10):
line: Line = Line(
title=f"Line_{uuid4()}",
description=f"Line description {uuid4()}",
owner_id=current_user.id
)
print("\t\t GENERATED LINE", line.__dict__)
for item_num in range(100):
item = Item(
title=f"Item_{uuid4()}",
description=f"Item description {uuid4()}",
owner_id=current_user.id
)
line_item: LineItem = LineItem(
owner_id=current_user.id,
line=line,
item=item
)
line.line_items.append(line_item)
print("\t\t\t GENERATED LINE ITEM", item.__dict__)
lines.append(line)
db.add_all(lines)
db.commit()
def init_db(db: Session) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_email(db, email=settings.FIRST_SUPERUSER)
if not user:
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
first_name='Administrator',
last_name='FastAPI',
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
if user:
print(f"...created superuser {user.email}")
for user in init_data.BASE_USER:
if not crud.user.get_by_email(db, email=user['email']):
user_in = schemas.UserCreate(
email=user['email'],
password=init_data.generate_random_password(),
first_name=user['first_name'],
last_name=user['last_name'],
)
user = crud.user.create(db, obj_in=user_in)
if user:
print(f"...created user {user.email}")
for store in init_data.BASE_STORES.split("\n"):
try:
internal_id, name, ceo = store.split(";")
if not crud.store.get_by_kwargs(db,
internal_id=internal_id).first():
store_in = schemas.StoreCreate(
internal_id=internal_id,
name=name.upper(),
support=models.store.StoreSupport.DISABLED.name,
)
store = crud.store.create(db, obj_in=store_in)
if store:
print(f"...created store {store.internal_id} {store.name}")
except ValueError:
pass
print("base_dir", settings.SERVER_BASE_DIR)
def create_user_open(
*,
db: Session = Depends(deps.get_db),
password: str = Body(...),
email: str = Body(...),
first_name: str = Body(...),
last_name: str = Body(...)
) -> Any:
"""
Create new user called from front end
:return:
"""
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(status_code=403,
detail="Registration current not allowed")
user = crud.user.get_by_email(db, email=email)
if user:
raise HTTPException(
status_code=400,
detail="The user with this username already exists in the system")
user_in = schemas.UserCreate(first_name=first_name,
last_name=last_name,
email=email,
password=password)
user = crud.user.create(db=db, obj_in=user_in)
return user
async def create_user_open(
*,
user_in: schemas.UnprivilegedUserCreate,
db: Session = Depends(deps.get_db),
redis: aioredis.Redis = Depends(deps.get_redis),
) -> Any:
"""
Create new user without the need to be logged in.
"""
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(
status_code=403,
detail="Open user registration is forbidden on this server",
)
user = crud.user.get_by_email(db, email=user_in.email)
if user is not None:
raise HTTPException(
status_code=400,
detail="The user with this username already exists in the system",
)
user_in = schemas.UserCreate(user_in.dict(exclude_unset=True))
user = await crud.user_cachedb.create(db, redis, obj_in=user_in)
if settings.EMAILS_ENABLED and user_in.email:
send_new_account_email(email_to=user_in.email,
username=user_in.email,
password=user_in.password)
def create_dev_data(db: Session) -> None:
"""
Create some dummy data for the development environment.
"""
# Create a non-staff user for testing purposes
user = crud.user.get_by_email(db, email="*****@*****.**")
if not user:
user_in = schemas.UserCreate(
email="*****@*****.**",
password="******",
is_superuser=False,
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
else:
db.query(models.ShortUrl).filter(models.ShortUrl.owner_id == user.id).delete()
# Create some shortened URLs and associate them with the test user.
for _ in range(310):
obj_in = schemas.ShortUrlCreate(
destination=f"https://google.com/?q={get_random_string(40)}"
)
crud.shorturl.create_with_owner(
db=db,
owner_id=user.id,
obj_in=obj_in,
)
def test_authenticate_user_success(db: Session) -> None:
faker = Faker()
profile = faker.profile()
email = profile.get("mail", None)
username = profile.get("username", None)
password = "******"
user_in = schemas.UserCreate(username=username,
email=email,
password=SecretStr(password))
user = crud.user.create(db=db, obj_in=user_in)
wrong_email = email + "xxx"
authenticated_user = crud.user.authenticate(db,
email=wrong_email,
password=SecretStr(password))
assert not authenticated_user
wrong_password = password + "xxx"
authenticated_user = crud.user.authenticate(
db, email=email, password=SecretStr(wrong_password))
assert not authenticated_user
authenticated_user = crud.user.authenticate(db,
email=email,
password=SecretStr(password))
assert authenticated_user
assert user.email == authenticated_user.email
def register(
*,
db: Session = Depends(get_db),
password: str = Body(...),
email: EmailStr = Body(...),
full_name: str = Body(None),
background_tasks: BackgroundTasks,
):
"""register a new user"""
# why not use UserCreate schema? if used, user can control self become a superuser
# only USERS_OPEN_REGISTRATION is True can register
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(status_code=403, detail="forbidden for register")
user = crud.user.get_by_email(db, email=email)
if user:
raise HTTPException(status_code=400, detail="User already exists")
user_in = schemas.UserCreate(password=password,
email=email,
full_name=full_name)
user = crud.user.create(db, obj=user_in)
# send confirm email
if settings.EMAILS_ENABLED and user.email:
confirm_token = create_access_token(
subject=email,
expires_delta=timedelta(settings.EMAIL_CONFIRM_TOKEN_EXPIRE))
background_tasks.add_task(send_confirm_email,
email_to=user.email,
token=confirm_token)
return user
def createsuperuser(noinput: bool = typer.Option(
False, help="create superuser in env")):
db = SessionLocal()
if noinput:
username = settings.SUPERUSER_NAME
email = settings.SUPERUSER_EMAIL
password = settings.SUPERUSER_PASSWORD
else:
username = typer.prompt("username:"******"admin")
email = typer.prompt("email:", default="*****@*****.**")
password = typer.prompt("password:"******"This email superuser already exist")
exit(0)
user_db = crud.user.create_superuser(db, obj=superuser)
typer.echo("superuser created.")
def create_user_open(
*,
db: Session = Depends(deps.get_db),
password: str = Body(...),
email: EmailStr = Body(...),
full_name: str = Body(None),
) -> Any:
"""
Create new user without the need to be logged in.
"""
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(
status_code=403,
detail="Open user registration is forbidden on this server",
)
user = crud.user.get_by_email(db, email=email)
if user:
raise HTTPException(
status_code=400,
detail="The user with this username already exists in the system",
)
user_in = schemas.UserCreate(password=password,
email=email,
full_name=full_name)
user = crud.user.create(db, obj_in=user_in)
return user
def init_user_data(db: Session) -> None:
print(f"#### Creating first user: {settings.FIRST_SUPERUSER}")
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
def test_user_exists(client, db_user_factory):
user = db_user_factory()
user_data = schemas.UserCreate(**user.__dict__)
resp = client.post(
'/user/register',
json=user_data.dict()
)
assert resp.status_code == 409
assert resp.json()['detail'] == 'A User with this email already exists'
def create_random_user(db: Session, fake: Faker):
user = schemas.UserCreate(full_name=fake.name(),
email=fake.email(),
password="******")
user_in_db = crud.user.get_by_email(db, email=user.email)
if user_in_db:
return user
user_db = crud.user.create(db, obj=user)
return user
def generate_user():
avatar_val = random.randint(0, 100000000000)
return schemas.UserCreate(
email=fake.email(),
name=fake.name(),
password='******',
login=fake.user_name(),
avatar_url=f'https://www.gravatar.com/avatar/{avatar_val}?d=identicon&s=512&r=g'
)
def test_create_user_role(db: Session) -> None:
email = random_email()
password = random_lower_string()
user_in = schemas.UserCreate(email=email, password=password)
user = crud.user.create(db, obj_in=user_in)
role = crud.role.get_by_name(db, name="ACCOUNT_ADMIN")
user_role_in = schemas.UserRoleCreate(user_id=user.id, role_id=role.id)
user_role = crud.user_role.create(db, obj_in=user_role_in)
assert user_role.user_id == user.id
assert user_role.role_id == role.id
def create_invite_to_room(
dataroom_id: UUID,
org_id: UUID,
req: schemas.InviteAPIRequest,
current_user: models.User = Depends(deps.get_current_active_user),
db: Session = Depends(deps.get_db),
auth: Oso = Depends(deps.get_oso),
):
# check whether the path is correct so that dataroom belongs to org
# and dataroom actually exists
room = crud.dataroom.get(db, id=dataroom_id)
if not room:
raise HTTPException(status_code=400)
if not room.organization_fk == org_id:
raise HTTPException(status_code=400)
# check whether the user is allowed to create invites
if not auth.is_allowed(current_user, "INVITE_GUESTS", room):
raise HTTPException(status_code=404, detail="Not enough privileges")
# check whether the invitee already exists in db, if not create him/her
create_user = schemas.UserCreate(email=req.email,
password=security.random_password())
invitee = crud.user.create_if_not_exists(db, obj_in=create_user)
# add user to the specific role
crud.room_roles.add_user_role(db, invitee, room, req.user_role)
# generate access url
access_token_expires = timedelta(days=req.expires_in)
token = security.create_access_token(invitee.id,
expires_delta=access_token_expires)
# generate invitation entry in db
create_invite = schemas.InviteCreate(
invitee=invitee,
jwt_token=token,
dataroom=room,
creator=current_user,
expires_in=security.calculate_expires_in_days(req.expires_in),
)
crud.invite.create(db, obj_in=create_invite)
# generate access link
access_link = f"{settings.DOMAIN_NAME}/access?token={token}"
# generate email and send invite to the user
send_access_email(
email_to=req.email,
access_link=access_link,
invitor_name=f"{current_user.first_name} {current_user.last_name}",
)
return "OK"
def init_db(db: Session) -> None:
user = crud.user.get_by_email(db, email=settings.USER_ADMIN_EMAIL)
if not user:
user_in = schemas.UserCreate(
email=settings.USER_ADMIN_EMAIL,
firstname=settings.USER_ADMIN_FIRSTNAME,
password=settings.USER_ADMIN_PASSWORD,
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in)
user = crud.user.get_by_email(db, email=settings.USER_TEST_EMAIL)
if not user:
user_in = schemas.UserCreate(
email=settings.USER_TEST_EMAIL,
firstname=settings.USER_TEST_FIRSTNAME,
password=settings.USER_TEST_PASSWORD,
is_superuser=False,
)
user = crud.user.create(db, obj_in=user_in)
def init_db() -> None:
user = crud.user.get_by_email(email=settings.USER_ADMIN_EMAIL)
if not user:
user_in = schemas.UserCreate(
full_name=settings.USER_ADMIN_FULLNAME,
email=settings.USER_ADMIN_EMAIL,
password=settings.USER_ADMIN_PASSWORD,
is_superuser=True,
)
user = crud.user.create(obj_in=user_in)
user = crud.user.get_by_email(email=settings.USER_TEST_EMAIL)
if not user:
user_in = schemas.UserCreate(
full_name=settings.USER_TEST_FULLNAME,
email=settings.USER_TEST_EMAIL,
password=settings.USER_TEST_PASSWORD,
is_superuser=False,
)
user = crud.user.create(obj_in=user_in)
def init_db(db: Session) -> None:
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_username(db, username=settings.SUPERUSER_USERNAME)
if not user:
user_in = schemas.UserCreate(
username=settings.SUPERUSER_USERNAME,
password=settings.SUPERUSER_PASSWORD,
is_superuser=True,
)
crud.user.create(db, user_in)
def init_db(db: Session) -> None:
user = crud.user.get_by_name(
db,
name=settings.FIRST_SUPERUSER,
)
if not user:
user_in = schemas.UserCreate(
name=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True
)
user = crud.user.create(db, obj_in=user_in)
def create_user_open(
*,
db: Session = Depends(deps.get_db),
password_1: str = Body(...),
password_2: str = Body(...),
email: str = Body(...),
full_name: str = Body(None),
uid: str = Body(...),
answer: str = Body(...),
) -> Any:
"""
Create new user without the need to be logged in.
"""
if not settings.USERS_OPEN_REGISTRATION:
raise HTTPException(
status_code=403,
detail="服务器未开启开放注册功能，请联系统管理员",
)
if password_1 != password_2:
raise HTTPException(
status_code=403,
detail="两次输入的密码不一致，请保持一致",
)
password = password_2
# 验证码
if red.exists(uid):
true = red.get(uid).decode('ascii')
if true != answer:
raise HTTPException(
status_code=400,
detail="验证码错误",
)
else:
raise HTTPException(
status_code=400,
detail="验证码不存在",
)
user = crud.user.get_by_email(db, email=email)
if user:
raise HTTPException(
status_code=400,
detail="The user with this username already exists in the system",
)
user_in = schemas.UserCreate(password=password,
email=email,
full_name=full_name,
is_wechat=False)
user = crud.user.create(db, obj_in=user_in)
return user
def create_default_superuser(db: Session):
superuser = schemas.UserCreate(
full_name=settings.SUPERUSER_NAME,
email=settings.SUPERUSER_EMAIL,
password=settings.SUPERUSER_PASSWORD,
)
user = crud.user.get_by_email(db, email=settings.SUPERUSER_EMAIL)
if user:
return
user_db = crud.user.create_superuser(db, obj=superuser)
return user_db
def init_db(db: Session) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_email(db, email=settings.FIRST_SUPERUSER)
if not user:
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
pfp_Path="Default.bmp")
user = crud.user.create(db, obj_in=user_in) # noqa: F841
def init_superuser(db: Session = Depends(deps.get_db)) -> None:
# Tables should be created with Alembic migrations
# But if you don't want to use migrations, create
# the tables un-commenting the next line
# Base.metadata.create_all(bind=engine)
user = crud.user.get_by_login(db, login=settings.FIRST_SUPERUSER)
if not user:
user_in = schemas.UserCreate(
login=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
)
user = crud.user.create(db, obj_in=user_in) # noqa: F841
def test_update_user_role(db: Session) -> None:
email = random_email()
password = random_lower_string()
user_in = schemas.UserCreate(email=email, password=password)
user = crud.user.create(db, obj_in=user_in)
role = crud.role.get_by_name(db, name="ACCOUNT_ADMIN")
user_role_in = schemas.UserRoleCreate(user_id=user.id, role_id=role.id)
user_role = crud.user_role.create(db, obj_in=user_role_in)
new_role = crud.role.get_by_name(db, name="ACCOUNT_MANAGER")
new_user_role_in = schemas.UserRoleUpdate(role_id=new_role.id)
new_user_role = crud.user_role.update(db,
db_obj=user_role,
obj_in=new_user_role_in)
assert new_user_role.role_id == new_role.id
def create_users():
"""
create test users:
- username: admin, password: admin, isadmin: "true"
- username: user2, password: user2pass, isadmin: "false"
"""
if not crud.get_user(db=database.SessionLocal(),
username="******") and not crud.get_admins(
db=database.SessionLocal()):
user = schemas.UserCreate(**{
"username": "******",
"password": "******",
"isadmin": "true"
})
crud.create_user(db=database.SessionLocal(), user=user)
if not crud.get_user(db=database.SessionLocal(), username="******"):
user = schemas.UserCreate(**{
"username": "******",
"password": "******",
"isadmin": "false"
})
crud.create_user(db=database.SessionLocal(), user=user)
def test_create_user(db: Session) -> None:
faker = Faker()
profile = faker.profile()
email = profile.get("mail", None)
username = profile.get("username", None)
password = "******"
user_in = schemas.UserCreate(username=username,
email=email,
password=SecretStr(password))
user = crud.user.create(db=db, obj_in=user_in)
assert user.email == email
assert user.username == username
assert hasattr(user, "hashed_password")
assert security.verify_password(SecretStr(password), user.hashed_password)
def create_user(
username: str = Body(...),
password: str = Body(...),
db: Session = Depends(dependencies.get_db),
):
user_in = schemas.UserCreate(username=username, password=password)
if crud.user.get_by_username(db, username=user_in.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="User already exists.",
)
user = crud.user.create(db, user_in)
return user
async def init_db(con: AsyncIOConnection) -> None:
with open(Path("./dbschema/database.esdl")) as f:
schema = f.read()
async with con.transaction():
await con.execute(f"""START MIGRATION TO {{ {schema} }}""")
await con.execute("""POPULATE MIGRATION""")
await con.execute("""COMMIT MIGRATION""")
user = await crud.user.get_by_email(con, email=settings.FIRST_SUPERUSER)
if not user:
user_in = schemas.UserCreate(
email=settings.FIRST_SUPERUSER,
password=settings.FIRST_SUPERUSER_PASSWORD,
is_superuser=True,
)
await crud.user.create(con, obj_in=user_in)
