async def delete_user_form(request: Request,
user: User = Depends(get_current_active_user)):
vm = VMBase(request, user=user)
if user.deletion_protection:
return templates.TemplateResponse(
"dashboard/account_deletion_protection_warning.html",
vm.to_dict(),
headers={"HX-Trigger-After-Settle": "openModal"},
)
return templates.TemplateResponse(
"dashboard/account_delete.html",
vm.to_dict(),
headers={"HX-Trigger-After-Settle": "openModal"},
)
async def get_user_assort_price(
trader_id: str,
profile: Profile = Depends(with_profile_readonly),
trader_manager: TraderManager = Depends(
Provide[AppContainer.trader.manager]),
) -> Union[TarkovSuccessResponse[Dict[ItemId, List[List[dict]]]],
TarkovErrorResponse]:
trader = trader_manager.get_trader(TraderType(trader_id))
items = {}
for item in profile.inventory.items.values():
if item.parent_id != profile.inventory.root_id:
continue
if not trader.can_sell(item):
continue
children_items = profile.inventory.iter_item_children_recursively(item)
price = trader.get_sell_price(item, children_items=children_items)
items[item.id] = [[{"_tpl": price.template_id, "count": price.amount}]]
# TODO: Calculate price for items to sell in specified trader
# output is { "item._id": [[{ "_tpl": "", "count": 0 }]] }
return TarkovSuccessResponse(data=items)
async def get_rating_correlation(account: Account = Depends(auth_account)):
import pymysql
c = pymysql.connect(host=DATABASE_URL.hostname,
user=DATABASE_URL.username,
password=DATABASE_URL.password,
database=DATABASE_URL.database)
cur = c.cursor()
cur.execute('CALL compute_correlation(%s)', account.id)
rows = cur.fetchall()
cur.close()
return [
Correlation(attrID=attr_id, correlation=correlation)
for attr_id, correlation in rows if correlation is not None
]
def create_book(request: schemas.Book, db: Session = Depends(get_db)):
if (validate(request.startDate)):
datetime_obj = datetime.strptime(request.startDate, '%d/%m/%y')
new_book = models.Book(title=request.title,
readIntent=request.readIntent,
startDate=datetime_obj)
db.add(new_book)
db.commit()
db.refresh(new_book)
return new_book
else:
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail=f"wrong format of startDate : {request.startDate}")
def summary_get(batch: int, dept: str, sem: int,
db: Session = Depends(get_db)):
if not is_batch_exists(db, batch):
raise BatchDoesNotExist
if not is_dept_exist(db, dept):
raise DeptDoesNotExist
if not is_scores_exist(db, batch, sem, dept):
raise NoResultFoundForQuery
res = get_summary(db, batch, dept, sem)
return res
def create_file(*,
file: UploadFile = File(...),
db_session: Session = Depends(get_db)):
"""
upload a new file.
"""
meta_in = MetaCreate()
meta_in.file_name, meta_in.content_type = file.filename, file.content_type
meta_read = create(db_session=db_session, meta_in=meta_in)
if meta_read.id > 0:
with open(os.path.join(UPLOAD_FOLDER, 'temp', str(meta_read.id)),
"wb") as buffer:
shutil.copyfileobj(file.file, buffer)
return meta_read
def run_migration(migration_id, repos: RepoProvider = Depends(repos_provider)):
""" Run the migration process in foreground
:param repos: RepoProvider
:param migration_id: Migration id
:return: String message
"""
repo = repos.migration_repo
manager = MigrationManager(repo)
coro = asyncio.ensure_future(manager.start_migration_async(migration_id),
loop=loop)
loop.run_until_complete(coro)
return f"The migration {migration_id} started successfully"
def login_access_token(form_data: LoginRequestForm = Depends()):
user = UserService().authenticate(email=form_data.username,
password=form_data.password)
if not user:
raise HTTPException(status_code=400,
detail='Incorrect email or password')
elif not user.is_active:
raise HTTPException(status_code=401, detail='Inactive user')
user.last_login = datetime.now()
db.session.commit()
return DataResponse().success_response(
{'access_token': create_access_token(user_id=user.id)})
def delete_subscribe(subscribers: List[Subscriber],
DB: Session = Depends(get_db)):
try:
logger.info('Delete Subscriptions method start')
if delete_subscribers(DB, subscribers):
logger.info('Delete Subscriptions method successfully ends')
return {'isError': False}
else:
logger.info('Delete Subscriptions method unsuccessfully ends')
return {'isError': True, 'message': 'Cannot be deleted'}
except Exception as ex:
logger.info('Delete Subscriptions method error:')
logger.info(ex)
return {'isError': True, 'message': ex}
def push(body=Depends(get_body)):
try:
request = PushFeaturesRequest(**json.loads(body))
df = pd.DataFrame(request.df)
store.push(
push_source_name=request.push_source_name,
df=df,
allow_registry_cache=request.allow_registry_cache,
)
except Exception as e:
# Print the original exception on the server side
logger.exception(traceback.format_exc())
# Raise HTTPException to return the error message to the client
raise HTTPException(status_code=500, detail=str(e))
async def get_task_outputs(
kernel_events: bool = True,
window_enumeration: bool = True,
db: AsyncIOMotorDatabase = Depends(get_db_instance),
):
projection = {"_id": 1, "same_as": 1}
print(window_enumeration)
if window_enumeration:
projection["window_enumeration"] = 1
if kernel_events:
projection["kernel_events"] = 1
tasks = await db.output.find({}, projection).to_list(length=None)
return tasks
def create_page(page: Page, sess: Session = Depends(create_session)):
if page.user_id is None or page.config_id is None:
raise HTTPException(400, "user or config id is not given")
user = sess.query(UserORM).filter(UserORM.id == page.user_id).scalar()
if not user:
raise HTTPException(400, f"user id ({page.user_id}) does not exist")
config = sess.query(WebsiteConfigORM).filter(
WebsiteConfigORM.id == page.config_id).scalar()
if not config:
raise HTTPException(400,
f"config id ({page.config_id}) does not exist")
pageOrm = PageORM(**page.dict(exclude_none=True, exclude_unset=True))
sess.add(pageOrm)
sess.flush([pageOrm])
return Page.from_orm(pageOrm)
async def update_migration(migration_id,
bind: MigrationBind,
repos: RepoProvider = Depends(repos_provider)):
""" Modify the migration model
:param migration_id: Migration id
:param bind: New migration configuration
:param repos: RepoProvider
:return: Migration model
"""
migration_repo = repos.migration_repo
updated_migration = await migration_repo.update_async(migration_id, bind)
return updated_migration
def acapy_auth(auth: str = Depends(x_api_key_scheme)):
if not "." in auth:
raise HTTPException(401, "Unauthorized")
try:
[role_str, token] = auth.split(".", maxsplit=1)
role = Role.from_str(role_str)
except:
raise HTTPException(401, "Unauthorized")
if not role:
raise HTTPException(401, "Unauthorized")
return AcaPyAuth(role=role, token=token)
async def settings_get(
request: Request,
api: api_.API = Depends(get_api),
db: database.Database = Depends(get_db),
scheduler: scheduler.Scheduler = Depends(get_scheduler),
):
schedules = [{
"schedule":
str(schedule),
"next_feeding":
f"{next_feeding:%Y-%m-%d %H:%M}" if next_feeding else "",
"id":
schedule.id,
} for schedule, next_feeding in api.list_schedules_with_runtimes(
db, scheduler)]
return templates.TemplateResponse(
"settings.html",
context={
"request": request,
"feed_angle": db.get_feed_angle(),
"schedules": schedules,
},
)
async def register_schema(
schema_id: SchemaID, db: Session = Depends(get_db)) -> Schema:
schema_attrs_list = _get_schema_attrs(schema_id)
create_schema_res = crud.create_schema(
db,
schema=Schema(
did=schema_attrs_list[0],
name=schema_attrs_list[2],
version=schema_attrs_list[3],
id=schema_id.schema_id,
),
)
if create_schema_res == 1:
raise HTTPException(status_code=405, detail="Schema already exists")
return create_schema_res
async def post_reject(item_id: int, db: Session = Depends(get_db)):
"""
Rejeita um contrato por id
"""
contract: Contract = db.query(Contract).get(item_id)
if contract is None:
raise HTTPException(HTTPStatus.NOT_FOUND)
if contract.status != ContractStatus.IMAGES_UPLOADED:
raise HTTPException(HTTPStatus.BAD_REQUEST)
contract.status = ContractStatus.REJECTED
db.add(contract)
db.commit()
return contract
def pincode_subscribe(subscribers: List[SubscriberPincodeModel],
DB: Session = Depends(get_db)):
dbSubs = []
try:
logger.info('Pincode Subscribe method start')
for sub in subscribers:
dbSubs.append(DBSubscriber(**sub.dict(), active=True))
isSuccess = insert_pincode_subscribers(DB, dbSubs)
logKeyword = f'{"Uns" if not isSuccess else "S"}uccessfully'
logger.info(f'Pincode Subscribe method {logKeyword} ends')
return {'isSubscriptionSuccess': isSuccess}
except Exception as ex:
logger.info('Pincode Subscribe method error:')
logger.info(ex)
return {'isSubscriptionSuccess': False, 'message': ex}
def client_profile_status(
profile: Profile = Depends(profile_manager.with_profile),
) -> Union[TarkovSuccessResponse[List[dict]], TarkovErrorResponse]:
response = []
for profile_type in ("scav", "pmc"):
response.append({
"profileid": f"{profile_type}{profile.profile_id}",
"status": "Free",
"sid": "",
"ip": "",
"port": 0,
})
print(response)
return TarkovSuccessResponse(data=response)
async def websocket_endpoint(
websocket: WebSocket, client_id: int,
token: Any = Depends(get_token)) -> None:
if token is None:
return
await manager.connect(websocket)
try:
while True:
data = await websocket.receive_json()
print(data)
asyncio.create_task(manager.eventHandle(websocket, data))
except WebSocketDisconnect:
manager.disconnect(websocket)
async def join(
request: Request,
profile: Profile = Depends(profile_manager.with_profile),
) -> Union[TarkovSuccessResponse[list], TarkovErrorResponse]:
request_data: dict = await request.json()
return TarkovSuccessResponse(data=[{
"profileid": profile.pmc.id,
"status": "busy",
"sid": "",
"ip": "127.0.0.1",
"port": 9909,
"version": "live",
"location``": request_data["location"],
"gamemode": "deathmatch",
"shortid": "TEST",
}])
async def client_game_profile_list(
profile_id: str = Cookie(..., alias="PHPSESSID"),
profile_manager: ProfileManager = Depends(Provide[AppContainer.profile.manager]),
) -> Union[TarkovSuccessResponse[List[dict]], TarkovErrorResponse]:
try:
async with profile_manager.locks[profile_id]:
profile = profile_manager.get_profile(profile_id)
return TarkovSuccessResponse(
data=[
profile.pmc.dict(exclude_none=True),
profile.scav.dict(exclude_none=True),
]
)
except Profile.ProfileDoesNotExistsError as error:
logger.exception(error)
return TarkovSuccessResponse(data=[])
async def get_bills_for_user_family(
user_id: int, state: State = Depends(get_state)) -> List[Bill]:
# vrne seznam userjev, ki so druzina od userja z id=user_id
bills = []
fam = []
for user in state.users:
if user.id == user_id:
main_user = user
for u2 in state.users:
if main_user and u2.id in main_user.family:
fam.append(u2)
for bill in state.bills:
if bill.date_payment == "" and bill.id_payer in main_user.family:
if bill.visible_family:
bills.append(bill)
return bills
async def generate_bots(
request: Request,
bot_generator: BotGenerator = Depends(Provide[BotContainer.bot_generator]),
) -> TarkovSuccessResponse[List[dict]]:
bots: List[dict] = []
request_data: dict = await request.json()
logger.debug(request_data)
for condition in request_data["conditions"]:
bot_limit = condition["Limit"]
for _ in range(bot_limit):
bot = bot_generator.generate(bot_role="assault")
bots.append(bot)
return TarkovSuccessResponse(data=bots)
async def get_task_output(task_id: str,
db: AsyncIOMotorDatabase = Depends(get_db_instance)):
# Check whether this task is valid
response = await db.input.find_one({"_id": ObjectId(task_id)})
if response is None:
raise HTTPException(status_code=404, detail="Task does not exist.")
response = await db.output.find_one({"_id": ObjectId(task_id)}, {"_id": 0})
# Return no content if the task exists but has no output
if response is None:
raise HTTPException(status_code=202,
detail="Task exists but has not finished.")
return response
def create_user(*, session: Session = Depends(get_session), user: UserCreate):
# create the stripe customer
customer = stripe.Customer.create(email=user.email, name=user.name)
db_user = User.from_orm(
user,
{
"password_hash": security.get_password_hash(user.password),
"stripe_customer_id": customer["id"],
},
)
session.add(db_user)
session.commit()
session.refresh(db_user)
return db_user
async def get_statistics_dict(user_id: int, state: State = Depends(get_state)):
stat1 = get_stat_value_for_month(user_id)
stat2 = get_stat_value_for_week(user_id)
stat3 = get_stat_credits(user_id)
stat4 = get_stat_donations(user_id)
stat5 = get_stat_transactions(user_id)
stat6 = get_stat_byCategory(user_id)
stat7 = get_stat_byCategory_num(user_id)
return {
"for_month": stat1,
"for_week": stat2,
"credits": stat3,
"donations": stat4,
"transactions": stat5,
"cake1": stat6,
"cake2": stat7
}
def _access_token(
security_scopes: SecurityScopes,
token: Tuple[bool, Union[dict, HTTPException]] = Depends(oidc_scheme),
) -> Optional[dict]:
success, payload = token
if not success:
if raise_on_error:
raise payload
else:
return None
if set(security_scopes.scopes) - current_scopes(payload):
error = HTTPException(status_code=status.HTTP_404_NOT_FOUND)
if raise_on_error:
raise error
else:
return None
return payload
async def task_error(
task_id: str,
request: models.ErrorMessage,
db: AsyncIOMotorDatabase = Depends(get_db_instance),
):
"""Process a error message from a VM."""
await db.error.insert_one({
"time":
int(datetime.datetime.now(tz=datetime.timezone.utc).timestamp()),
"task_id":
task_id,
"stack_trace":
request.stack_trace.strip(),
})
await update_task_status(db, ObjectId(task_id), "failed")
return {}
def register_account(
email: str = Body(..., embed=True),
password: str = Body(..., embed=True),
edition: str = Body(..., embed=True),
account_service: AccountService = Depends(
Provide[AppContainer.launcher.account_service]),
) -> PlainTextResponse:
try:
account_service.find(email=email, password=password)
return PlainTextResponse(
content=zlib.compress("FAILED".encode("utf8")))
except NotFoundError:
account_service.create_account(
email=email,
password=password,
edition=edition,
)
return PlainTextResponse(content=zlib.compress("OK".encode("utf8")))
