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)