from dependency_injector.wiring import Provide, inject
from fastapi.params import Depends
from server.container import AppContainer
from server.requests import ZLibRequest
from server.utils import make_router
from tarkov.dependencies import profile_manager
from tarkov.models import TarkovSuccessResponse
from tarkov.offraid.requests import OffraidSaveRequest
from tarkov.offraid.services import OffraidSaveService
from tarkov.profile.profile import Profile
offraid_router = make_router(tags=["Offraid"])
@offraid_router.put("/raid/profile/save")
@inject
def singleplayer_raid_profile_save(
request: OffraidSaveRequest,
profile: Profile = Depends(profile_manager.with_profile),
offraid_service: OffraidSaveService = Depends(
Provide[AppContainer.offraid.service]),
) -> TarkovSuccessResponse:
if request.is_player_scav:
raise NotImplementedError
offraid_service.update_profile(
profile=profile,
raid_profile=request.profile,
raid_health=request.health,
)
from typing import Dict, List, Union
from dependency_injector.wiring import Provide, inject
from fastapi.params import Depends
from pydantic import BaseModel
from server.container import AppContainer
from server.utils import make_router
from tarkov.profile.dependencies import with_profile
from tarkov.inventory.types import ItemId, TemplateId
from tarkov.models import TarkovErrorResponse, TarkovSuccessResponse
from tarkov.profile.profile import Profile
from tarkov.trader.manager import TraderManager
from tarkov.trader.models import TraderType
insurance_router = make_router(tags=["Insurance"])
class InsuranceListCostRequest(BaseModel):
traders: List[str]
items: List[ItemId]
@insurance_router.post("/client/insurance/items/list/cost")
@inject
async def items_list_cost(
request: InsuranceListCostRequest,
profile: Profile = Depends(with_profile),
trader_manager: TraderManager = Depends(
Provide[AppContainer.trader.manager]),
) -> Union[TarkovSuccessResponse[Dict[str, dict]], TarkovErrorResponse]:
from typing import List
from server.utils import make_router
from tarkov.hideout import repositories as hideout_repositories
from tarkov.hideout.repositories.areas import HideoutAreaTemplate
from tarkov.hideout.repositories.production import HideoutProductionModel
from tarkov.hideout.repositories.scavcase_production import ScavcaseProductionModel
from tarkov.hideout.repositories.settings import HideoutSettingsModel
from tarkov.models import TarkovSuccessResponse
hideout_router = make_router(tags=["Hideout"])
@hideout_router.post("/client/hideout/areas")
def hideout_areas() -> TarkovSuccessResponse[List[HideoutAreaTemplate]]:
return TarkovSuccessResponse(
data=hideout_repositories.areas_repository.areas)
@hideout_router.post("/client/hideout/settings")
def hideout_settings() -> TarkovSuccessResponse[HideoutSettingsModel]:
return TarkovSuccessResponse(data=hideout_repositories.settings)
@hideout_router.post("/client/hideout/production/recipes")
def client_hideout_production_recipes(
) -> TarkovSuccessResponse[List[HideoutProductionModel]]:
return TarkovSuccessResponse(
data=hideout_repositories.production_repository.production)
import zlib
from dependency_injector.wiring import Provide, inject
from fastapi.params import Body, Depends
from fastapi.requests import Request
from fastapi.responses import PlainTextResponse
from server.container import AppContainer
from server.utils import get_request_url_root, make_router
from tarkov.exceptions import NotFoundError
from tarkov.launcher.accounts import AccountService
from tarkov.launcher.models import Account
from tarkov.launcher.helpers import available_editions
launcher_router = make_router(tags=["Launcher"])
@launcher_router.get("/launcher/server/connect")
@inject
async def connect(request: Request, ) -> dict:
return {
"backendUrl": get_request_url_root(request).rstrip("/"),
"name": "Jet Py",
"editions": available_editions(),
}
@launcher_router.post("/launcher/profile/login")
@inject
def login(
email: str = Body(..., embed=True),
from typing import Any, List
from fastapi import Request
from fastapi.params import Depends
from pydantic import BaseModel
from server.utils import make_router
from tarkov.profile.dependencies import with_profile
from tarkov.lib import locations
from tarkov.models import TarkovSuccessResponse
from tarkov.profile.models import ProfileModel
from tarkov.profile.profile import Profile
singleplayer_router = make_router(tags=["Singleplayer"])
@singleplayer_router.get("/singleplayer/bundles")
def singleplayer_bundles() -> List:
return []
@singleplayer_router.get("/singleplayer/settings/raid/menu")
def singleplayer_settings_raid_menu() -> dict:
# TODO: Put that into the config file !
return {
"aiAmount": "AsOnline",
"aiDifficulty": "AsOnline",
"bossEnabled": True,
"scavWars": False,
"taggedAndCursed": False,
}
from fastapi.params import Body, Cookie, Depends
from fastapi.requests import Request
from server import logger
from server.container import AppContainer
from server.utils import get_request_url_root, make_router
from tarkov.inventory_dispatcher import DispatcherManager
from tarkov.inventory_dispatcher.manager import DispatcherResponse
from tarkov.launcher.accounts import AccountService
from tarkov.models import TarkovErrorResponse, TarkovSuccessResponse
from tarkov.profile.dependencies import with_profile
from tarkov.profile.profile import Profile
from tarkov.profile.profile_manager import ProfileManager
from tarkov.profile.service import ProfileService
profile_router = make_router(tags=["Profile"])
@profile_router.post(
"/client/game/profile/items/moving",
response_model=TarkovSuccessResponse[DispatcherResponse],
response_model_exclude_none=True,
response_model_exclude_unset=False,
)
@inject
def client_game_profile_item_move(
profile: Profile = Depends(with_profile),
body: dict = Body(...),
) -> Union[TarkovSuccessResponse[DispatcherResponse], TarkovErrorResponse]:
dispatcher = DispatcherManager(profile)
response = dispatcher.dispatch(body["data"])
import asyncio
from typing import Optional
import orjson
from dependency_injector.wiring import Provide, inject
from fastapi import Request
from fastapi.params import Cookie, Depends
from fastapi.responses import PlainTextResponse
from server import logger
from server.container import AppContainer
from server.utils import get_request_url_root, make_router
from tarkov.models import TarkovSuccessResponse
from .notifier import NotifierService
notifier_router = make_router(tags=["NotifierService"])
@notifier_router.post("/client/notifier/channel/create")
def client_notifier_channel_create(
request: Request,
profile_id: Optional[str] = Cookie(alias="PHPSESSID", default=None),
) -> TarkovSuccessResponse[dict]:
url_root = get_request_url_root(request).rstrip("/")
notifier_server_url = f"{url_root}/notifierServer/get/{profile_id}"
response = {
"notifier": {
"server": f"{url_root}/",
"channel_id": "testChannel",
"url": notifier_server_url,
},
from typing import Dict, Optional, Type, Union
import ujson
from dependency_injector.wiring import Provide, inject
from fastapi.params import Cookie, Depends
from fastapi.requests import Request
from server import db_dir, start_time
from server.container import AppContainer
from server.utils import get_request_url_root, make_router
from tarkov.config import FleaMarketConfig
from tarkov.inventory.repositories import AnyTemplate, ItemTemplatesRepository
from tarkov.inventory.types import TemplateId
from tarkov.models import TarkovErrorResponse, TarkovSuccessResponse
misc_router = make_router(tags=["Misc/Bootstrap"])
@misc_router.post("/client/locations")
def client_locations() -> TarkovSuccessResponse[dict]:
locations_base_path = db_dir.joinpath("base", "locations.json")
locations_base: dict = ujson.load(locations_base_path.open())
for file in (db_dir / "locations").glob("*.json"):
map_data = ujson.load(file.open("r"))
map_id = map_data["base"]["_Id"]
locations_base["locations"][map_id] = map_data["base"]
return TarkovSuccessResponse(data=locations_base)
from dependency_injector.wiring import Provide, inject
from fastapi import Request
from fastapi.params import Body, Depends
from server.container import AppContainer
from server.utils import make_router
from tarkov.fleamarket.fleamarket import FleaMarket
from tarkov.fleamarket.models import FleaMarketRequest, FleaMarketResponse
from tarkov.inventory.types import TemplateId
from tarkov.models import TarkovSuccessResponse
flea_market_router = make_router(tags=["FleaMarket"])
@flea_market_router.post(
"/client/ragfair/find",
response_model_exclude_none=True,
response_model_exclude_unset=False,
response_model=TarkovSuccessResponse[FleaMarketResponse],
)
@inject
async def find(
req: Request,
flea_market: FleaMarket = Depends(Provide[AppContainer.flea.market]),
) -> TarkovSuccessResponse[FleaMarketResponse]:
request = FleaMarketRequest.parse_obj(await req.json())
return TarkovSuccessResponse(data=flea_market.view.get_response(request))
@flea_market_router.post("/client/items/prices")
def client_items_prices() -> TarkovSuccessResponse:
from typing import Dict, List, Union
from fastapi.params import Body, Depends
from server.utils import make_router
from tarkov.dependencies import profile_manager
from tarkov.mail.requests import GetAllAttachmentsRequest, MailDialogViewRequest
from tarkov.models import TarkovErrorResponse, TarkovSuccessResponse
from tarkov.profile.profile import Profile
mail_router = make_router(tags=["Notifier"])
@mail_router.post("/client/mail/dialog/list")
def mail_dialog_list(
profile: Profile = Depends(profile_manager.with_profile),
) -> Union[TarkovSuccessResponse[List[Dict]], TarkovErrorResponse]:
return TarkovSuccessResponse(
data=profile.mail.view.view_dialogue_preview_list())
@mail_router.post("/client/mail/dialog/info")
async def mail_dialog_info(
dialogue_id: str = Body(..., alias="dialogId", embed=True),
profile: Profile = Depends(profile_manager.with_profile),
) -> Union[TarkovSuccessResponse[dict], TarkovErrorResponse]:
dialogue_preview = profile.mail.view.view_dialog_preview(
dialogue_id=dialogue_id)
return TarkovSuccessResponse(data=dialogue_preview)
from typing import Dict, List, Optional, Union
from dependency_injector.wiring import Provide, inject
from fastapi.params import Cookie, Depends
from server.container import AppContainer
from server.utils import make_router
from tarkov.profile.dependencies import with_profile, with_profile_readonly
from tarkov.inventory.models import Item
from tarkov.inventory.types import ItemId
from tarkov.models import Base, TarkovErrorResponse, TarkovSuccessResponse
from tarkov.profile.profile import Profile
from tarkov.trader.manager import TraderManager
from tarkov.trader.models import BarterSchemeEntry, TraderType
trader_router = make_router(tags=["Traders"])
@trader_router.post(
"/client/trading/customization/storage",
response_model=TarkovSuccessResponse[dict],
)
async def customization_storage(
profile_id: Optional[str] = Cookie(alias="PHPSESSID", default=None),
) -> Union[TarkovSuccessResponse[dict], TarkovErrorResponse]:
if profile_id is None:
return TarkovErrorResponse(data="",
err=True,
errmsg="No session cookie provided")
# customization_data = ujson.load(
# root_dir.joinpath('resources', 'profiles', profile_id, 'storage.json').open('r', encoding='utf8')
from typing import Literal, Union
import ujson
from fastapi import Request
from fastapi.params import Depends
from server import db_dir
from server.utils import make_router
from tarkov.dependencies import profile_manager
from tarkov.models import TarkovErrorResponse, TarkovSuccessResponse
from tarkov.profile.profile import Profile
match_router = make_router(tags=["Match"])
@match_router.post("/client/match/group/status")
def group_status() -> TarkovSuccessResponse[dict]:
return TarkovSuccessResponse(data={
"players": [],
"invite": [],
"group": [],
})
@match_router.post("/client/match/group/exit_from_menu")
def exit_from_menu() -> TarkovSuccessResponse[Literal[None]]:
return TarkovSuccessResponse(data=None)
@match_router.post("/client/match/available")
def available() -> TarkovSuccessResponse[Literal[True]]:
from typing import List
import ujson
from dependency_injector.wiring import Provide, inject
from fastapi.params import Depends
from fastapi.requests import Request
from server import db_dir, logger
from server.utils import make_router
from tarkov.bots.generator import BotGenerator
from tarkov.bots.container import BotContainer
from tarkov.models import TarkovSuccessResponse
bots_router = make_router(tags=["Bots"])
@bots_router.get(
"/singleplayer/settings/bot/difficulty/{bot_type}/{difficulty}")
def bot_difficulty_settings(bot_type: str, difficulty: str) -> dict:
if bot_type == "core":
return ujson.load(
db_dir.joinpath("base", "botCore.json").open(encoding="utf8"))
bot_file = db_dir.joinpath("bots", bot_type, "difficulty",
f"{difficulty}.json").open(encoding="utf8")
return ujson.load(bot_file)
@bots_router.get("/singleplayer/settings/bot/limit/{bot_type}")
def settings_bot_limit(bot_type: str) -> int: # pylint: disable=unused-argument
from functools import lru_cache
import ujson
from server import db_dir
from server.utils import make_router
from tarkov.library import load_locale
from tarkov.models import TarkovSuccessResponse
lang_router = make_router(tags=["Locale"])
@lru_cache(8)
def _client_menu_locale(locale_type: str) -> dict:
locale_path = db_dir / "locales" / locale_type / "menu.json"
return ujson.load(locale_path.open("r", encoding="utf8"))["data"]
@lang_router.post("/client/menu/locale/{locale_type}")
def client_menu_locale(locale_type: str) -> TarkovSuccessResponse[dict]:
return TarkovSuccessResponse(data=_client_menu_locale(locale_type))
@lang_router.post("/client/languages")
def client_languages() -> TarkovSuccessResponse[list]:
languages_data_list = []
languages_dir = db_dir / "locales"
for dir_ in languages_dir.glob("*"):
language_file = dir_ / f"{dir_.stem}.json"
languages_data_list.append(
ujson.load(language_file.open("r", encoding="utf8")))
from server.utils import make_router
from tarkov.models import TarkovSuccessResponse
friend_router = make_router(tags=["Friends"])
@friend_router.post("/client/friend/list")
def client_friend_list() -> TarkovSuccessResponse[dict]:
return TarkovSuccessResponse(data={
"Friends": [],
"Ignore": [],
"InIgnoreList": []
})
@friend_router.post("/client/friend/request/list/inbox")
def client_friend_request_list_inbox() -> TarkovSuccessResponse[list]:
return TarkovSuccessResponse(data=[])
@friend_router.post("/client/friend/request/list/outbox")
def client_friend_request_list_outbox() -> TarkovSuccessResponse[list]:
return TarkovSuccessResponse(data=[])