async def get_true_pos(
planet: Planet,
date_params: DateParams = Depends(),
number_of_values: int = Query(1, ge=1),
step: int = Query(1, ge=1),
executor: ProcessPoolExecutor = Depends(get_executor),
):
start_date = safe_date(JULIAN_CALENDAR, date_params)
dates = (start_date + i for i in range(0, number_of_values * step, step))
loop = asyncio.get_running_loop()
results = [
(
date.jdn,
loop.run_in_executor(
executor, compute_true_pos, planet, date.days_from_epoch()
),
)
for date in dates
]
return [
{"jdn": jdn, "position": await result_awaitable}
for jdn, result_awaitable in results
]
async def get_chat(
chat_id: int,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a detailed chat object. Contains information about the participants of the chat."""
chat = db.query(Chat).filter(Chat.chat_id == chat_id).first()
contacts = []
for rel in chat.contacts:
contact = crud.get_contact(db, current_user.user_id, rel.contact_id)
contacts.append(
ContactResponse(contact_id=contact.contact_id,
connector_id=contact.connector_id,
name=contact.name,
is_self=contact.is_self,
service_id=contact.service_id))
return ChatDetailsResponse(chat_id=chat_id,
connector_id=chat.connector_id,
name=chat.name,
is_muted=chat.is_muted,
is_archived=chat.is_archived,
pin_position=chat.pin_position,
participants=contacts)
async def get_messages(
chat_id: int,
pagination: Pagination = Depends(get_pagination),
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a list of all messages for a specific chat."""
chat = crud.get_chat(db, current_user.user_id, chat_id)
if not chat:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"The chat with id {chat_id} does not exist.",
)
messages = (db.query(
models.Message).filter(models.Message.chat_id == chat_id).order_by(
desc_op(models.Message.sent_datetime)).limit(
pagination.count).offset(pagination.page *
pagination.count).all())
if not messages:
return []
return [
MessageResponse(
message_id=message.message_id,
contact_id=message.contact_id,
sent_datetime=message.sent_datetime,
message=prepare_message(chat.chat_id, message.message_id,
message.message),
) for message in messages
]
async def get_contact(
contact_id: int,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a contact by id."""
return crud.get_contact(db, current_user.user_id, contact_id)
async def download_media(
chat_id: int,
message_id: int,
current_user: UserResponse = Depends(get_current_verified_user),
pool: Pool = Depends(get_pool),
db: Session = Depends(get_db),
):
"""Download a media file.
Not all messages have a media file attached to it."""
chat = crud.get_chat(db, current_user.user_id, chat_id)
if not chat:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"The chat with id {chat_id} does not exist.",
)
connector_id = chat.contacts[0].contact.connector_id
connector = crud.get_connector(db, current_user.user_id, connector_id)
message = db.query(models.Message).filter(
models.Message.message_id == message_id).first()
filename, mime, data = await pool.get_bytes(
f"{connector.connector_type}/{connector_id}/{uuid.uuid4()}/chats/{chat.internal_id}/messages/{message.internal_id}/get_media",
{})
if data:
return Response(data, media_type=mime)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"File {filename} does not exist.",
)
def create_roster_score_service(
settings: Settings = Depends(get_settings),
roster_repo: LeagueRosterRepository = Depends(create_league_roster_repository),
score_repo: LeaguePlayerScoreRepository = Depends(create_league_player_score_repository),
public_repo: PublicRepository = Depends(create_public_repository),
):
return RosterScoreService(settings.current_season, roster_repo, score_repo, public_repo,)
def get_to_jdn(
calendar: Calendar = Depends(safe_calendar),
date_params: DateParams = Depends(),
):
date = safe_date(calendar, date_params)
return {"jdn": date.jdn, "date": str(date)}
async def delete_chat(
chat_id: int,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Deletes a chat and all its messages. This action cannot be undone."""
db.query(Chat).filter(Chat.chat_id == chat_id).delete()
db.commit()
def create_player_projection_service(
settings: Settings = Depends(get_settings),
player_repo: PlayerRepository = Depends(create_player_repository),
player_score_repo: LeaguePlayerScoreRepository = Depends(
create_league_player_score_repository),
public_repo: PublicRepository = Depends(create_public_repository),
):
return PlayerProjectionService(settings.current_season, player_repo,
player_score_repo, public_repo)
def create_issue_58_migration(
league_repo=Depends(create_league_repository),
user_league_repo=Depends(create_user_league_repository),
league_config_repo=Depends(create_league_config_repository),
league_roster_repo=Depends(create_league_roster_repository),
state_repo=Depends(create_state_repository),
):
return Issue58Migration(league_repo, user_league_repo, league_config_repo,
league_roster_repo, state_repo)
def create_notification_service(
config_repo: LeagueConfigRepository = Depends(
create_league_config_repository),
discord_service: DiscordService = Depends(create_discord_service),
):
return NotificationService(
config_repo=config_repo,
discord_service=discord_service,
)
def create_issue_118_migration(
league_repo=Depends(create_league_repository),
matchup_repo: LeagueWeekMatchupRepository = Depends(
create_league_week_matchup_repository),
player_score_repo: LeaguePlayerScoreRepository = Depends(
create_league_player_score_repository),
cfl_game_proxy: CflGameProxy = Depends(create_cfl_game_proxy),
):
return Issue118Migration(league_repo, matchup_repo, player_score_repo,
cfl_game_proxy)
def create_update_player_stats_command_executor(
state_repo: StateRepository = Depends(create_state_repository),
league_config_repo: LeagueConfigRepository = Depends(
create_league_config_repository),
league_player_score_repo: LeaguePlayerScoreRepository = Depends(
create_league_player_score_repository),
):
return UpdatePlayerStatsCommandExecutor(
state_repo=state_repo,
league_config_repo=league_config_repo,
league_player_score_repo=league_player_score_repo)
async def logout_all_but_this_session(
current_user: AuthUser = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Logout from all sessions (except the current one)."""
db.query(models.Session).filter(
models.Session.user_id == current_user.user_id,
models.Session.session_id != current_user.session_id,
).delete()
db.commit()
def create_roster_player_service(
league_owned_player_repo: LeagueOwnedPlayerRepository = Depends(
create_league_owned_player_repository),
roster_repo: LeagueRosterRepository = Depends(
create_league_roster_repository),
league_transaction_repo: LeagueTransactionRepository = Depends(
create_league_transaction_repository),
):
return RosterPlayerService(league_owned_player_repo,
roster_repo=roster_repo,
league_transaction_repo=league_transaction_repo)
async def logout_from_session(
session_id: int,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Logout from one session."""
db.query(models.Session).filter(
models.Session.user_id == current_user.user_id,
models.Session.session_id == session_id,
).delete()
db.commit()
def get_logged_user(token: str = Depends(oauth_scheme),
db: Session = Depends(get_db)) -> UserOut:
access_token = Token(token)
username = access_token.get_username()
if not username:
return HTTPException(status_code=status.HTTP_403_FORBIDDEN,
detail="Invalid Token")
db_user = db.query(users.User).get(username)
return UserOut(username=db_user.username,
name=db_user.name,
surname=db_user.surname,
active=db_user.active)
async def get_session(
current_user: AuthUser = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get the current session."""
session = (db.query(models.Session).filter(
models.Session.user_id == current_user.user_id,
models.Session.session_id == current_user.session_id,
models.Session.valid_until > datetime.now(),
).first())
return session
async def delete_message(
chat_id: int,
message_id: int,
request: DeleteMessageRequest,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Delete a message.
Not all services support message deletion."""
db.query(models.Message).filter(
models.Message.chat_id == chat_id,
models.Message.message_id == message_id).delete()
db.commit()
async def indexer(apiKey: APIKey = Depends(get_api_key),
config: AppConfiguration = Depends(get_config)):
"""Start indexing jobs for all configured sites."""
jobs = []
for site in config.sites.values():
job = queue.enqueue(tasks.index,
args=[site],
kwargs={"force": True},
job_timeout=tasks.INDEXING_TIMEOUT)
jobs.append(job.id)
return {"jobs": jobs}
async def get_connectors(
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a list of all connectors the user has."""
connectors = (db.query(models.Connector).filter(
models.Connector.user_id == current_user.user_id).all())
if not connectors:
return []
return connectors
def get_houses(
method: HouseMethods = Depends(safe_houses_method),
latitude: float = Query(..., ge=-90, le=90),
date_params: DateParams = Depends(),
):
date = safe_date(JULIAN_CALENDAR, date_params)
asc = ascendant(date.days_from_epoch(), latitude)
houses_list = method(asc, latitude)
return [str(round(Sexagesimal(x, 2))) for x in houses_list]
async def get_sessions(
current_user: AuthUser = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a list of all active sessions the user has."""
sessions = (db.query(models.Session).filter(
models.Session.user_id == current_user.user_id,
models.Session.valid_until > datetime.now(),
).all())
if not sessions:
return []
return sessions
async def sign_in(
form_data: OAuth2PasswordRequestForm = Depends(),
session: Session = Depends(get_database_session),
) -> Dict[str, Any]:
repository: UserRepository = UserMysqlRepository(session)
user = await authenticate_user(
repository=repository,
username=form_data.username,
password=form_data.password,
)
if not user:
raise FailureSignInException
token = create_access_token(username=user.username,
scopes=form_data.scopes)
return {"access_token": token, "token_type": TokenType.BEARER}
async def edit_message(
chat_id: int,
message_id: int,
message: MessageContent,
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Edit a message.
Not all services support message editing."""
edit_message = (db.query(models.Message).filter(
models.Message.chat_id == chat_id,
models.Message.message_id == message_id).first())
edit_message.message = json.dumps(message.__dict__)
db.commit()
def delete_user(user_id: str,
auth_user: AdminModel = Depends(get_current_user)):
user = admin.delete_user(user_id)
if user:
return {"success": True}
return {"success": False}
def get_messages(start_time: Optional[datetime] = None,
end_time: Optional[datetime] = None,
auth_user: AdminModel = Depends(get_current_user)):
_messages = admin.messages_count(start_time=start_time, end_time=end_time)
return {"messages": _messages}
async def get_session(
session_id: int,
current_user: AuthUser = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Get a session by id."""
session = (db.query(models.Session).filter(
models.Session.session_id == session_id,
models.Session.valid_until > datetime.now(),
).first())
if not session:
raise SESSION_NOT_FOUND
return session
def users_load(auth_user: AdminModel = Depends(get_current_user)):
try:
users = admin.load_users()
except Exception as e:
raise e
return {"users": users, "count": len(users)}
def create_room(room_name: str,
auth_user: AdminModel = Depends(get_current_user)):
if room_name.strip() == "":
raise HTTPException(status_code=411, detail="Enter your room name")
_room = admin.create_room(room_name, str(auth_user.id))
return _room
