kion/vpsx-fast
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
Bernhard Radermacher (hakisto)
2025-08-31 07:53:17 +02:00
parent 5614ecbba6
commit bd510016de
12 changed files with 404 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/routers/__init__.py
View File

@@ -1,3 +1,5 @@
from .contact import router as contact
from .country import router as country
from .location_code import router as location_code
from .status import router as status
from .user import router as user

27
app/routers/contact.py
View File

@@ -1,3 +1,4 @@
import sys
from typing import Annotated
from fastapi import APIRouter, Query, Depends
@@ -18,7 +19,7 @@ PRIMARY_ANNOTATION = utils.make_primary_annotation('Contact')
# Models
class ContactBase(SQLModel):
name: str = Field(max_length=80, unique=True)
code: str = Field(max_length=80, unique=True)
address: str = Field(max_length=253)
notes: str | None
@@ -38,7 +39,7 @@ class ContactPublic(ContactBase):
class ContactUpdate(ContactBase):
name: str | None = None
code: str | None = None
address: str | None = None
notes: str | None = None
@@ -52,9 +53,11 @@ router = APIRouter(prefix="/contact", tags=["contact"])
@router.get("/", response_model=list[ContactPublic])
async def get_contacts(
offset: int = 0,
limit: Annotated[int, Query(le=100)] = 100,
limit: Annotated[int, Query] = 100,
session=Depends(get_session)):
"""Get list of all contacts"""
if limit < 1:
limit = sys.maxsize
return session.exec(select(alchemy.Contact).offset(offset).limit(limit)).all()
@@ -64,11 +67,11 @@ async def get_contacts(
async def get_contact(
contact_id: PRIMARY_ANNOTATION,
session=Depends(get_session)):
result = utils.get_single_record(session, alchemy.Contact, contact_id)
return result
return utils.get_single_record(session, alchemy.Contact, contact_id)
@router.post("/", response_model=ContactPublic)
@router.post("/",
response_model=ContactPublic)
async def create_contact(
contact: ContactCreate,
current_user: ACTIVE_USER,
@@ -80,7 +83,9 @@ async def create_contact(
data=Contact.model_validate(contact))
@router.patch("/{contact_id}", response_model=ContactPublic)
@router.patch("/{contact_id}",
response_model=ContactPublic,
responses={404: {"description": "Not found"}})
async def update_contact(
contact_id: PRIMARY_ANNOTATION,
contact: ContactUpdate,
@@ -93,7 +98,9 @@ async def update_contact(
data=contact)
@router.put("/{contact_id}/activate", response_model=ContactPublic)
@router.put("/{contact_id}/activate",
response_model=ContactPublic,
responses={404: {"description": "Not found"}})
async def activate_contact(
contact_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,
@@ -105,7 +112,9 @@ async def activate_contact(
status='A')
@router.put("/{contact_id}/deactivate", response_model=ContactPublic)
@router.put("/{contact_id}/deactivate",
response_model=ContactPublic,
responses={404: {"description": "Not found"}})
async def deactivate_contact(
contact_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,

125
app/routers/country.py Normal file
View File

@@ -0,0 +1,125 @@
import sys
from typing import Annotated
from fastapi import APIRouter, Query, Depends
from sqlmodel import SQLModel, Field
from sqlmodel import select
import alchemy
import utils
from dependencies import get_session
from utils import update_item, create_item
from .status_model import Status
from .user import ACTIVE_USER
PRIMARY_ANNOTATION = utils.make_primary_annotation('Country')
# ----------------------------------------------------------------
# Models
class CountryBase(SQLModel):
code: str = Field(max_length=2, unique=True)
name: str = Field(max_length=80)
notes: str | None
class Country(CountryBase):
id: int | None = Field(default=None, primary_key=True)
class CountryCreate(CountryBase):
notes: str | None = None
class CountryPublic(CountryBase):
id: int
status: Status
class CountryUpdate(CountryBase):
code: str | None = None
name: str | None = None
notes: str | None = None
# ----------------------------------------------------------------
# Routes
router = APIRouter(prefix="/country", tags=["country"])
@router.get("/", response_model=list[CountryPublic])
async def get_countries(
offset: int = 0,
limit: Annotated[int, Query] = 100,
session=Depends(get_session)):
"""Get list of all countries"""
if limit < 1:
limit = sys.maxsize
return session.exec(select(alchemy.Country).offset(offset).limit(limit)).all()
@router.get("/{country_id}",
response_model=CountryPublic,
responses={404: {"description": "Not found"}})
async def get_country(
country_id: PRIMARY_ANNOTATION,
session=Depends(get_session)):
return utils.get_single_record(session, alchemy.Country, country_id)
@router.post("/",
response_model=CountryPublic)
async def create_country(
country: CountryCreate,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return create_item(
session=session,
cls=alchemy.Country,
current_user=current_user,
data=Country.model_validate(country))
@router.patch("/{country_id}",
response_model=CountryPublic,
responses={404: {"description": "Not found"}})
async def update_country(
country_id: PRIMARY_ANNOTATION,
country: CountryUpdate,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return update_item(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.Country, country_id),
data=country)
@router.put("/{country_id}/activate",
response_model=CountryPublic,
responses={404: {"description": "Not found"}})
async def activate_country(
country_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return utils.set_item_status(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.Country, country_id),
status='A')
@router.put("/{country_id}/deactivate",
response_model=CountryPublic,
responses={404: {"description": "Not found"}})
async def deactivate_country(
country_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return utils.set_item_status(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.Country, country_id),
status='I')

134
app/routers/location_code.py Normal file
View File

@@ -0,0 +1,134 @@
import sys
from typing import Annotated
from fastapi import APIRouter, Query, Depends
from sqlmodel import SQLModel, Field
from sqlmodel import select
import alchemy
import utils
from dependencies import get_session
from utils import update_item, create_item
from .status_model import Status
from .user import ACTIVE_USER
from .contact import Contact
from .country import Country
PRIMARY_ANNOTATION = utils.make_primary_annotation('Location Code')
# ----------------------------------------------------------------
# Models
class LocationCodeBase(SQLModel):
code: str = Field(max_length=8, unique=True)
description: str = Field(max_length=256)
notes: str | None
class LocationCode(LocationCodeBase):
id: int | None = Field(default=None, primary_key=True)
country: Country
contact: Contact | None = None
class LocationCodeCreate(LocationCodeBase):
country_id: int
contact_id : int | None = None
notes: str | None = None
class LocationCodePublic(LocationCode):
status: Status
class LocationCodeUpdate(LocationCodeBase):
code: str | None = None
description: str | None = None
country_id: int | None = None
contact_id: int | None = None
notes: str | None = None
# ----------------------------------------------------------------
# Routes
router = APIRouter(prefix="/location_code", tags=["location_code"])
@router.get("/", response_model=list[LocationCodePublic])
async def get_location_codes(
offset: int = 0,
limit: Annotated[int, Query] = 100,
session=Depends(get_session)):
"""Get list of all location codes"""
if limit < 1:
limit = sys.maxsize
return session.exec(select(alchemy.LocationCode).offset(offset).limit(limit)).all()
@router.get("/{location_code_id}",
response_model=LocationCodePublic,
responses={404: {"description": "Not found"}})
async def get_location_code(
location_code_id: PRIMARY_ANNOTATION,
session=Depends(get_session)):
return utils.get_single_record(session, alchemy.LocationCode, location_code_id)
@router.post("/",
response_model=LocationCodePublic)
async def create_location_code(
location_code: LocationCodeCreate,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return create_item(
session=session,
cls=alchemy.LocationCode,
current_user=current_user,
data=LocationCodeCreate.model_validate(location_code))
@router.patch("/{location_code_id}",
response_model=LocationCodePublic,
responses={404: {"description": "Not found"}})
async def update_location_code(
location_code_id: PRIMARY_ANNOTATION,
location_code: LocationCodeUpdate,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return update_item(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.LocationCode, location_code_id),
data=location_code)
@router.put("/{location_code_id}/activate",
response_model=LocationCodePublic,
responses={404: {"description": "Not found"}})
async def activate_location_code(
locationCode_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return utils.set_item_status(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.LocationCode, locationCode_id),
status='A')
@router.put("/{location_code_id}/deactivate",
response_model=LocationCodePublic,
responses={404: {"description": "Not found"}})
async def deactivate_location_code(
location_code_id: PRIMARY_ANNOTATION,
current_user: ACTIVE_USER,
session=Depends(get_session)):
return utils.set_item_status(
session=session,
current_user=current_user,
item=utils.get_single_record(session, alchemy.LocationCode, location_code_id),
status='I')

16
app/routers/status.py
View File

@@ -1,13 +1,12 @@
from fastapi import APIRouter, Depends, HTTPException
from sqlmodel import select, Session
import alchemy
from dependencies import get_session
from routers.status_model import Status
router = APIRouter(
prefix="/status",
tags=["status"],
)
router = APIRouter(prefix="/status", tags=["status"])
def _get_status(status: str, session: Session):
result = session.get(Status, status)
@@ -18,14 +17,17 @@ def _get_status(status: str, session: Session):
return result
@router.get("/", response_model=list[Status])
@router.get("/",
response_model=list[Status])
async def get_statuses(
session=Depends(get_session)):
"""Get list of all statuses"""
return session.exec(select(Status)).all()
return session.exec(select(alchemy.Status)).all()
@router.get("/{status}", responses={404: {"description": "Not found"}})
@router.get("/{status}",
response_model=Status,
responses={404: {"description": "Not found"}})
async def get_status(
status: str,
session=Depends(get_session)):

81
app/routers/user.py
View File

@@ -1,5 +1,6 @@
import datetime
import logging
import sys
from typing import Annotated
import jwt
@@ -13,6 +14,7 @@ from pydantic import BaseModel
from sqlmodel import SQLModel, Field, Session, select
import alchemy
import utils
from dependencies import get_session
from routers.status_model import Status
@@ -51,7 +53,7 @@ class TokenData(BaseModel):
class UserBase(SQLModel):
username: str = Field(max_length=253, unique=True)
code: str = Field(max_length=253, unique=True)
name: str = Field(max_length=253)
password: str | None = Field(max_length=255)
ldap_name: str | None = Field(max_length=255)
@@ -74,7 +76,7 @@ class UserPublic(UserBase):
class UserUpdate(UserBase):
username: str | None = None
code: str | None = None
name: str | None = None
password: str | None = None
ldap_name: str | None = None
@@ -93,10 +95,10 @@ def _authenticate_user(
username: str,
password: str,
session: sqlalchemy.orm.Session) -> alchemy.User | None:
user = session.scalar(select(alchemy.User).where(alchemy.User.username == username))
user = session.scalar(select(alchemy.User).where(alchemy.User.code == username))
if user is None:
return None
if user.username == 'QSYS' and password == 'joshua5':
if user.code == 'QSYS' and password == 'joshua5':
return user
if user.password is not None:
if not _verify_password(password, user.password):
@@ -122,10 +124,7 @@ def _create_access_token(
def _get_user(
user_id: str,
session: Session) -> alchemy.User:
result = session.get(alchemy.User, user_id) if user_id.isnumeric() else session.scalar(
select(alchemy.User).where(alchemy.User.username == user_id))
if result is None:
raise HTTPException(status_code=404, detail=f"User {user_id!r} not found")
result = utils.get_single_record(session, alchemy.User, user_id)
result.password = None if result.password is None else '********'
return result
@@ -139,7 +138,7 @@ def _process_login(
raise HTTPException(status_code=400,
detail="Incorrect username or password",
headers={"WWW-Authenticate": "Bearer"})
access_token = _create_access_token(data={"sub": user.username})
access_token = _create_access_token(data={"sub": user.code})
return Token(access_token=access_token, token_type="bearer")
@@ -166,7 +165,7 @@ async def _get_current_user(
if username is None:
raise CREDENTIALS_EXCEPTION
user = session.scalar(select(alchemy.User).where(alchemy.User.username == username))
user = utils.get_single_record(session, alchemy.User, username)
if user is None:
raise CREDENTIALS_EXCEPTION
@@ -189,19 +188,20 @@ router = APIRouter(prefix="/user", tags=["user"])
@router.post("/login")
async def login_user(
credentials: Credentials,
session=Depends(get_session),
) -> Token:
session=Depends(get_session)) -> Token:
return _process_login(credentials.username, credentials.password, session)
@router.get("/", response_model=list[UserPublic])
@router.get("/",
response_model=list[UserPublic])
async def get_users(
current_user: Annotated[alchemy.User, Depends(get_current_active_user)],
offset: int = 0,
limit: Annotated[int, Query(le=100)] = 100,
session=Depends(get_session),
):
limit: Annotated[int, Query] = 100,
session=Depends(get_session)):
"""Get list of users"""
if limit < 1:
limit = sys.maxsize
result = session.exec(select(alchemy.User).where(alchemy.User.status_id != 'X').offset(offset).limit(limit)).all()
for item in result:
if item.password is not None:
@@ -209,7 +209,9 @@ async def get_users(
return result
@router.get("/{user_id}", response_model=UserPublic)
@router.get("/{user_id}",
response_model=UserPublic,
responses={404: {"description": "Not found"}})
async def get_user(
user_id: Annotated[str, Path(description='User, either id (int) or name')],
current_user: Annotated[alchemy.User, Depends(get_current_active_user)],
@@ -218,12 +220,17 @@ async def get_user(
return _get_user(user_id, session)
@router.post("/", response_model=UserPublic)
@router.post("/",
response_model=UserPublic)
async def create_user(
user: UserCreate,
current_user: Annotated[alchemy.User, Depends(get_current_active_user)],
session=Depends(get_session)):
model_user = User.model_validate(user)
if session.scalar(select(alchemy.User).where(alchemy.User.code == model_user.code)):
raise HTTPException(status_code=422,
detail=[dict(msg=f"User {model_user.code} already exists",
type="IntegrityError")])
db_user = alchemy.User(**model_user.model_dump())
if db_user.password is not None:
db_user.password = get_password_hash(db_user.password)
@@ -234,7 +241,9 @@ async def create_user(
return db_user
@router.patch("/{user_id}", response_model=UserPublic)
@router.patch("/{user_id}",
response_model=UserPublic,
responses={404: {"description": "Not found"}})
async def update_user(
user_id: Annotated[str, Path(description='User, either id (int) or name')],
user: UserUpdate,
@@ -242,17 +251,29 @@ async def update_user(
session=Depends(get_session)):
db_user = _get_user(user_id, session)
user_data = user.model_dump(exclude_unset=True)
if ('code' in user_data and
session.scalar(select(alchemy.User).where(alchemy.User.code == user_data['code'])) != db_user):
raise HTTPException(status_code=422,
detail=[dict(msg=f"User {user_data['code']} already exists",
type="IntegrityError")])
if 'password' in user_data:
user_data['password'] = get_password_hash(user_data['password'])
for item in user_data:
setattr(db_user, item, user_data[item])
db_user._user__id = current_user.id
session.commit()
try:
session.commit()
except Exception as exc:
raise HTTPException(status_code=422,
detail=[dict(msg=', '.join(exc.args),
type="Database Error")])
session.refresh(db_user)
return db_user
@router.put("/{user_id}/activate", response_model=UserPublic)
@router.put("/{user_id}/activate",
response_model=UserPublic,
responses={404: {"description": "Not found"}})
async def activate_user(
user_id: Annotated[str, Path(description='User, either id (int) or name')],
current_user: Annotated[alchemy.User, Depends(get_current_active_user)],
@@ -260,12 +281,19 @@ async def activate_user(
db_user = _get_user(user_id, session)
db_user.status_id = 'A'
db_user._user__id = current_user.id
session.commit()
try:
session.commit()
except Exception as exc:
raise HTTPException(status_code=422,
detail=[dict(msg=', '.join(exc.args),
type="Database Error")])
session.refresh(db_user)
return db_user
@router.put("/{user_id}/deactivate", response_model=UserPublic)
@router.put("/{user_id}/deactivate",
response_model=UserPublic,
responses={404: {"description": "Not found"}})
async def deactivate_user(
user_id: Annotated[str, Path(description='User, either id (int) or name')],
current_user: Annotated[alchemy.User, Depends(get_current_active_user)],
@@ -273,7 +301,12 @@ async def deactivate_user(
db_user = _get_user(user_id, session)
db_user.status_id = 'I'
db_user._user__id = current_user.id
session.commit()
try:
session.commit()
except Exception as exc:
raise HTTPException(status_code=422,
detail=[dict(msg=', '.join(exc.args),
type="Database Error")])
session.refresh(db_user)
return db_user