def init() -> None:
db = SessionLocal()
create_user(
db,
UserCreate(
email="*****@*****.**",
password="******",
is_active=True,
is_superuser=True,
),
)
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
db_user = crud.get_user_by_email(db, email=user.email)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
db_user = crud.get_user_by_name(db, name=user.name)
if db_user:
raise HTTPException(status_code=400, detail="Name already registered")
return crud.create_user(db=db, user=user)
def create_user(
user: UserCreate,
db: Session = Depends(get_db),
# current_user: User = Depends(get_admin_user), # This is commented for development and testin purposes
):
db_user = crud.get_user_by_email(db, email=user.email)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
return crud.create_user(db=db, user=user)
def create_user(
user: UserCreate,
db: Session = Depends(get_db),
):
db_user = crud.get_user_by_email_or_username(db,
email=user.email,
username=user.username)
if db_user:
raise HTTPException(status_code=400, detail="Email already registered")
return crud.create_user(db=db, user=user)
def create_user(user: schemas.UserCreate,
response: Response,
db: Session = Depends(get_db)):
try:
user = crud.create_user(db, user)
response.set_cookie(key="session", value=user.session)
except crud.CreateUserCommitError:
raise HTTPException(status_code=400,
detail={"error": "Failed to create user"})
return schemas.User.from_orm(user)
def register_user(user: schemas.UserCreate,
db: Session = Depends(deps.get_db)) -> JSONResponse:
data = crud.get_user(db, email=user.email)
if data is not None and not data:
return JSONResponse(status_code=400,
content={"message": "email already registered"})
# raise HTTPException(status_code=400,
# detail="email already registered")
data = crud.create_user(db=db, user=user)
if data is None:
return JSONResponse(status_code=500,
content={"message": "Internal Server Error"})
return JSONResponse(status_code=200,
content={"message": "success"})
async def google_auth(request: Request, db: Session = Depends(get_db)):
request = await request.body()
google_info = json.loads(request)['body']
try:
token = json.loads(google_info)['token']
except:
raise HTTPException(status_code=400, detail="No Token.")
# verify google token
try:
idinfo = id_token.verify_oauth2_token(token, requests.Request(),
CLIENT_ID)
userid = idinfo['sub']
except ValueError:
# Invalid token
raise HTTPException(status_code=400, detail="Token Invalid.")
# if user does not exist add to user tables and retrieve id
user_info = json.loads(google_info)['user']
name = user_info['name']
email = user_info['email']
user_check = crud.get_user_one(db, email)
if user_check is None:
user_dict = {'name': name, 'email': email}
user_schema = schema.UserIn(**user_dict)
db_user = crud.create_user(db, user_schema)
# if user does exist retrieve id
else:
db_user = user_check
return {
'u_id': db_user.u_id,
'u_name': db_user.name,
'u_email': db_user.email,
'is_auth': True
}
async def handle_webhook(update: Update, client_session: ClientSession = Depends(http_client_session), ):
update_message = update.message if update.message is not None else update.edited_message
user = crud.get_user_by_id(update_message.from_.id)
if not user:
await send_message(client_session, chat_id=update_message.chat.id, text=language_info())
user = crud.create_user(update_message)
args = FuncParameters(
session=client_session,
message=update_message,
localization=user.lang,
)
msg_welcome_back = await welcome_back(args)
if msg_welcome_back:
await send_message(client_session, chat_id=update_message.chat.id, text=msg_welcome_back)
crud.save_message(update_message)
answer = await choice_of_answer(args)
msg = await send_message(client_session, chat_id=update_message.chat.id, text=answer)
logger.debug(msg.json(indent=2, sort_keys=True))
def regist(signup: SignUp):
try:
user_id_result = available_user_id(signup.user_id)
if not user_id_result["result"]:
return user_id_result
passwd_result = stringutils.passwd_validator(signup.passwd)
if not passwd_result["result"]:
return passwd_result
with session_scope() as db:
if crud.get_user_by_user_id(signup.user_id, db) is None:
signup.passwd = get_password_hash(signup.passwd)
result = crud.create_user(signup, db)
else:
return {"result": False, "detail": "can not use this email!"}
except EmailNotValidError as e:
return {"result": False, "detail": "user_id is not valid"}
except exc.SQLAlchemyError as error:
print("signup error", error)
return {"result": False, "detail": "could not sign-up!"}
return {"result": True, "detail": "success!"}
async def create_u(user: Message, ):
user = crud.create_user(user)
logger.debug(f"created user: {user}")
return user
def create_user(name: str, _id: int, db: Session = Depends(get_db)):
crud.create_user(name=name, _id=_id, db=db)
return {'username': name, 'id': _id}
def init_db(db, args):
# Initialize the database with dummy values
print("Deleting all folders, files and users")
Base.metadata.drop_all(
bind=engine, tables=[models.File.__table__, models.User.__table__])
models.Base.metadata.create_all(bind=engine)
if os.path.exists(
os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"kmr_storage")):
shutil.rmtree(
os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"kmr_storage"))
user = None
print("Populating dummy users...")
fake = Faker("en_IN")
for i in range(args.num_users):
firstname = fake.unique.first_name()
lastname = fake.unique.last_name()
user = crud.create_user(
db=db,
user=schemas.UserRegister(
name=f"{firstname} {lastname}",
passwd_hashed=f"fake_hash#{i+1}",
op_co=f"Operating Company {i+1}",
email_id=f"{firstname.lower()}.{lastname.lower()}@danaher.com",
contact_no=fake.unique.phone_number()))
db.commit()
# Populate `files` table with 1 root folder & 1 event folder created by `user`
print("Creating dummy standard parent folder...")
abs_path = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
"kmr_storage", "2021-February")
if not os.path.exists(abs_path):
os.makedirs(abs_path)
parent = crud.create_folder(db=db,
f=schemas.FolderCreate(
name="2021-February",
abs_path=abs_path,
is_folder=True,
created_on=datetime.date(2021, 2, 20)))
db.commit()
print("Creating dummy event folder...")
abs_path = os.path.join(abs_path, "Event_1")
if not os.path.exists(abs_path):
os.makedirs(abs_path)
folder = crud.create_folder(db=db,
f=schemas.FolderCreate(
name="Event_1",
abs_path=abs_path,
is_folder=True,
parent=parent.id,
created_by=user.id,
created_on=datetime.date(2021, 2, 20)))
db.commit()
print("Creating dummy file in event folder...")
abs_path = os.path.join(abs_path, "test_file.txt")
with open(abs_path, "w") as f:
f.write("This is a dummy file for testing")
file = crud.create_file(db=db,
f=schemas.FileCreate(
name="test_file.txt",
abs_path=abs_path,
is_folder=False,
parent=folder.id,
created_by=user.id,
created_on=datetime.date(2021, 2, 20),
size=os.path.getsize(abs_path),
file_type=os.path.splitext(abs_path)[1][1:]))
db.commit()
#!/usr/bin/env python
import os
from db import get_db, crud, schemas, engine, models
models.Base.metadata.create_all(bind=engine)
ADMIN_USERNAME = os.getenv("ADMINUSERNAME", "RICKASTLEY")
ADMIN_PASSWORD = os.getenv("ADMINPASSWORD", "GIVEYOUUPNEVERGONNA")
ADMIN_ORGANIZATION = os.getenv("ADMINORGANIZATION", "Internet")
user_schema = schemas.UserCreate(username=ADMIN_USERNAME,
password=ADMIN_PASSWORD,
organization=ADMIN_ORGANIZATION)
db = next(get_db())
db.query(models.User).delete()
db.query(models.Vaccine).delete()
db.commit()
crud.create_user(db, user_schema, admin=True)
async def register_user(user: schemas.UserRegister,
db: Session = Depends(utils.get_db)):
db_user = crud.get_user_by_email(db, email_id=user.email_id)
if db_user:
raise HTTPException(status_code=400, detail="User already exists")
return crud.create_user(db=db, user=user)
