def create(db_session: Session, *, user_in: UserCreate) -> User:
user = User(
**user_in.dict()
)
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
def create(self, user_create: UserCreate) -> User:
data = user_create.dict(exclude={'id'})
doc_ref = self.collection_ref.document(user_create.id)
doc_ref.set(data)
doc = doc_ref.get()
if doc.exists:
user = User(id=doc.id, **doc.to_dict())
return user
async def create_user(self, *, new_user: UserCreate) -> UserInDB:
query_values = new_user.dict()
query_values["id"] = uuid4()
query_values["created_at"] = datetime.utcnow()
query_values["hashed_password"] = query_values["password"]
del query_values["password"]
query = users_table.insert().values(**query_values)
id = await self.db.execute(query)
return UserInDB(**query_values)
def upsert_in_db(bucket: Bucket, *, user_in: UserCreate, persist_to=0):
user_doc_id = get_doc_id(user_in.username)
passwordhash = get_password_hash(user_in.password)
user = UserInDB(**user_in.dict(), hashed_password=passwordhash)
doc_data = jsonable_encoder(user)
with bucket.durability(persist_to=persist_to,
timeout=config.COUCHBASE_DURABILITY_TIMEOUT_SECS):
bucket.upsert(user_doc_id, doc_data)
return user
async def create_user(
data: UserCreate,
db: Session = Depends(get_db),
current_user: UserInDB = Depends(check_superuser_or_admin),
environment: str = Depends(get_environment_from_token)
):
new_user = data.user_data
new_user.password = get_password_hash(new_user.password)
user_validated = UserCreate(**new_user.dict())
user = User(**user_validated.dict())
db.add(user)
db.commit()
db.refresh(user)
return user
async def create_license(data: UserCreate, db: DBClient = client):
"""Required fields: `fullname`, `username`, `email`, `password`."""
logging.info(">>> " + __name__ + ":" + create_license.__name__)
data = data.dict()
data['type'] = config.USERTYPE_LICENSE
data = UserCreate(**data)
msg = await crud.check_free_email_username(db, data.username, data.email)
if msg:
return utils.error_400_response(msg)
user = await crud.create(db, data)
if user:
return utils.create_aliased_response(UserResponse(response=user))
return utils.create_500_response("User creation failed")
async def create(db: DBClient, data: UserCreate):
logging.info(">>> " + __name__ + ":" + create.__name__)
collection = utils.get_collection(db, config.DOCTYPE_USER)
passwordhash = get_password_hash(data.password)
user = UserInDB(**data.dict(), hashed_password=passwordhash)
return await utils.create(collection, user)
def upsert(bucket: Bucket, *, user_in: UserCreate, persist_to=0):
user = upsert_in_db(bucket, user_in=user_in, persist_to=persist_to)
user_in_sync = UserSyncIn(**user_in.dict(), name=user_in.username)
assert insert_sync_gateway(user_in_sync)
return user
