)
from sqlalchemy.orm import Session
from . import crud
from .deps import Settings, get_db, get_settings
from .schemas import (
Auth,
AuthToken,
Ticket,
User,
UserCreate,
UserUpdate,
)
from .util import InvalidToken, create_token, extract_payload
router = APIRouter(prefix="/users")
@router.get("", response_model=list[User], tags=["Users"])
def get_users(db: Session = Depends(get_db), email: Optional[str] = None):
return crud.get_users(db=db, email=email)
@router.get("/{user_id}", response_model=User, tags=["Users"])
def get_user(user_id: int, db: Session = Depends(get_db)):
db_user = crud.get_user(db=db, user_id=user_id)
if db_user is None:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"User {user_id} not found.",
)
from django.utils.functional import cached_property
from fastapi import APIRouter, Depends, status, Request
from django_etebase import app_settings, models
from django_etebase.token_auth.models import AuthToken
from django_etebase.models import UserInfo
from django_etebase.signals import user_signed_up
from django_etebase.utils import create_user, get_user_queryset, CallbackContext
from myauth.models import UserType, get_typed_user_model
from ..exceptions import AuthenticationFailed, transform_validation_error, HttpError
from ..msgpack import MsgpackRoute
from ..utils import BaseModel, permission_responses, msgpack_encode, msgpack_decode, get_user_username_email_kwargs
from ..dependencies import AuthData, get_auth_data, get_authenticated_user
User = get_typed_user_model()
authentication_router = APIRouter(route_class=MsgpackRoute)
class LoginChallengeIn(BaseModel):
username: str
class LoginChallengeOut(BaseModel):
salt: bytes
challenge: bytes
version: int
class LoginResponse(BaseModel):
username: str
challenge: bytes
from fastapi import Depends, APIRouter
from sqlalchemy.orm import Session
from app import schemas
from app.database import get_db
from app.repositories import user
router = APIRouter(
prefix='/user',
tags=['Users']
)
@router.post('/', response_model=schemas.ShowUser)
def create_user(new_user: schemas.User, db: Session = Depends(get_db)):
return user.create(new_user, db)
@router.get('/{id}', response_model=schemas.ShowUser)
def get_user(id: int, db: Session = Depends(get_db)):
return user.get(id, db)
import asyncpg
from fastapi import APIRouter, HTTPException, Request, status
from pydantic.error_wrappers import ValidationError
from app.entities.user import CreateUser, User, UserDoesNotExist
from app.entities.wallet import WalletEnrollParams
from app.usecases.user import UserUsecase
from app.usecases.wallet import WalletUsecase
router = APIRouter(prefix="/users", tags=["users"])
@router.post("", response_model=User, status_code=status.HTTP_201_CREATED)
async def create_user(request: Request, params: CreateUser) -> User:
"""Creates new user and its wallet."""
try:
usecase: UserUsecase = request.app.state.user_usecase
user = await usecase.create(params.email)
if not user:
raise HTTPException(status_code=400, detail="User create error.")
return user
except asyncpg.exceptions.UniqueViolationError as unique_exception:
raise HTTPException(
status_code=400, detail="User with this email already exists."
) from unique_exception
except asyncpg.exceptions.NotNullViolationError as not_null_exception:
raise (
HTTPException(status_code=400, detail="Error of wallet's creation.")
) from not_null_exception
from typing import List
from fastapi import APIRouter, Depends, HTTPException
from datetime import datetime
from api.models.user import Artist, Profile, Client
from api.models.booking import Booking
from api.models.responses import BookingListResponse, SuccessResponse, TimeSlotListResponse
from api.models.requests import CreateBookingRequest, ScheduleBookingRequest, CreateClientRequest, SelectTimeSlotRequest
from api.services.booking import create_booking, get_times, get_user_bookings, booking_exists, select_time, set_price, approve_price, approve_design, schedule_booking, get_artist_bookings
from api.services.dependencies import get_current_artist, get_current_user, get_current_client
from api.services.auth import create_client
router = APIRouter(prefix="/booking", tags=["Booking"])
@router.post("/create", response_model=Booking)
async def new_booking(request: CreateBookingRequest,
current_user: Profile = Depends(get_current_user),
client: Client = Depends(get_current_client)):
if client is None:
client = await create_client(current_user, CreateClientRequest())
assert client is not None
booking = await create_booking(request, current_user)
if booking is None:
raise HTTPException(status_code=400, detail="Whoops!")
return Booking(**dict(booking))
@router.get("/list", response_model=BookingListResponse)
async def list_bookings(current_user: Profile = Depends(get_current_user)):
from fastapi import APIRouter, Form, HTTPException
from fastapi.responses import ORJSONResponse
from src.business.exceptions import ShortTextException, DocumentNotFound
from src.models.documents import Document, NewDocument
from src.business import documents as business_documents
api_router = APIRouter(default_response_class=ORJSONResponse)
@api_router.get("/{document_id}/summary/", response_model=Document)
async def get_document(document_id: int):
"""
Get document summary
"""
try:
summary = business_documents.get_document_summary(document_id)
except DocumentNotFound as e:
raise HTTPException(status_code=404, detail={"document_id": str(e)})
return Document(document_id=document_id, summary=summary)
@api_router.post("/", response_model=NewDocument)
async def create_document(text: str = Form(...)):
"""
Create document
"""
try:
document_id = business_documents.create_document(text)
except ShortTextException as e:
raise HTTPException(status_code=422, detail={"text": str(e)})
from fastapi import APIRouter, HTTPException, Request, status
from app.entities.user import User, UserDoesNotExist
from app.entities.wallet import WalletDoesNotExist, WalletTransferParams
from app.usecases.wallet import WalletUsecase
router = APIRouter(prefix="/wallets", tags=["wallets"])
@router.post("/transfer", response_model=User, status_code=status.HTTP_200_OK)
async def transfer(request: Request, params: WalletTransferParams):
"""Handler for routing of funds from one wallet to another."""
try:
usecase: WalletUsecase = request.app.state.wallet_usecase
user = await usecase.transfer(
source_wallet_id=params.wallet_from,
destination_wallet_id=params.wallet_to,
amount=params.amount,
)
return user
except UserDoesNotExist as user_not_exist:
raise HTTPException(
status_code=404,
detail=f"User does not exists. Full error: {user_not_exist}",
) from user_not_exist
except WalletDoesNotExist as wallet_not_exist:
raise HTTPException(
status_code=404,
detail=f"Wallet does not exists. Full error: {wallet_not_exist}",
) from wallet_not_exist
from fastapi import APIRouter from micro_blog import blog routers = APIRouter() routers.include_router(blog.router, prefix='/blog')
import uuid
from typing import Optional, List
from fastapi import APIRouter, Depends, Header, HTTPException
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from starlette import status
from starlette.responses import JSONResponse
from rest_introduction_app.api.challenges.challenge_4.model import UserRegistration, User, to_base64, rot13, HQMessage, \
un_rot13, un_base64
challenge_tag = "Challenge - Cryptography agency that just loooooooves acronyms."
router = APIRouter(prefix="/challenge/acronym_agency")
security = HTTPBasic()
@router.get("/information", status_code=status.HTTP_200_OK)
async def get_information():
"""
Get this resource to obtain mission debrief
"""
return {
"message":
f"You are an Agent in Bureau of People's Internet Network Deciphering Agency. "
f"You have received several messages that are currently stored in our system."
f"Use /encrypted_message to retrieve message. "
f"Then use your knowledge and tools at your disposal (other endpoints) "
f"to decipher those messages. "
f"Hurry though, the timer is set to 2 hours. After that time the messages "
f"will be wiped out due to security reasons. "
f"There are six flags waiting. "
from fastapi import APIRouter, Depends, HTTPException
from mealie.db.database import db
from mealie.db.db_setup import generate_session
from mealie.routes.deps import get_current_user
from mealie.schema.meal import MealPlanIn, MealPlanInDB
from mealie.schema.snackbar import SnackResponse
from mealie.schema.user import GroupInDB, UserInDB
from mealie.services.image import image
from mealie.services.meal_services import get_todays_meal, process_meals
from sqlalchemy.orm.session import Session
from starlette.responses import FileResponse
router = APIRouter(prefix="/api/meal-plans", tags=["Meal Plan"])
@router.get("/all", response_model=list[MealPlanInDB])
def get_all_meals(
current_user: UserInDB = Depends(get_current_user),
session: Session = Depends(generate_session),
):
""" Returns a list of all available Meal Plan """
return db.groups.get_meals(session, current_user.group)
@router.post("/create")
def create_meal_plan(
data: MealPlanIn, session: Session = Depends(generate_session), current_user=Depends(get_current_user)
):
""" Creates a meal plan database entry """
processed_plan = process_meals(session, data)
import json
from attr import dataclass
from fastapi import APIRouter, Security, Query
from typing import List, Optional
from fastapi.exceptions import HTTPException
from pydantic.main import BaseModel
from pydantic.tools import parse_obj_as
from . import Reference, NewReference, UpdateReference
from ..users import User
from splash.api.auth import get_current_user
from .references_service import ReferencesService
from splash.service.base import UidInDictError
references_router = APIRouter()
class CreateReferenceResponse(BaseModel):
uid: str
@dataclass
class Services():
references: ReferencesService
services = Services(None)
def set_references_service(references_svc: ReferencesService):
import uvicorn
from fastapi import APIRouter
from pydantic import BaseModel
from ..src.provider import app, fakedb, router as main_router
pact_router = APIRouter()
class ProviderState(BaseModel):
state: str # noqa: E999
@pact_router.post("/_pact/provider_states")
async def provider_states(provider_state: ProviderState):
mapping = {
'UserA does not exist': setup_no_user_a,
'UserA exists and is not an administrator':
setup_user_a_nonadmin
}
mapping[provider_state.state]()
return {'result': mapping[provider_state.state]}
def run_server():
app.include_router(main_router)
app.include_router(pact_router)
uvicorn.run(app)
from fastapi import APIRouter, Request, Query
from main import templates
router = APIRouter(prefix="/items", tags=["items"])
@router.get('/')
async def items(request: Request):
return templates.TemplateResponse('index.html', {
"request": request,
"for": "items router"
})
@router.put('/{item_id}')
async def item(item_id: int, q: str = Query(None, min_length=5,
max_length=50)):
return {"Item": f"You item is {item_id}", "query": q}
from fastapi import APIRouter, UploadFile, File, Query
from pydantic import BaseModel
from starlette.responses import StreamingResponse
from api.utils import get_projectless_db_connection
from api.utils.db import (
get_project_readonly_connection,
get_project_write_connection,
Connection,
)
from api.utils.extensions import guess_delimiter_by_filename
from db.python.layers.family import FamilyLayer, PedRow
from models.models.family import Family
from models.models.sample import sample_id_transform_to_raw_list
router = APIRouter(prefix='/family', tags=['family'])
class ContentType(Enum):
"""Enum for available content type options for get pedigree endpoint"""
CSV = 'csv'
TSV = 'tsv'
JSON = 'json'
class FamilyUpdateModel(BaseModel):
"""Model for updating a family"""
id: int
external_id: Optional[str] = None
"""
Module with routes regarding the User entity.
"""
from typing import List
from typing import Optional
from fastapi import APIRouter
from pydantic.types import UUID4
from src.core.boundaries.base_schemas import LimitOffsetPaginationResult
from src.core.boundaries.schemas import ChatUserCreationRequest
from src.core.boundaries.schemas import ChatUserResponse
from src.core.services import chatuser_service
chatuser_router = APIRouter()
@chatuser_router.get("/{chatuser_id}", response_model=ChatUserResponse)
async def get_chatuser_by_id(chatuser_id: UUID4):
"""
Gets a chat user by its id.
"""
user = await chatuser_service.get_user_by_id(chatuser_id)
return user
@chatuser_router.get(
"/", response_model=LimitOffsetPaginationResult[List[ChatUserResponse]])
async def get_chatusers(offset: int = 0,
limit: int = 10,
from fastapi import APIRouter from app.routers import external_apis, accounts, platforms, transactions api_router = APIRouter() api_router.include_router(external_apis.router) api_router.include_router(accounts.router) api_router.include_router(platforms.router) api_router.include_router(transactions.router)
from routers.tokens import get_token_info_list
from routers.sbp import get_sbp
from routers.prices import load_exchangerate
from database.repositories.fullnoderepository import get_active_node_count
from database.models import SessionLocal, get_db
from database.repositories.transactionsrepository import get_disctinct_accounts_by_transaction, get_last_transaction, get_transaction_count_since_last_day
from fastapi import APIRouter, Depends
from dependencies import get_token_header
from routers.net import load_syncInfo
from nodeFunctions import get_node_ip
from datetime import datetime, time
router = APIRouter(
prefix="/stats",
tags=["stats"],
dependencies=[Depends(get_token_header)],
responses={404: {"description": "Not found"}},
)
@router.get('/', description='Returns a summary of stats')
async def get_all_stats(db: SessionLocal = Depends(get_db)):
ip = get_node_ip()
sync_info = await load_syncInfo(ip)
block_height = sync_info['result']['current']
transaction_count = await get_transaction_count_since_last_day(db)
active_node_count = await get_active_node_count(db)
total_accounts = await get_disctinct_accounts_by_transaction(db)
total_super_nodes = len(await get_sbp(ip, False))
token_list = await get_token_info_list(ip)
total_tokens = len(token_list)
from fastapi import FastAPI, APIRouter, Depends
from sqlalchemy.orm import Session
from api.model import crud, models, schemas
from api.model.export_data import data_alimentos
from api.model.database import SessionLocal, engine
data = APIRouter()
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@data.get("/export_data/")
def export_data(db: Session = Depends(get_db)):
data_alimentos.export_data(db)
)
from fastapi.templating import Jinja2Templates
from ..applogger import rslogger
from ..config import settings
from ..crud import create_useinfo_entry
from ..models import UseinfoValidation
from ..schemas import PeerMessage
# from ..session import auth_manager
# Routing
# =======
# See `APIRouter config` for an explanation of this approach.
# Remove the "discuss" prefix until PR #2640 of FastAPI is merged
router = APIRouter(tags=["discuss"], )
templates = Jinja2Templates(
directory=f"{settings._book_server_path}/templates/discuss")
class ConnectionManager:
def __init__(self):
self.active_connections: Dict[str, WebSocket] = {}
async def connect(self, user: str, websocket: WebSocket):
await websocket.accept()
self.active_connections[user] = websocket
def disconnect(self, sockid: str):
del self.active_connections[sockid]
from hashlib import sha512
import logging
from fastapi import APIRouter
from fastapi.responses import JSONResponse
from requests import get
from app.utils.complexity.squad_score import squad_score, scaler
from app.utils.img_processing.google_api import GoogleAPI, NoTextFoundException
from app.utils.security.header_checking import AuthRouteHandler
from app.api.models import Submission, ImageSubmission
# global variables and services
router = APIRouter(route_class=AuthRouteHandler)
log = logging.getLogger(__name__)
vision = GoogleAPI()
@router.post("/submission/text")
async def submission_text(sub: Submission):
"""Takes a Submission Object and calls the Google Vision API to text annotate
the passed s3 link, then passes those concatenated transcriptions to the SquadScore
method, returns:
Arguments:
---
`sub`: Submission - Submission object **see `help(Submission)` for more info**
Returns:
---
```
{"SubmissionID": int, "IsFlagged": boolean,"LowConfidence": boolean, "Complexity": int}
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/2/7 10:02
# @Author : xwh
# @File : service.py
# @Description :
from fastapi import APIRouter
from requests import get, post
service_router = APIRouter()
@service_router.get("/status/{name}")
def get_systemd_service_status():
return
from fastapi import APIRouter
from sqlalchemy.sql.expression import text
from Application.user.login import login
login_routers = APIRouter()
@login_routers.post("/login")
def _login(username: str, password: str):
return login(username, password)
# -*- coding: utf-8 -*-
from fastapi import APIRouter, Path
from .controllers import PostCtrl
post_router = APIRouter(prefix='/posts')
@post_router.get('', summary="获取文章列表")
async def get_posts_list(page: int = 1, per_page: int = 10):
pagination = PostCtrl().get_posts_paginate(page=page, per_page=per_page)
return {
"r": {
"items": pagination.items,
"page": pagination.page,
"per_page": pagination.per_page,
"total_page": pagination.pages
},
"msg": "",
"code": 0
}
@post_router.get('/{post_id}', summary="查看文章详情")
async def get_post_detail(post_id: int = Path(...)):
post = PostCtrl().get_one_post(post_id)
return {"r": post or {}, "msg": "", "code": 0}
from fastapi import APIRouter, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from datetime import timedelta
from ..schemas import Login
from ..database import get_db
from ..models import User
from ..hashing import Hash
from ..token import create_access_token
router = APIRouter(tags=["Auth"])
@router.post('/login')
def login(req: OAuth2PasswordRequestForm = Depends(),
db: Session = Depends(get_db)):
user = db.query(User).filter(User.email == req.username).first()
if not user:
raise HTTPException(
status_code=401,
detail="Incorrect email or password, please try again.")
if not Hash.verify(req.password, user.password):
raise HTTPException(
status_code=401,
detail="Incorrect email or password, please try again.")
if Hash.verify(req.password, user.password):
# access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = create_access_token(data={"sub": user.email})
return {"access_token": access_token, "token_type": "bearer"}
from blog import schemas, database, models, token
from fastapi import APIRouter, Depends, status, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from blog.hashing import Hash
# from .. import models
# from ..database import engine
# from .routers import blog, user, authentication
router = APIRouter(
tags= ['authentication']
)
@router.post('/login')
def login(request:OAuth2PasswordRequestForm = Depends(), db: Session = Depends(database.get_db)):
user = db.query(models.User).filter(models.User.email == request.username).first()
if not user:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
detail=f"Invalid Credentials")
if not Hash.verify(user.password, request.password):
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
detail=f"Invalid Passowrd")
# access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
access_token = token.create_access_token(
data={"sub": user.name},
# expires_delta=access_token_expires
)
return {"access_token": access_token, "token_type": "bearer"}
from fastapi import APIRouter, Depends, HTTPException
from typing import List
from sqlalchemy.orm import Session
from datetime import timezone
from backend.crud import transaction as trans_crud
from backend.crud import user as user_crud
from backend.schemas import TransactionIn, TransactionOut
from backend import get_db
router = APIRouter(prefix="/transactions", tags=["transactions"])
@router.get("/{user_id}", response_model=List[TransactionOut])
def get_transactions(user_id: str, skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
"""
Route to grab all transactions
"""
db_user = user_crud.get_user(db=db, user_id=user_id)
if not db_user:
raise HTTPException(status_code=400, detail="User does not exist")
return trans_crud.get_transactions(db=db, skip=skip, limit=limit, user_id=user_id)
@router.post("/{user_id}", response_model=TransactionOut)
def create_transaction(user_id: str, transaction: TransactionIn, db: Session = Depends(get_db)):
"""
Route to create a new transaction
# *
# * http://www.apache.org/licenses/LICENSE-2.0
# *
# * Unless required by applicable law or agreed to in writing, software
# * distributed under the License is distributed on an "AS IS" BASIS,
# * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# * See the License for the specific language governing permissions and
# * limitations under the License.
from fastapi import APIRouter
from pydantic import BaseModel, Field
from pims import __api_version__, __version__
from pims.config import ReadableSettings, get_settings
router = APIRouter()
class ServerInfo(BaseModel):
version: str = Field(..., description='PIMS version')
api_version: str = Field(..., description='PIMS API specification version')
settings: ReadableSettings
@router.get('/info', response_model=ServerInfo, tags=['Server'])
def show_status() -> ServerInfo:
"""
PIMS Server status.
"""
return ServerInfo(version=__version__,
api_version=__api_version__,
from typing import List
from fastapi import APIRouter, HTTPException, Depends
from starlette.status import (HTTP_201_CREATED, HTTP_409_CONFLICT,
HTTP_403_FORBIDDEN, HTTP_200_OK)
from models.user import User
from objects import USER_CLIENT, JWT_SERVICE
app = APIRouter()
@app.post('/user', status_code=HTTP_201_CREATED, tags=['User'])
async def post_user(user: User,
roles: List[str] = Depends(JWT_SERVICE.check_jwt_token)):
if 'admin' not in roles:
raise HTTPException(HTTP_403_FORBIDDEN,
detail='Only admin can create new user')
if USER_CLIENT.create_user(user):
return {'msg': 'User has been successfully created'}
else:
raise HTTPException(HTTP_409_CONFLICT, detail='User already existed')
@app.delete('/user/{username}', status_code=HTTP_200_OK, tags=['User'])
async def delete_user(username: str,
roles: List[str] = Depends(JWT_SERVICE.check_jwt_token)):
if 'admin' not in roles:
raise HTTPException(HTTP_403_FORBIDDEN,
detail='Only admin can delete new user')
from api.utils.db import (
get_projectless_db_connection,
get_project_readonly_connection,
get_project_write_connection,
Connection,
)
from db.python.layers.analysis import AnalysisLayer
from db.python.tables.project import ProjectPermissionsTable
from models.enums import AnalysisType, AnalysisStatus
from models.models.analysis import Analysis
from models.models.sample import (
sample_id_transform_to_raw_list,
sample_id_format_list,
)
router = APIRouter(prefix='/analysis', tags=['analysis'])
class AnalysisModel(BaseModel):
"""
Model for 'createNewAnalysis'
"""
sample_ids: List[str]
type: AnalysisType
status: AnalysisStatus
meta: Optional[Dict[str, Any]] = None
output: Optional[str] = None
active: bool = True
# please don't use this, unless you're the analysis-runner,
# the usage is tracked ... (Ծ_Ծ)
from fastapi import APIRouter
from fastapi_plus.utils.custom_route import CustomRoute
from ..schema.auth import AuthDataSchema, LoginInputSchema
from ..service.user import UserService
router = APIRouter(route_class=CustomRoute)
@router.post('/login', response_model=AuthDataSchema, response_model_exclude_unset=True)
async def login(*, login_input: LoginInputSchema):
"""
用户登录
:param login_input: 登录结构
:return:
"""
if login_input.type == 'token':
return UserService().login_by_token(login_input.key)
elif login_input.type == 'openid':
return UserService().login_by_openid(login_input.key)
elif login_input.type == 'code':
return UserService().login_by_code(login_input.key)
elif login_input.type == 'password':
return UserService().login_by_password(login_input.key, login_input.password)
else:
return {
'code': 500,
'message': '登录错误',
}