evyos-center-server/wag-managment-api-service-version-2
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

events imports are checked

Browse Source
This commit is contained in:
berkay
2024-11-08 15:05:12 +03:00
parent 643d6d8f65
commit a5b1e0b2f4
71 changed files with 2517 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
service_app/routers/account/router.py Normal file
View File

53
service_app/routers/address/address/router.py Normal file
View File

@@ -0,0 +1,53 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertAddress,
SearchAddress,
ListOptions,
PatchRecord,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
address_router = APIRouter(prefix="/address", tags=["Address"])
address_router.include_router(address_router, include_in_schema=True)
@address_router.post(path="/list", summary="List Active/Delete/Confirm Address")
def address_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@address_router.post(path="/create", summary="Create Address with given auth levels")
def address_create(request: Request, data: InsertAddress):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@address_router.post(path="/search", summary="Search Address with given auth levels")
def address_search(request: Request, data: SearchAddress):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@address_router.post(
path="/update/{address_uu_id}", summary="Update Address with given auth levels"
)
def address_update(request: Request, address_uu_id: str, data: InsertAddress):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, address_uu_id=address_uu_id, token_dict=token_dict
)
@address_router.patch(
path="/patch/{address_uu_id}", summary="Update Address Active/Delete/Confirm"
)
def address_patch(request: Request, address_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, address_uu_id=address_uu_id, token_dict=token_dict
)

46
service_app/routers/address/post_code/router.py Normal file
View File

@@ -0,0 +1,46 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertPostCode,
ListOptions,
PatchRecord,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
post_code_router = APIRouter(prefix="/postcode", tags=["Post Code"])
post_code_router.include_router(post_code_router, include_in_schema=True)
@post_code_router.post(path="/list", summary="List Active/Delete/Confirm PostCode")
def post_code_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@post_code_router.post(path="/create", summary="Create PostCode with given auth levels")
def post_code_create(request: Request, data: InsertPostCode):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@post_code_router.post(
path="/update/{post_code_uu_id}", summary="Update PostCode with given auth levels"
)
def post_code_update(request: Request, post_code_uu_id: str, data: InsertPostCode):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, post_code_uu_id=post_code_uu_id, token_dict=token_dict
)
@post_code_router.patch(
path="/patch/{post_code_uu_id}", summary="Update PostCode Active/Delete/Confirm"
)
def post_code_patch(request: Request, post_code_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, post_code_uu_id=post_code_uu_id, token_dict=token_dict
)

74
service_app/routers/api/router.py Normal file
View File

@@ -0,0 +1,74 @@
import json
import typing
import zlib
from base64 import b64decode
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from pydantic import BaseModel
internal_route = APIRouter(prefix="/internal", tags=["Internal"])
internal_route.include_router(internal_route, include_in_schema=False)
class ApiReceive(BaseModel):
data: str
class BankReceive(BaseModel):
import_file_name: str
iban: str
bank_date: str
channel_branch: str
currency: typing.Optional[str] = "TL"
currency_value: float
bank_balance: float
additional_balance: float
process_name: str
process_type: str
process_comment: str
bank_reference_code: str
@internal_route.post(
path="/isbank/retreive",
summary="Receive isbank xls service from mail reader service",
)
def is_bank_retrieve_account_records(request: Request, bank_data: ApiReceive):
from database_sql_models import AccountRecords
data_dict = bank_data.model_dump()
data_bulk = json.loads(zlib.decompress(b64decode(data_dict["data"])))
print("data_bulk", data_bulk)
new_record_list = []
for data_keys in data_bulk: # data_bulk is a dict
for data_dict in data_bulk[data_keys]: # data_bulk[data_keys] is a list
data_dict["bank_balance"] = data_dict.pop("balance")
data_dict["import_file_name"] = str(data_keys)
print("data_dict before pyd", data_dict)
data_dict = BankReceive(**data_dict).model_dump()
print("data_dict after pyd", data_dict)
if new_account_record := AccountRecords.find_or_create(**data_dict):
print("new_account_record.is_found", new_account_record.is_found)
if not new_account_record.is_found:
new_record_list.append(new_account_record.get_dict())
if new_record_list:
return JSONResponse(
content={
"completed": True,
"message": "Create Bank Record",
"data": new_record_list,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Record already exist or can not be created",
},
status_code=status.HTTP_406_NOT_ACCEPTABLE,
)

98
service_app/routers/application/enums_and_drops/router.py Normal file
View File

@@ -0,0 +1,98 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.exceptions import HTTPException
from fastapi.responses import JSONResponse
from databases import ApiEnumDropdown
from api_validations.validations_request import (
SingleEnumClassKey,
SingleEnumUUID,
SingleEnumOnlyClass,
)
enums_route = APIRouter(prefix="/enums", tags=["Enums and Dropdowns of API"])
enums_route.include_router(enums_route, include_in_schema=False)
@enums_route.post(path="/get/key", summary="Get single enum via key")
def get_single_enum_via_key_and_class(data: SingleEnumClassKey):
enum = ApiEnumDropdown.query.filter(
ApiEnumDropdown.enum_class.ilike(data.class_name),
ApiEnumDropdown.key.ilike(data.key_name),
).populate_existing()
if record := enum.first():
return JSONResponse(
content={
"completed": True,
"message": "Get single enum via key",
"data": record.get_enum_dict() if enum else None,
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Enum not found",
)
@enums_route.post(path="/get/uu_id", summary="Get single enum via uu_id")
def get_single_enum_via_uuid(data: SingleEnumUUID):
enum = ApiEnumDropdown.query.filter(
ApiEnumDropdown.uu_id == data.uu_id
).populate_existing()
if records := enum.first():
return JSONResponse(
content={
"completed": True,
"message": "Get single enum via uu_id",
"data": records.get_enum_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Enum not found",
)
@enums_route.post(path="/list/class", summary="Get all enums via class")
def list_all_enums_with_class(data: SingleEnumOnlyClass):
enums = ApiEnumDropdown.query.filter(
ApiEnumDropdown.enum_class.ilike(data.class_name or "")
).populate_existing()
if records := enums.all():
records_list = [record.get_enum_dict() for record in records]
return JSONResponse(
content={
"completed": True,
"message": "Get all enums via class",
"count": len(records_list),
"data": records_list,
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Enums not found",
)
@enums_route.post(path="/list/all", summary="Get all enums")
def list_all_enums():
enums = ApiEnumDropdown.query.filter().populate_existing()
if records := enums.all():
records_list = [record.get_enum_dict() for record in records]
return JSONResponse(
content={
"completed": True,
"count": len(records_list),
"message": "Get all enums",
"data": records_list,
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Enums can not be listed",
)

58
service_app/routers/application/occupants/router.py Normal file
View File

@@ -0,0 +1,58 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.exceptions import HTTPException
from fastapi.responses import JSONResponse
from databases import OccupantTypes
from api_validations.validations_request import (
SingleOccupantTypeClassKey,
SingleOccupantTypeUUID,
)
occupant_types_route = APIRouter(prefix="/occupant_types", tags=["Occupant Types"])
occupant_types_route.include_router(occupant_types_route, include_in_schema=False)
@occupant_types_route.post(
path="/get/code", summary="Get single occupant type via code"
)
def get_single_occupant_type_via_code(data: SingleOccupantTypeClassKey):
occupant_type = OccupantTypes.query.filter(
OccupantTypes.occupant_code.ilike(data.type_code)
).populate_existing()
if record := occupant_type.first():
return JSONResponse(
content={
"completed": True,
"message": "Get single occupant type via code",
"data": record.get_dict() if record else None,
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Occupant type not found",
)
@occupant_types_route.post(
path="/get/uu_id", summary="Get single occupant type via uu_id"
)
def get_single_occupant_type_via_uuid(data: SingleOccupantTypeUUID):
occupant_type = OccupantTypes.query.filter(
OccupantTypes.uu_id == data.uu_id
).populate_existing()
if records := occupant_type.first():
return JSONResponse(
content={
"completed": True,
"message": "Get single occupant type via uu_id",
"data": records.get_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Occupant type not found",
)

0
service_app/routers/application/router.py Normal file
View File

144
service_app/routers/authentication/router.py Normal file
View File

@@ -0,0 +1,144 @@
from typing import Union
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
Login,
Logout,
ChangePassword,
Remember,
Forgot,
CreatePassword,
OccupantSelection,
EmployeeSelection,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_events.events import (
AuthenticationLoginEventMethod,
AuthenticationSelectEventMethod,
AuthenticationCheckTokenEventMethod,
AuthenticationRefreshEventMethod,
AuthenticationChangePasswordEventMethod,
AuthenticationCreatePasswordEventMethod,
AuthenticationDisconnectUserEventMethod,
AuthenticationLogoutEventMethod,
AuthenticationRefreshTokenEventMethod,
AuthenticationForgotPasswordEventMethod,
AuthenticationDownloadAvatarEventMethod,
)
login_route = APIRouter(prefix="/authentication", tags=["Authentication"])
login_route.include_router(login_route, include_in_schema=True)
@login_route.post(path="/select", summary="Select company or occupant type")
def authentication_select_company_or_occupant_type(
request: Request, data: Union[EmployeeSelection, OccupantSelection]
):
active_function = getattr(
AuthenticationSelectEventMethod,
"authentication_select_company_or_occupant_type",
)
return active_function(data=data, request=request, token_dict=None)
@login_route.post(path="/login", summary="Login user with domain and password")
def authentication_login_with_domain_and_creds(request: Request, data: Login):
active_function = getattr(
AuthenticationLoginEventMethod, "authentication_login_with_domain_and_creds"
)
return active_function(data=data, request=request, token_dict=None)
@login_route.get(path="/valid", summary="Check access token is valid")
def authentication_check_token_is_valid(request: Request):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationCheckTokenEventMethod, "authentication_check_token_is_valid"
)
return active_function(request=request, token_dict=token_dict)
@login_route.get(path="/refresh", summary="Refresh credentials with access token")
def authentication_refresh_user_info(request: Request):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationRefreshEventMethod, "authentication_refresh_user_info"
)
return active_function(request=request, token_dict=token_dict)
@login_route.post(path="/change_password", summary="Change password with access token")
def authentication_change_password(request: Request, data: ChangePassword):
active_function = getattr(
AuthenticationChangePasswordEventMethod, "authentication_change_password"
)
return active_function(data=data, request=request, token_dict=None)
@login_route.post(
path="/create_password", summary="Create password with password token"
)
def authentication_create_password(request: Request, data: CreatePassword):
active_function = getattr(
AuthenticationCreatePasswordEventMethod, "authentication_create_password"
)
return active_function(data=data, request=request, token_dict=None)
@login_route.post(path="/disconnect", summary="Disconnect user with access token")
def authentication_disconnect_user(request: Request, data: Logout):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationDisconnectUserEventMethod, "authentication_disconnect_user"
)
return active_function(data=data, request=request, token_dict=token_dict)
@login_route.post(path="/logout", summary="Logout user with access token")
def authentication_logout_user(request: Request, data: Logout):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationLogoutEventMethod, "authentication_logout_user"
)
return active_function(data=data, request=request, token_dict=token_dict)
@login_route.post(path="/refresher", summary="Refresh token with refresh token")
def authentication_refresher_token(request: Request, data: Remember):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationRefreshTokenEventMethod, "authentication_refresher_token"
)
return active_function(data=data, request=request, token_dict=token_dict)
@login_route.post(path="/forgot", summary="Forgot password with email or phone number")
def authentication_forgot_password(request: Request, data: Forgot):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationForgotPasswordEventMethod, "authentication_forgot_password"
)
return active_function(data=data, request=request, token_dict=token_dict)
@login_route.post(path="/avatar", summary="Get link of avatar with credentials")
def authentication_download_avatar(request: Request, data: Forgot):
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(
AuthenticationDownloadAvatarEventMethod, "authentication_download_avatar"
)
return active_function(data=data, request=request, token_dict=token_dict)

39
service_app/routers/building/build/router.py Normal file
View File

@@ -0,0 +1,39 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
PatchRecord,
ListOptions,
InsertBuild,
UpdateBuild,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_route = APIRouter(prefix="/building/build", tags=["Building"])
build_route.include_router(build_route, include_in_schema=True)
@build_route.post(path="/list", summary="List Build Active/Delete/Confirm Build")
def building_build_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@build_route.post(path="/create", summary="Create Build with given auth levels")
def building_build_create(request: Request, data: InsertBuild):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_route.post(path="/update/{build_uu_id}", summary="Update Build Parts with given auth levels")
def building_build_update(request: Request, build_uu_id: str, data: UpdateBuild):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, build_uu_id=build_uu_id, token_dict=token_dict)
@build_route.patch(path="/patch/{build_uu_id}", summary="Patch Build Parts with given auth levels")
def building_build_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, build_uu_id=build_uu_id, token_dict=token_dict)

109
service_app/routers/building/buildarea/router.py Normal file
View File

@@ -0,0 +1,109 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildArea,
UpdateBuildArea,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.core_response import return_json_response_from_alchemy
from databases import (
BuildArea,
Build,
)
build_area_route = APIRouter(prefix="/building/area", tags=["Building Area"])
build_area_route.include_router(build_area_route, include_in_schema=True)
@build_area_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
def build_area_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
Build.filter_attr = list_options
records = BuildArea.filter_active(
*BuildArea.get_smart_query(smart_query=list_options.query),
BuildArea.company_id == token_dict.selected_company.company_id,
)
return return_json_response_from_alchemy(response=records, pagination=list_options)
@build_area_route.post(
path="/create", summary="Create BuildParts with given auth levels"
)
def build_area_create(request: Request, data: InsertBuildArea):
token_dict = parse_token_object_to_dict(request=request)
created_build = BuildArea.create_action(data=data, token=token_dict)
return JSONResponse(
content={
"completed": True,
"message": "Create BuildParts record",
"data": created_build.get_dict(),
"build": created_build,
},
status_code=status.HTTP_200_OK,
)
@build_area_route.post(
path="/update/{build_uu_id}", summary="Update BuildParts with given auth levels"
)
def build_area_update(request: Request, build_uu_id: str, data: UpdateBuildArea):
token_dict = parse_token_object_to_dict(request=request)
if updated_build := BuildArea.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
):
return JSONResponse(
content={
"completed": True,
"message": "Update BuildParts record",
"data": updated_build,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update BuildParts record", "data": {}},
status_code=status.HTTP_200_OK,
)
@build_area_route.patch(
path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
)
def build_area_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
find_one_build = BuildArea.find_one_or_abort(uu_id=build_uu_id)
access_authorized_build = BuildArea.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[BuildArea.id == find_one_build.id],
)
if access_authorized_build.count:
action = data.excluded_dump()
find_one_build.active = bool(action.get("active", find_one_build.active))
find_one_build.is_confirmed = bool(
action.get("confirm", find_one_build.is_confirmed)
)
find_one_build.deleted = bool(action.get("delete", find_one_build.deleted))
find_one_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch BuildParts record completed",
"data": find_one_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch BuildParts record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)

92
service_app/routers/building/buildparts/router.py Normal file
View File

@@ -0,0 +1,92 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildParts,
UpdateBuildParts,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from databases import BuildParts
build_parts_route = APIRouter(prefix="/building/parts", tags=["Building Parts"])
build_parts_route.include_router(build_parts_route, include_in_schema=True)
@build_parts_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
def building_build_part_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@build_parts_route.post(
path="/create", summary="Create Build Parts with given auth levels"
)
def building_build_part_create(request: Request, data: InsertBuildParts):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_parts_route.post(
path="/update/{build_uu_id}", summary="Update Build Parts with given auth levels"
)
def building_build_part_update(
request: Request, build_uu_id: str, data: UpdateBuildParts
):
token_dict = parse_token_object_to_dict(request=request)
if updated_build := BuildParts.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
):
return JSONResponse(
content={
"completed": True,
"message": "Update Build Parts record",
"data": updated_build,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update Build Parts record", "data": {}},
status_code=status.HTTP_200_OK,
)
@build_parts_route.patch(
path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
)
def building_build_part_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
find_one_build = BuildParts.find_one_or_abort(uu_id=build_uu_id)
access_authorized_build = BuildParts.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[BuildParts.id == find_one_build.id],
)
if access_authorized_build.count:
action = data.excluded_dump()
find_one_build.active = bool(action.get("active", find_one_build.active))
find_one_build.is_confirmed = bool(
action.get("confirm", find_one_build.is_confirmed)
)
find_one_build.deleted = bool(action.get("delete", find_one_build.deleted))
find_one_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch Build record completed",
"data": find_one_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Build record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)

106
service_app/routers/building/buildsites/router.py Normal file
View File

@@ -0,0 +1,106 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
PatchRecord,
ListOptions,
InsertBuildSites,
UpdateBuildSites,
)
from databases import BuildSites
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.core_response import return_json_response_from_alchemy
build_sites_route = APIRouter(prefix="/building/sites", tags=["Building Sites"])
build_sites_route.include_router(build_sites_route, include_in_schema=True)
@build_sites_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
def building_sites_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
BuildSites.filter_attr = list_options
records = BuildSites.filter_active(
*BuildSites.get_smart_query(smart_query=list_options.query),
BuildSites.company_id == token_dict.selected_company.company_id,
)
return return_json_response_from_alchemy(response=records, pagination=list_options)
@build_sites_route.post(
path="/create", summary="Create Build Sites with given auth levels"
)
def building_sites_create(request: Request, data: InsertBuildSites):
token_dict = parse_token_object_to_dict(request=request)
created_build = BuildSites.create_action(data=data, token=token_dict)
return JSONResponse(
content={
"completed": True,
"message": "Create Build Sites record",
"data": created_build.get_dict(),
"build": created_build,
},
status_code=status.HTTP_200_OK,
)
@build_sites_route.post(
path="/update/{build_uu_id}", summary="Update Build Sites with given auth levels"
)
def building_sites_update(request: Request, build_uu_id: str, data: UpdateBuildSites):
token_dict = parse_token_object_to_dict(request=request)
if updated_build := BuildSites.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
):
return JSONResponse(
content={
"completed": True,
"message": "Update Build Sites record",
"data": updated_build,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update Build Sites record", "data": {}},
status_code=status.HTTP_200_OK,
)
@build_sites_route.patch(
path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
)
def building_sites_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
find_one_build = BuildSites.find_one_or_abort(uu_id=build_uu_id)
access_authorized_build = BuildSites.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[BuildSites.id == find_one_build.id],
)
if access_authorized_build.count:
action = data.excluded_dump()
find_one_build.active = bool(action.get("active", find_one_build.active))
find_one_build.is_confirmed = bool(
action.get("confirm", find_one_build.is_confirmed)
)
find_one_build.deleted = bool(action.get("delete", find_one_build.deleted))
find_one_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch Build Sites record completed",
"data": find_one_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Build Sites record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)

103
service_app/routers/building/buildtypes/router.py Normal file
View File

@@ -0,0 +1,103 @@
from fastapi import status
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildTypes,
UpdateBuildTypes,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.core_response import return_json_response_from_alchemy
from databases import BuildTypes
build_types_route = APIRouter(prefix="/building/types", tags=["Types"])
build_types_route.include_router(build_types_route, include_in_schema=True)
@build_types_route.post(path="/list", summary="List Active/Delete/Confirm Build Parts")
def building_types_list(list_options: ListOptions):
BuildTypes.filter_attr = list_options
records = BuildTypes.filter_active(
*BuildTypes.get_smart_query(smart_query=list_options.query),
)
return return_json_response_from_alchemy(response=records, pagination=list_options)
@build_types_route.post(
path="/create", summary="Create BuildParts with given auth levels"
)
def building_types_create(request: Request, data: InsertBuildTypes):
token_dict = parse_token_object_to_dict(request=request)
created_build = BuildTypes.create_action(data=data, token=token_dict)
return JSONResponse(
content={
"completed": True,
"message": "Create BuildParts record",
"data": created_build.get_dict(),
"build": created_build,
},
status_code=status.HTTP_200_OK,
)
@build_types_route.post(
path="/update/{build_uu_id}", summary="Update BuildParts with given auth levels"
)
def building_types_update(request: Request, build_uu_id: str, data: UpdateBuildTypes):
token_dict = parse_token_object_to_dict(request=request)
if updated_build := BuildTypes.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
):
return JSONResponse(
content={
"completed": True,
"message": "Update BuildParts record",
"data": updated_build,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update BuildParts record", "data": {}},
status_code=status.HTTP_200_OK,
)
@build_types_route.patch(
path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
)
def building_types_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
find_one_build = BuildTypes.find_one_or_abort(uu_id=build_uu_id)
access_authorized_build = BuildTypes.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[BuildTypes.id == find_one_build.id],
)
if access_authorized_build.count:
action = data.excluded_dump()
find_one_build.active = bool(action.get("active", find_one_build.active))
find_one_build.is_confirmed = bool(
action.get("confirm", find_one_build.is_confirmed)
)
find_one_build.deleted = bool(action.get("delete", find_one_build.deleted))
find_one_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch BuildParts record completed",
"data": find_one_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch BuildParts record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)

52
service_app/routers/building/livingspaces/router.py Normal file
View File

@@ -0,0 +1,52 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildLivingSpace,
UpdateBuildLivingSpace,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_living_space = APIRouter(prefix="/building/living_space", tags=["Living Space"])
build_living_space.include_router(build_living_space, include_in_schema=True)
@build_living_space.post(
path="/list", summary="List Active/Delete/Confirm Build Living Space"
)
def building_living_space_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@build_living_space.post(
path="/create", summary="Create Build Living Space with given auth levels"
)
def building_living_space_create(request: Request, data: InsertBuildLivingSpace):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_living_space.post(
path="/update/{build_uu_id}",
summary="Update Build Living Space with given auth levels",
)
def building_living_space_update(
request: Request, build_uu_id: str, data: UpdateBuildLivingSpace
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, build_uu_id=build_uu_id, token_dict=token_dict
)
@build_living_space.patch(
path="/patch/{build_uu_id}", summary="Update Active/Delete/Confirm"
)
def building_living_space_patch(request: Request, build_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, build_uu_id=build_uu_id, token_dict=token_dict
)

47
service_app/routers/company/company/router.py Normal file
View File

@@ -0,0 +1,47 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertCompany,
UpdateCompany,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
company_route = APIRouter(prefix="/company", tags=["Company"])
company_route.include_router(company_route, include_in_schema=True)
@company_route.post(path="/list", summary="List Active/Delete/Confirm Companies")
def company_company_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@company_route.post(path="/create", summary="Create Company with given auth levels")
def company_company_create(request: Request, data: InsertCompany):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@company_route.post(
path="/update/{company_uu_id}", summary="Update Company with given auth levels"
)
def company_company_update(request: Request, company_uu_id: str, data: UpdateCompany):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)
@company_route.patch(
path="/patch/{company_uu_id}", summary="Update Active/Delete/Confirm"
)
def company_company_patch(request: Request, company_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)

47
service_app/routers/company/department/router.py Normal file
View File

@@ -0,0 +1,47 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
department_route = APIRouter(prefix="/department", tags=["Departments"])
department_route.include_router(department_route, include_in_schema=True)
@department_route.post(path="/list", summary="List Active/Delete/Confirm Departments")
def company_department_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@department_route.post(path="/create", summary="Create Company with given auth levels")
def company_department_create(request: Request, data: DepartmentsPydantic):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@department_route.post(
path="/update/{company_uu_id}", summary="Update Company with given auth levels"
)
def company_department_update(
request: Request, company_uu_id: str, data: DepartmentsPydantic
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
company_uu_id=company_uu_id, data=data, token_dict=token_dict
)
@department_route.patch(
path="/patch/{company_uu_id}", summary="Patch Company with given auth levels"
)
def company_department_patch(request: Request, company_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
company_uu_id=company_uu_id, data=data, token_dict=token_dict
)

54
service_app/routers/company/duties/router.py Normal file
View File

@@ -0,0 +1,54 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertDuties,
UpdateDuties,
SelectDuties,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
duties_route = APIRouter(prefix="/duties", tags=["Duties"])
duties_route.include_router(duties_route, include_in_schema=True)
@duties_route.post(path="/list", summary="List Active/Delete/Confirm Duties")
def company_duties_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=list_options, token_dict=token_dict)
@duties_route.post(path="/get_by_duty_uuid", summary="Get Single Duty by Duty UUID")
def company_duties_get_by_duty_uuid(request: Request, data: SelectDuties):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@duties_route.post(path="/create", summary="Create Duties with given auth levels")
def company_duties_create(request: Request, data: InsertDuties):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@duties_route.post(
path="/update/{duties_uu_id}", summary="Update Duties with given auth levels"
)
def company_duties_update(request: Request, duties_uu_id: str, data: UpdateDuties):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, duties_uu_id=duties_uu_id, token_dict=token_dict
)
@duties_route.patch(
path="/patch/{duties_uu_id}", summary="Patch Duties with given auth levels"
)
def company_duties_patch(request: Request, duties_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, duties_uu_id=duties_uu_id, token_dict=token_dict
)

44
service_app/routers/company/duty/router.py Normal file
View File

@@ -0,0 +1,44 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertCompanyDuty,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
duty_route = APIRouter(prefix="/duty", tags=["Duty"])
duty_route.include_router(duty_route, include_in_schema=True)
@duty_route.post(path="/list", summary="List Active/Delete/Confirm Duty")
def company_duty_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@duty_route.post(path="/create", summary="Create Company with given auth levels")
def company_duty_create(request: Request, data: InsertCompanyDuty):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@duty_route.post(
path="/update/{company_uu_id}", summary="Update Company with given auth levels"
)
def company_duty_update(request: Request, company_uu_id: str, data):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)
@duty_route.patch(path="/patch/{company_uu_id}", summary="Update Active/Delete/Confirm")
def company_duty_patch(request: Request, company_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)

60
service_app/routers/company/employee/router.py Normal file
View File

@@ -0,0 +1,60 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertEmployees,
UnBindEmployees2People,
BindEmployees2People,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
employee_route = APIRouter(prefix="/employee", tags=["Employee"])
employee_route.include_router(employee_route, include_in_schema=True)
@employee_route.post(path="/list", summary="List Active/Delete/Confirm Staff")
def company_employee_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=list_options, token_dict=token_dict)
@employee_route.post(path="/create", summary="Create Employee with given auth levels")
def company_employee_create(request: Request, data: InsertEmployees):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@employee_route.post(
path="/update/{employee_uu_id}", summary="Update Employee with given auth levels"
)
def company_employee_update(request: Request, employee_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, employee_uu_id=employee_uu_id, token_dict=token_dict
)
@employee_route.patch(
path="/patch/{employee_uu_id}", summary="Update Active/Delete/Confirm"
)
def company_employee_patch(request: Request, employee_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, employee_uu_id=employee_uu_id, token_dict=token_dict
)
@employee_route.post(path="/employ", summary="Employ Employee with given auth levels")
def company_employee_employ(request: Request, data: BindEmployees2People):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@employee_route.post(path="/fire", summary="UnEmploy Employee with given auth levels")
def company_employee_fire(request: Request, data: UnBindEmployees2People):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)

51
service_app/routers/company/staff/router.py Normal file
View File

@@ -0,0 +1,51 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertStaff,
SelectStaff,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
staff_route = APIRouter(prefix="/staff", tags=["Staff"])
staff_route.include_router(staff_route, include_in_schema=True)
@staff_route.post(path="/list", summary="List Active/Delete/Confirm Staff")
def company_staff_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@staff_route.post(path="/get_by_duties_uu_id", summary="Get Staff by UUID")
def company_staff_get_by_uu_id(request: Request, data: SelectStaff):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@staff_route.post(path="/create", summary="Create Staff with given auth levels")
def company_staff_create(request: Request, data: InsertStaff):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@staff_route.post(
path="/update/{staff_uu_id}", summary="Update Staff with given auth levels"
)
def company_staff_update(request: Request, staff_uu_id: str, data):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, staff_uu_id=staff_uu_id, token_dict=token_dict
)
@staff_route.patch(path="/patch/{staff_uu_id}", summary="Update Active/Delete/Confirm")
def company_staff_patch(request: Request, staff_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, staff_uu_id=staff_uu_id, token_dict=token_dict
)

89
service_app/routers/decision_book/decision_book/router.py Normal file
View File

@@ -0,0 +1,89 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertDecisionBook,
UpdateDecisionBook,
DecisionBookDecisionBookInvitations,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_decision_book_route = APIRouter(
prefix="/build/decision_book", tags=["Decision Book"]
)
build_decision_book_route.include_router(
build_decision_book_route, include_in_schema=True
)
@build_decision_book_route.post(
path="/list", summary="List Active/Delete/Confirm Build Decision Book"
)
def build_decision_book_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@build_decision_book_route.post(
path="/create", summary="Create Build Decision Book with given auth levels"
)
def build_decision_book_create(request: Request, data: InsertDecisionBook):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_route.post(
path="/approval", summary="Approve Build Decision Book with given auth levels"
)
def build_decision_book_approval(request: Request, data):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_route.post(
path="/update/{book_uu_id}",
summary="Update Build Decision Book with given auth levels",
)
def build_decision_book_update(
request: Request, book_uu_id: str, data: UpdateDecisionBook
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_route.patch(
path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
)
def build_decision_book_patch(request: Request, book_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_route.post(
path="/invite/list", summary="List Build Decision Book Invitations"
)
def build_decision_book_invite(request: Request, data: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=data, token_dict=token_dict)
@build_decision_book_route.post(
path="/invite/create", summary="Create Build Decision Book Invitations"
)
def build_decision_book_invite_create(
request: Request, data: DecisionBookDecisionBookInvitations
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_route.post(
path="/invite/update", summary="Update Build Decision Book Invitations"
)
def build_decision_book_invite_update(request: Request, data):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)

38
service_app/routers/decision_book/decision_book_invitations/router.py Normal file
View File

@@ -0,0 +1,38 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DecisionBookDecisionBookInvitationsAttend,
DecisionBookDecisionBookInvitationsAssign,
PatchRecord,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_decision_book_invitations = APIRouter(
prefix="/build/decision_book/invitations", tags=["Decision Book Invitations"]
)
build_decision_book_invitations.include_router(
build_decision_book_invitations, include_in_schema=True
)
@build_decision_book_invitations.post(
path="/attend", summary="Decision Book Invitations Attend"
)
def build_decision_book_invitations_attend(
request: Request, data: DecisionBookDecisionBookInvitationsAttend
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_invitations.post(
path="/assign", summary="Decision Book Invitations Assign"
)
def build_decision_book_invitations_assign(
request: Request, data: DecisionBookDecisionBookInvitationsAssign
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)

62
service_app/routers/decision_book/decision_book_items/router.py Normal file
View File

@@ -0,0 +1,62 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildDecisionBookItems,
UpdateBuildDecisionBookItems,
ListDecisionBook,
PatchRecord,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_decision_book_items_route = APIRouter(
prefix="/build/decision_book/items", tags=["Decision Book Items"]
)
build_decision_book_items_route.include_router(
build_decision_book_items_route, include_in_schema=True
)
@build_decision_book_items_route.post(
path="/list", summary="List Active/Delete/Confirm Build Decision Book Items"
)
def build_decision_book_items_list(request: Request, data: ListDecisionBook):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_items_route.post(
path="/create", summary="Create Build Items Decision Book with given auth levels"
)
def build_decision_book_items_create(
request: Request, data: InsertBuildDecisionBookItems
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_items_route.post(
path="/update/{book_uu_id}",
summary="Update Build Decision Book Items with given auth levels",
)
def build_decision_book_items_update(
request: Request, book_uu_id: str, data: UpdateBuildDecisionBookItems
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, book_uu_id=book_uu_id, token_dict=token_dict
)
@build_decision_book_items_route.patch(
path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
)
def build_decision_book_items_patch(
request: Request, book_uu_id: str, data: PatchRecord
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, book_uu_id=book_uu_id, token_dict=token_dict
)

55
service_app/routers/decision_book/decision_book_person/router.py Normal file
View File

@@ -0,0 +1,55 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertDecisionBook,
UpdateDecisionBook,
DecisionBookDecisionBookInvitationsAttend,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
build_decision_book_people_route = APIRouter(
prefix="/build/decision_book/people", tags=["Decision Book People"]
)
build_decision_book_people_route.include_router(
build_decision_book_people_route, include_in_schema=True
)
@build_decision_book_people_route.post(
path="/list", summary="List Active/Delete/Confirm Build Decision Book People"
)
def build_decision_book_people_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@build_decision_book_people_route.post(
path="/add",
summary="Add people to Build Decision People Book with given auth levels",
)
def build_decision_book_people_add(request: Request, data: InsertDecisionBook):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_people_route.post(
path="/remove",
summary="Remove people from Build Decision Book People with given auth levels",
)
def build_decision_book_people_remove(request: Request, data: UpdateDecisionBook):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@build_decision_book_people_route.post(
path="/attend",
summary="Attend to Build Decision Book Invitations with given auth levels",
)
def build_decision_book_invite_attend(
request: Request, data: DecisionBookDecisionBookInvitationsAttend
):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)

35
service_app/routers/events/events/bind_events_router.py Normal file
View File

@@ -0,0 +1,35 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.validations_request import (
RegisterEvents2Employee,
RegisterEvents2Occupant,
PatchRecord,
)
bind_events_route = APIRouter(prefix="/bind/events", tags=["Binds"])
bind_events_route.include_router(bind_events_route, include_in_schema=True)
@bind_events_route.post(path="/occupant", summary="Register Event to Occupant")
def bind_events_occupant(request: Request, data: RegisterEvents2Occupant):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@bind_events_route.post(path="/employee", summary="Register Event to Employee")
def bind_events_employee(request: Request, data: RegisterEvents2Employee):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@bind_events_route.patch(
path="/patch/{event_uu_id}", summary="Patch Bind Events with given auth levels"
)
def bind_events_patch(request: Request, event_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, event_uu_id=event_uu_id, token_dict=token_dict
)

36
service_app/routers/events/events/router.py Normal file
View File

@@ -0,0 +1,36 @@
from fastapi import Request
from fastapi.routing import APIRouter
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.validations_request import (
CreateEvents,
ListOptions,
)
event_route = APIRouter(prefix="/event", tags=["Events"])
event_route.include_router(event_route, include_in_schema=True)
@event_route.post(path="/create", summary="Create Event")
def events_create(request: Request, data: CreateEvents):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@event_route.post(path="/list", summary="List Events")
def events_list(request: Request, data: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@event_route.post(path="/update", summary="Update Event")
def events_update(request: Request, data: CreateEvents):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
# @event_route.patch(path="/patch", summary="Patch Event")
# def events_patch(request: Request, data: CreateEvents):
# token_dict = parse_token_object_to_dict(request=request)
# return token_dict.available_event(data=data, token_dict=token_dict)

62
service_app/routers/events/modelentities/router.py Normal file
View File

@@ -0,0 +1,62 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
model_entities_route = APIRouter(prefix="/model/entities", tags=["Model Entities"])
model_entities_route.include_router(model_entities_route, include_in_schema=True)
@model_entities_route.post(path="/list", summary="List Active/Delete/Confirm Events")
def model_entities_list(request: Request, list_options: ListOptions):
from events.events_model_entities import ModelEntitiesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEntitiesEvents, "model_entities_list")
return active_function(data=list_options, token_dict=token_dict)
@model_entities_route.post(
path="/create", summary="Create Events with given auth levels"
)
def model_entities_create(request: Request, data: DepartmentsPydantic):
from events.events_model_entities import ModelEntitiesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEntitiesEvents, "model_entities_create")
return active_function(data=data, token_dict=token_dict)
@model_entities_route.post(
path="/update/{company_uu_id}", summary="Update Events with given auth levels"
)
def model_entities_update(
request: Request, company_uu_id: str, data: DepartmentsPydantic
):
from events.events_model_entities import ModelEntitiesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEntitiesEvents, "model_entities_update")
return active_function(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)
@model_entities_route.patch(
path="/patch/{company_uu_id}", summary="Patch Events with given auth levels"
)
def model_entities_patch(request: Request, company_uu_id: str, data: PatchRecord):
from events.events_model_entities import ModelEntitiesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEntitiesEvents, "model_entities_patch")
return active_function(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)

58
service_app/routers/events/models/router.py Normal file
View File

@@ -0,0 +1,58 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
model_route = APIRouter(prefix="/model/entities", tags=["Model Entities"])
model_route.include_router(model_route, include_in_schema=True)
@model_route.post(path="/list", summary="List Active/Delete/Confirm Events")
def model_list(request: Request, list_options: ListOptions):
from events.events_models import ModelEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEvents, "model_list")
return active_function(data=list_options, token_dict=token_dict)
@model_route.post(path="/create", summary="Create Events with given auth levels")
def model_create(request: Request, data: DepartmentsPydantic):
from events.events_models import ModelEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEvents, "model_create")
return active_function(data=data, token_dict=token_dict)
@model_route.post(
path="/update/{company_uu_id}", summary="Update Events with given auth levels"
)
def model_update(request: Request, company_uu_id: str, data: DepartmentsPydantic):
from events.events_models import ModelEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEvents, "model_list")
return active_function(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)
@model_route.patch(
path="/patch/{company_uu_id}", summary="Patch Events with given auth levels"
)
def model_patch(request: Request, company_uu_id: str, data: PatchRecord):
from events.events_models import ModelEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModelEvents, "model_list")
return active_function(
data=data, company_uu_id=company_uu_id, token_dict=token_dict
)

54
service_app/routers/events/modules/router.py Normal file
View File

@@ -0,0 +1,54 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
modules_route = APIRouter(prefix="/modules", tags=["Modules"])
modules_route.include_router(modules_route, include_in_schema=True)
@modules_route.post(path="/list", summary="List Active/Delete/Confirm Modules")
def modules_list(request: Request, list_options: ListOptions):
from events.events_modules import ModulesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModulesEvents, "modules_list")
return active_function(list_options=list_options, token_dict=token_dict)
@modules_route.post(path="/create", summary="Create Modules with given auth levels")
def modules_create(request: Request, data: DepartmentsPydantic):
from events.events_modules import ModulesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModulesEvents, "modules_create")
return active_function(data=data, token_dict=token_dict)
@modules_route.post(
path="/update/{module_uu_id}", summary="Update Modules with given auth levels"
)
def modules_update(request: Request, module_uu_id: str, data: DepartmentsPydantic):
from events.events_modules import ModulesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModulesEvents, "modules_update")
return active_function(data=data, module_uu_id=module_uu_id, token_dict=token_dict)
@modules_route.patch(
path="/patch/{module_uu_id}", summary="Patch Modules with given auth levels"
)
def modules_patch(request: Request, module_uu_id: str, data: PatchRecord):
from events.events_modules import ModulesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ModulesEvents, "modules_patch")
return active_function(data=data, token_dict=token_dict)

25
service_app/routers/events/services/bind_services_router.py Normal file
View File

@@ -0,0 +1,25 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
RegisterServices2Employee,
RegisterServices2Occupant,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
bind_services_route = APIRouter(prefix="/bind/services", tags=["Binds"])
bind_services_route.include_router(bind_services_route, include_in_schema=True)
@bind_services_route.post(path="/occupant", summary="Bind Services to Occupant")
def bind_services_occupant(request: Request, data: RegisterServices2Occupant):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@bind_services_route.post(path="/employee", summary="Bind Services to Employee")
def bind_services_employee(request: Request, data: RegisterServices2Employee):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)

56
service_app/routers/events/services/router.py Normal file
View File

@@ -0,0 +1,56 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
DepartmentsPydantic, PatchRecord, ListOptions
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
services_route = APIRouter(prefix="/services", tags=["Services"])
services_route.include_router(services_route, include_in_schema=True)
@services_route.post(path="/list", summary="List Active/Delete/Confirm Modules")
def services_list(request: Request, list_options: ListOptions):
from events.events_services import ServicesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ServicesEvents, "services_list")
return active_function(list_options=list_options, token_dict=token_dict)
@services_route.post(path="/create", summary="Create Modules with given auth levels")
def services_create(request: Request, data: DepartmentsPydantic):
from events.events_services import ServicesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ServicesEvents, "services_create")
return active_function(data=data, token_dict=token_dict)
@services_route.post(
path="/update/{service_uu_id}", summary="Update Modules with given auth levels"
)
def services_update(request: Request, service_uu_id: str, data: DepartmentsPydantic):
from events.events_services import ServicesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ServicesEvents, "services_update")
return active_function(
data=data, service_uu_id=service_uu_id, token_dict=token_dict
)
@services_route.patch(
path="/patch/{service_uu_id}", summary="Patch Modules with given auth levels"
)
def services_patch(request: Request, service_uu_id: str, data: PatchRecord):
from events.events_services import ServicesEvents
token_dict = parse_token_object_to_dict(request=request)
active_function = getattr(ServicesEvents, "services_patch")
return active_function(
data=data, service_uu_id=service_uu_id, token_dict=token_dict
)

42
service_app/routers/people/router.py Normal file
View File

@@ -0,0 +1,42 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertPerson, UpdateUsers, PatchRecord, ListOptions
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
people_router = APIRouter(prefix="/people", tags=["People"])
people_router.include_router(people_router, include_in_schema=True)
@people_router.post(path="/list", summary="List Active/Delete/Confirm People")
def people_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@people_router.post(path="/create", summary="Create People with given auth levels")
def people_create(request: Request, data: InsertPerson):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@people_router.post(
path="/update/{user_uu_id}", summary="Update People with given auth levels"
)
def people_update(request: Request, user_uu_id: str, data: UpdateUsers):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, user_uu_id=user_uu_id, token_dict=token_dict
)
@people_router.patch(path="/patch/{user_uu_id}", summary="Update Active/Delete/Confirm")
def people_patch(request: Request, user_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, user_uu_id=user_uu_id, token_dict=token_dict
)

80
service_app/routers/project_decision_book/project_decision_book/router.py Normal file
View File

@@ -0,0 +1,80 @@
from fastapi import status, HTTPException
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
InsertBuildDecisionBookProjects,
UpdateBuildDecisionBookProjects,
PatchRecord,
ListOptions,
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.core_response import return_json_response_from_alchemy
from databases import BuildDecisionBookProjects
build_project_decision_book_route = APIRouter(
prefix="/build/project/decision_book", tags=["Project Decision Book"]
)
build_project_decision_book_route.include_router(
build_project_decision_book_route, include_in_schema=True
)
@build_project_decision_book_route.post(
path="/list", summary="List Active/Delete/Confirm Project Build Decision Book"
)
def project_decision_book_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
BuildDecisionBookProjects.pre_query = BuildDecisionBookProjects.select_action(
duty_id=token_dict.duty_list["duty_id"]
)
build_decision_book_records = BuildDecisionBookProjects.filter_active(
*BuildDecisionBookProjects.get_smart_query(list_options.query)
)
return return_json_response_from_alchemy(
response=build_decision_book_records, pagination=list_options
)
@build_project_decision_book_route.post(
path="/create", summary="Create Build Project Decision Book with given auth levels"
)
def project_decision_book_create(
request: Request, data: InsertBuildDecisionBookProjects
):
token_dict = parse_token_object_to_dict(request=request)
if build_decision_book_records := BuildDecisionBookProjects.create_action(
data=data, token=token_dict
):
return JSONResponse(
content={
"completed": True,
"message": "Create Build record",
"data": build_decision_book_records.get_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=401,
detail=f"This user can not access/modify {data.build_uu_id} - building",
)
@build_project_decision_book_route.post(
path="/update/{book_uu_id}",
summary="Update Project Build Decision Book with given auth levels",
)
def project_decision_book_update(
request: Request, book_uu_id: str, data: UpdateBuildDecisionBookProjects
):
return
@build_project_decision_book_route.patch(
path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
)
def project_decision_book_patch(request: Request, book_uu_id: str, data: PatchRecord):
return

78
service_app/routers/project_decision_book/project_decision_book_person/router.py Normal file
View File

@@ -0,0 +1,78 @@
from fastapi import status, HTTPException
from fastapi.routing import APIRouter
from fastapi.responses import JSONResponse
from fastapi.requests import Request
from api_validations.validations_request import (
InsertDecisionBook, UpdateDecisionBook, PatchRecord, ListOptions
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
from api_validations.core_response import return_json_response_from_alchemy
from databases import BuildDecisionBook, Build
build_project_decision_book_person_route = APIRouter(
prefix="/build/decision_book/person", tags=["Decision Book Person"]
)
build_project_decision_book_person_route.include_router(
build_project_decision_book_person_route, include_in_schema=True
)
@build_project_decision_book_person_route.post(
path="/list", summary="List Active/Delete/Confirm Build Decision Book"
)
def project_decision_book_person_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
BuildDecisionBook.pre_query = BuildDecisionBook.select_action(
duty_id=token_dict.duty_list["duty_id"]
)
build_decision_book_records = BuildDecisionBook.filter_active(
*BuildDecisionBook.get_smart_query(list_options.query)
)
return return_json_response_from_alchemy(
response=build_decision_book_records, pagination=list_options
)
@build_project_decision_book_person_route.post(
path="/create", summary="Create Build Decision Book with given auth levels"
)
def project_decision_book_person_create(request: Request, data: InsertDecisionBook):
token_dict = parse_token_object_to_dict(request=request)
Build.pre_query = Build.select_action(duty_id=token_dict.duty_list["duty_id"])
if Build.find_one(uu_id=data.build_uu_id):
build_decision_book_records = BuildDecisionBook.create_action(data=data)
return JSONResponse(
content={
"completed": True,
"message": "Create Build record",
"data": build_decision_book_records.get_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=401,
detail=f"This user can not access/modify {data.build_uu_id} - building",
)
@build_project_decision_book_person_route.post(
path="/update/{book_uu_id}",
summary="Update Build Decision Book with given auth levels",
)
def project_decision_book_person_update(
request: Request, book_uu_id: str, data: UpdateDecisionBook
):
return
@build_project_decision_book_person_route.patch(
path="/patch/{book_uu_id}", summary="Update Active/Delete/Confirm"
)
def project_decision_book_person_patch(
request: Request, book_uu_id: str, data: PatchRecord
):
return

45
service_app/routers/rules/router.py Normal file
View File

@@ -0,0 +1,45 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import UpdateEndpointAccessList, InsertEndpointAccess
from api_services.redis.auth_actions.token import parse_token_object_to_dict
endpoint_restriction_route = APIRouter(prefix="/access", tags=["Endpoint Access"])
endpoint_restriction_route.include_router(
endpoint_restriction_route, include_in_schema=True
)
@endpoint_restriction_route.post(
path="/endpoint/restriction/create",
summary="Add extra restriction to endpoints list",
)
def endpoint_restriction_create(request: Request, data: InsertEndpointAccess):
token_dict = parse_token_object_to_dict(request=request)
return
@endpoint_restriction_route.post(
path="/endpoint/bind/update", summary="Update extra restriction to endpoints list"
)
def endpoint_restriction_update(request: Request, data: UpdateEndpointAccessList):
token_dict = parse_token_object_to_dict(request=request)
return
@endpoint_restriction_route.post(
path="/endpoint/bind/list", summary="List extra restriction to endpoints list"
)
def endpoint_restriction_list(request: Request):
token_dict = parse_token_object_to_dict(request=request)
return
@endpoint_restriction_route.patch(
path="/endpoint/bind/patch", summary="Patch extra restriction to endpoints list"
)
def endpoint_restriction_patch(request: Request):
token_dict = parse_token_object_to_dict(request=request)
return

42
service_app/routers/users/router.py Normal file
View File

@@ -0,0 +1,42 @@
from fastapi.routing import APIRouter
from fastapi.requests import Request
from api_validations.validations_request import (
InsertUsers, UpdateUsers, PatchRecord, ListOptions
)
from api_services.redis.auth_actions.token import parse_token_object_to_dict
user_route = APIRouter(prefix="/user", tags=["User"])
user_route.include_router(user_route, include_in_schema=True)
@user_route.post(path="/list", summary="List Active/Delete/Confirm Users")
def user_list(request: Request, list_options: ListOptions):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(list_options=list_options, token_dict=token_dict)
@user_route.post(path="/create", summary="Create User with given auth levels")
def user_create(request: Request, data: InsertUsers):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(data=data, token_dict=token_dict)
@user_route.post(
path="/update/{user_uu_id}", summary="Update User with given auth levels"
)
def user_update(request: Request, user_uu_id: str, data: UpdateUsers):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, user_uu_id=user_uu_id, token_dict=token_dict
)
@user_route.patch(path="/patch/{user_uu_id}", summary="Update Active/Delete/Confirm")
def user_patch(request: Request, user_uu_id: str, data: PatchRecord):
token_dict = parse_token_object_to_dict(request=request)
return token_dict.available_event(
data=data, user_uu_id=user_uu_id, token_dict=token_dict
)