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

database and services updated and tested

Browse Source
This commit is contained in:
berkay
2025-01-08 21:35:11 +03:00
parent 364a4df4b1
commit 08896e4c61
132 changed files with 13302 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

291
api_events/events/__init__.py Normal file
View File

@@ -0,0 +1,291 @@
from api_events.events.identity.people import (
PeopleListEventMethod,
PeopleCreateEventMethod,
PeopleUpdateEventMethod,
PeoplePatchEventMethod,
)
from api_events.events.address.address import (
AddressListEventMethod,
AddressCreateEventMethod,
AddressUpdateEventMethod,
AddressPatchEventMethod,
AddressSearchEventMethod,
AddressPostCodeCreateEventMethod,
AddressPostCodeUpdateEventMethod,
AddressPostCodeListEventMethod,
)
from api_events.events.application.authentication import (
AuthenticationLoginEventMethod,
AuthenticationSelectEventMethod,
AuthenticationCheckTokenEventMethod,
AuthenticationRefreshEventMethod,
AuthenticationChangePasswordEventMethod,
AuthenticationCreatePasswordEventMethod,
AuthenticationResetPasswordEventMethod,
AuthenticationDisconnectUserEventMethod,
AuthenticationLogoutEventMethod,
AuthenticationRefreshTokenEventMethod,
AuthenticationForgotPasswordEventMethod,
AuthenticationDownloadAvatarEventMethod,
)
from api_events.events.account.account_records import (
AccountRecordsListEventMethod,
AccountRecordsCreateEventMethod,
AccountRecordsUpdateEventMethod,
AccountRecordsPatchEventMethod,
)
from api_events.events.identity.users import (
UserListEventMethod,
UserCreateEventMethod,
UserUpdateEventMethod,
UserPatchEventMethod,
)
from api_events.events.building.building_build import (
BuildListEventMethod,
BuildCreateEventMethod,
BuildUpdateEventMethod,
BuildPatchEventMethod,
)
from api_events.events.building.building_build_parts import (
BuildingBuildPartsListEventMethod,
BuildingBuildPartsCreateEventMethod,
BuildingBuildPartsUpdateEventMethod,
BuildingBuildPartsPatchEventMethod,
)
from api_events.events.building.building_build_area import (
BuildAreaListEventMethod,
BuildAreaCreateEventMethod,
BuildAreaUpdateEventMethod,
BuildAreaPatchEventMethod,
)
from api_events.events.building.building_build_sites import (
BuildSitesListEventMethod,
BuildSitesCreateEventMethod,
BuildSitesUpdateEventMethod,
)
from api_events.events.building.building_build_types import (
BuildTypesListEventMethod,
)
from api_events.events.company.company_company import (
CompanyListEventMethod,
CompanyCreateEventMethod,
CompanyUpdateEventMethod,
CompanyPatchEventMethod,
)
from api_events.events.company.company_department import (
DepartmentListEventMethod,
DepartmentCreateEventMethod,
DepartmentUpdateEventMethod,
DepartmentPatchEventMethod,
)
from api_events.events.company.company_duties import (
DutiesListEventMethod,
DutiesGetByUUIDEventMethod,
DutiesCreateEventMethod,
DutiesUpdateEventMethod,
DutiesPatchEventMethod,
)
from api_events.events.company.company_duty import (
DutyListEventMethod,
DutyCreateEventMethod,
DutyUpdateEventMethod,
DutyPatchEventMethod,
)
from api_events.events.company.company_employee import (
EmployeeListEventMethod,
EmployeeCreateEventMethod,
EmployeeUpdateEventMethod,
EmployeePatchEventMethod,
Employee2PeopleEmployEventMethod,
Employee2PeopleFireEventMethod,
)
from api_events.events.company.company_staff import (
StaffListEventMethod,
StaffCreateEventMethod,
StaffGetByUUIDEventMethod,
StaffUpdateEventMethod,
StaffPatchEventMethod,
)
from api_events.events.building.building_living_spaces import (
BuildingLivingSpacesListEventMethod,
BuildingLivingSpacesCreateEventMethod,
BuildingLivingSpacesUpdateEventMethod,
)
from api_events.events.decision_book.decision_book_decision_book import (
DecisionBookListEventMethod,
DecisionBookCreateEventMethod,
DecisionBookUpdateEventMethod,
DecisionBookPatchEventMethod,
DecisionBookApprovalEventMethod,
)
from api_events.events.decision_book.decision_book_decision_book_items import (
DecisionBookDecisionBookItemsListEventMethod,
DecisionBookDecisionBookItemsCreateEventMethod,
DecisionBookDecisionBookItemsUpdateEventMethod,
DecisionBookDecisionBookItemsPatchEventMethod,
)
from api_events.events.decision_book.project_decision_book import (
ProjectDecisionBookListEventMethod,
ProjectDecisionBookCreateEventMethod,
ProjectDecisionBookUpdateEventMethod,
ProjectDecisionBookApprovalEventMethod,
ProjectDecisionBookPatchEventMethod,
)
from api_events.events.decision_book.project_decision_book_person import (
ProjectDecisionBookPersonListEventMethod,
ProjectDecisionBookPersonCreateEventMethod,
ProjectDecisionBookPersonUpdateEventMethod,
ProjectDecisionBookPersonPatchEventMethod,
)
from api_events.events.decision_book.project_decision_book_items import (
BuildDecisionBookProjectItemsPatchEventMethod,
BuildDecisionBookProjectItemsUpdateEventMethod,
BuildDecisionBookProjectItemsCreateEventMethod,
BuildDecisionBookProjectItemsListEventMethod,
)
# from api_events.events.events.events_ import (
# EventBindOccupantEventMethod,
# EventBindEmployeeEventMethod,
# )
from api_events.events.events.events_bind_services import (
ServiceBindOccupantEventMethod,
ServiceBindEmployeeEventMethod,
)
from api_events.events.decision_book.decision_book_decision_book_person import (
DecisionBookPersonListEventMethod,
DecisionBookPersonAddEventMethod,
DecisionBookPersonRemoveEventMethod,
DecisionBookPersonAttendEventMethod,
DecisionBookPersonAssignOccupantEventMethod,
)
from api_events.events.decision_book.decision_book_invitations import (
BuildDecisionBookInvitationsListEventMethod,
BuildDecisionBookInvitationsCreateEventMethod,
BuildDecisionBookInvitationsUpdateEventMethod,
)
from api_events.events.events.events_events import (
EventsBindEventToEmployeeMethod,
EventsBindEventToOccupantMethod,
EventsListEventMethod,
)
__all__ = [
"AddressListEventMethod",
"AddressCreateEventMethod",
"AddressUpdateEventMethod",
"AddressPatchEventMethod",
"AddressSearchEventMethod",
"AddressPostCodeCreateEventMethod",
"AddressPostCodeUpdateEventMethod",
"AddressPostCodeListEventMethod",
"PeopleListEventMethod",
"PeopleUpdateEventMethod",
"PeoplePatchEventMethod",
"PeopleCreateEventMethod",
"AuthenticationLoginEventMethod",
"AuthenticationSelectEventMethod",
"AuthenticationCheckTokenEventMethod",
"AuthenticationRefreshEventMethod",
"AuthenticationChangePasswordEventMethod",
"AuthenticationCreatePasswordEventMethod",
"AuthenticationResetPasswordEventMethod",
"AuthenticationDisconnectUserEventMethod",
"AuthenticationLogoutEventMethod",
"AuthenticationRefreshTokenEventMethod",
"AuthenticationForgotPasswordEventMethod",
"AuthenticationDownloadAvatarEventMethod",
"AccountRecordsListEventMethod",
"AccountRecordsCreateEventMethod",
"AccountRecordsUpdateEventMethod",
"AccountRecordsPatchEventMethod",
"UserListEventMethod",
"UserCreateEventMethod",
"UserUpdateEventMethod",
"UserPatchEventMethod",
"BuildListEventMethod",
"BuildCreateEventMethod",
"BuildUpdateEventMethod",
"BuildPatchEventMethod",
"BuildingBuildPartsListEventMethod",
"BuildingBuildPartsCreateEventMethod",
"BuildingBuildPartsUpdateEventMethod",
"BuildingBuildPartsPatchEventMethod",
"BuildingLivingSpacesListEventMethod",
"BuildingLivingSpacesCreateEventMethod",
"BuildingLivingSpacesUpdateEventMethod",
"BuildAreaListEventMethod",
"BuildAreaCreateEventMethod",
"BuildAreaUpdateEventMethod",
"BuildAreaPatchEventMethod",
"BuildSitesListEventMethod",
"BuildSitesCreateEventMethod",
"BuildSitesUpdateEventMethod",
"BuildTypesListEventMethod",
"DecisionBookListEventMethod",
"DecisionBookCreateEventMethod",
"DecisionBookUpdateEventMethod",
"DecisionBookPatchEventMethod",
"DecisionBookApprovalEventMethod",
"DecisionBookPersonListEventMethod",
"DecisionBookPersonAddEventMethod",
"DecisionBookPersonRemoveEventMethod",
"DecisionBookDecisionBookItemsListEventMethod",
"DecisionBookDecisionBookItemsCreateEventMethod",
"DecisionBookDecisionBookItemsUpdateEventMethod",
"DecisionBookDecisionBookItemsPatchEventMethod",
"ProjectDecisionBookListEventMethod",
"ProjectDecisionBookCreateEventMethod",
"ProjectDecisionBookUpdateEventMethod",
"ProjectDecisionBookApprovalEventMethod",
"ProjectDecisionBookPatchEventMethod",
"ProjectDecisionBookPersonListEventMethod",
"ProjectDecisionBookPersonCreateEventMethod",
"ProjectDecisionBookPersonUpdateEventMethod",
"ProjectDecisionBookPersonPatchEventMethod",
"BuildDecisionBookProjectItemsPatchEventMethod",
"BuildDecisionBookProjectItemsUpdateEventMethod",
"BuildDecisionBookProjectItemsCreateEventMethod",
"BuildDecisionBookProjectItemsListEventMethod",
"CompanyPatchEventMethod",
"CompanyCreateEventMethod",
"CompanyUpdateEventMethod",
"CompanyListEventMethod",
"DepartmentListEventMethod",
"DepartmentCreateEventMethod",
"DepartmentUpdateEventMethod",
"DepartmentPatchEventMethod",
"DutiesListEventMethod",
"DutiesGetByUUIDEventMethod",
"DutiesCreateEventMethod",
"DutiesUpdateEventMethod",
"DutiesPatchEventMethod",
"DutyListEventMethod",
"DutyCreateEventMethod",
"DutyUpdateEventMethod",
"DutyPatchEventMethod",
"EmployeeListEventMethod",
"EmployeeCreateEventMethod",
"EmployeeUpdateEventMethod",
"EmployeePatchEventMethod",
"Employee2PeopleEmployEventMethod",
"Employee2PeopleFireEventMethod",
"StaffListEventMethod",
"StaffCreateEventMethod",
"StaffGetByUUIDEventMethod",
"StaffUpdateEventMethod",
"StaffPatchEventMethod",
# "EventBindOccupantEventMethod",
# "EventBindEmployeeEventMethod",
"ServiceBindOccupantEventMethod",
"ServiceBindEmployeeEventMethod",
"BuildDecisionBookInvitationsListEventMethod",
"BuildDecisionBookInvitationsCreateEventMethod",
"BuildDecisionBookInvitationsUpdateEventMethod",
"DecisionBookPersonAttendEventMethod",
"DecisionBookPersonAssignOccupantEventMethod",
"EventsBindEventToEmployeeMethod",
"EventsBindEventToOccupantMethod",
"EventsListEventMethod",
]

72
api_events/events/abstract_class.py Normal file
View File

@@ -0,0 +1,72 @@
import typing
from abc import ABC
from fastapi.exceptions import HTTPException
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class ActionsSchema(ABC):
def __init__(self, endpoint: str = None):
self.endpoint = endpoint
def retrieve_action_from_endpoint(self):
from databases import EndpointRestriction
endpoint_restriction = EndpointRestriction.filter_one(
EndpointRestriction.endpoint_name.ilike(f"%{self.endpoint}%"), system=True
).data
if not endpoint_restriction:
raise HTTPException(
status_code=404,
detail=f"Endpoint {self.endpoint} not found in the database",
)
return endpoint_restriction
class ActionsSchemaFactory:
def __init__(self, action: ActionsSchema):
self.action = action
try:
self.action_match = self.action.retrieve_action_from_endpoint()
except Exception as e:
err = e
print(f"ActionsSchemaFactory Error: {e}")
class MethodToEvent(ABC, ActionsSchemaFactory):
action_key: str = None
event_type: str = None
event_description: str = ""
event_category: str = ""
__event_keys__: dict = {}
__event_validation__: dict = {}
@classmethod
def call_event_method(cls, method_uu_id: str, *args, **kwargs):
function_name = cls.__event_keys__.get(method_uu_id)
return getattr(cls, function_name)(*args, **kwargs)
@classmethod
def ban_token_objects(
cls,
token: typing.Union[EmployeeTokenObject, OccupantTokenObject],
ban_list: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
from fastapi import status
from fastapi.exceptions import HTTPException
if token.user_type == ban_list.user_type:
if isinstance(token, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="No employee can reach this event. An notification is send to admin about event registration",
)
if isinstance(token, OccupantTokenObject):
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="No occupant can reach this event. An notification is send to admin about event registration",
)

0
api_events/events/account/__init__.py Normal file
View File

347
api_events/events/account/account_records.py Normal file
View File

@@ -0,0 +1,347 @@
import typing
from api_library.date_time_actions.date_functions import system_arrow
from api_validations.validations_request import (
InsertAccountRecord,
UpdateAccountRecord,
ListOptions,
)
from api_validations.core_response import AlchemyJsonResponse
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.validations_response.account import AccountListResponse
from databases import (
AccountRecords,
BuildIbans,
)
from databases.sql_models.building.build import Build, BuildLivingSpace
from databases.sql_models.building.decision_book import BuildDecisionBookPayments
from databases.sql_models.others.enums import ApiEnumDropdown
class AccountRecordsListEventMethods(MethodToEvent):
event_type = "SELECT"
event_description = ""
event_category = ""
__event_keys__ = {
"7192c2aa-5352-4e36-98b3-dafb7d036a3d": "account_records_list",
"208e6273-17ef-44f0-814a-8098f816b63a": "account_records_list_flt_res",
}
__event_validation__ = {
"7192c2aa-5352-4e36-98b3-dafb7d036a3d": AccountListResponse,
"208e6273-17ef-44f0-814a-8098f816b63a": AccountListResponse,
}
@classmethod
def account_records_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
AccountRecords.pre_query = AccountRecords.filter_all(
AccountRecords.company_id
== token_dict.selected_occupant.responsible_company_id,
)
elif isinstance(token_dict, EmployeeTokenObject):
AccountRecords.pre_query = AccountRecords.filter_all(
AccountRecords.company_id == token_dict.selected_company.company_id,
)
AccountRecords.filter_attr = list_options
records = AccountRecords.filter_all()
return AlchemyJsonResponse(
completed=True, message="List Build record", result=records
)
@classmethod
def account_records_list_flt_res(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if not isinstance(token_dict, OccupantTokenObject):
raise AccountRecords().raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message="Only Occupant can see this data",
data={},
)
return_list = []
living_space: BuildLivingSpace = BuildLivingSpace.filter_by_one(
id=token_dict.selected_occupant.living_space_id
).data
if not living_space:
raise AccountRecords().raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message="Living space not found",
data={},
)
if not list_options:
list_options = ListOptions()
main_filters = [
AccountRecords.living_space_id
== token_dict.selected_occupant.living_space_id,
BuildDecisionBookPayments.process_date
>= str(system_arrow.now().shift(months=-3).date()),
BuildDecisionBookPayments.process_date
< str(system_arrow.find_last_day_of_month(living_space.expiry_ends)),
BuildDecisionBookPayments.process_date
>= str(system_arrow.get(living_space.expiry_starts)),
BuildDecisionBookPayments.is_confirmed == True,
AccountRecords.active == True,
]
order_type = "desc"
if list_options.order_type:
order_type = "asc" if list_options.order_type[0] == "a" else "desc"
order_by_list = BuildDecisionBookPayments.process_date.desc()
if list_options.order_field:
if list_options.order_field == "process_date":
order_by_list = (
BuildDecisionBookPayments.process_date.asc()
if order_type == "asc"
else BuildDecisionBookPayments.process_date.desc()
)
if list_options.order_field == "bank_date":
order_by_list = (
AccountRecords.bank_date.desc()
if order_type == "asc"
else AccountRecords.bank_date.asc()
)
if list_options.order_field == "currency_value":
order_by_list = (
AccountRecords.currency_value.desc()
if order_type == "asc"
else AccountRecords.currency_value.asc()
)
if list_options.order_field == "process_comment":
order_by_list = (
AccountRecords.process_comment.desc()
if order_type == "asc"
else AccountRecords.process_comment.asc()
)
if list_options.order_field == "payment_amount":
order_by_list = (
BuildDecisionBookPayments.payment_amount.desc()
if order_type == "asc"
else BuildDecisionBookPayments.payment_amount.asc()
)
if list_options.query:
for key, value in list_options.query.items():
if key == "process_date":
main_filters.append(BuildDecisionBookPayments.process_date == value)
if key == "bank_date":
main_filters.append(AccountRecords.bank_date == value)
if key == "currency":
main_filters.append(BuildDecisionBookPayments.currency == value)
if key == "currency_value":
main_filters.append(AccountRecords.currency_value == value)
if key == "process_comment":
main_filters.append(AccountRecords.process_comment == value)
if key == "payment_amount":
main_filters.append(
BuildDecisionBookPayments.payment_amount == value
)
query = (
AccountRecords.session.query(
BuildDecisionBookPayments.process_date,
BuildDecisionBookPayments.payment_amount,
BuildDecisionBookPayments.currency,
AccountRecords.bank_date,
AccountRecords.currency_value,
AccountRecords.process_comment,
BuildDecisionBookPayments.uu_id,
)
.join(
AccountRecords,
AccountRecords.id == BuildDecisionBookPayments.account_records_id,
)
.filter(*main_filters)
).order_by(order_by_list)
query.limit(list_options.size or 5).offset(
(list_options.page or 1 - 1) * list_options.size or 5
)
for list_of_values in query.all() or []:
return_list.append(
{
"process_date": list_of_values[0],
"payment_amount": list_of_values[1],
"currency": list_of_values[2],
"bank_date": list_of_values[3],
"currency_value": list_of_values[4],
"process_comment": list_of_values[5],
}
)
return dict(completed=True, message="List Build record", result=return_list)
class AccountRecordsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
event_description = ""
event_category = ""
__event_keys__ = {
"31f4f32f-0cd4-4995-8a6a-f9f56335848a": "account_records_create",
}
__event_validation__ = {
"31f4f32f-0cd4-4995-8a6a-f9f56335848a": InsertAccountRecord,
}
@classmethod
def account_records_create(
cls,
data: InsertAccountRecord,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
data_dict = data.excluded_dump()
if isinstance(token_dict, OccupantTokenObject):
build_iban = BuildIbans.filter_one(
BuildIbans.iban == data.iban,
BuildIbans.build_id == token_dict.selected_occupant.build_id,
).data
if not build_iban:
BuildIbans.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message=f"{data.iban} is not found in company related to your organization",
data={
"iban": data.iban,
},
)
account_record = AccountRecords.find_or_create(**data.excluded_dump())
return AlchemyJsonResponse(
completed=True,
message="Update Build record",
result=account_record.get_dict(),
)
elif isinstance(token_dict, EmployeeTokenObject):
# Build.pre_query = Build.select_action(
# employee_id=token_dict.selected_employee.employee_id,
# )
# build_ids_list = Build.filter_all(
# )
# build_iban = BuildIbans.filter_one(
# BuildIbans.iban == data.iban,
# BuildIbans.build_id.in_([build.id for build in build_ids_list.data]),
# ).data
# if not build_iban:
# BuildIbans.raise_http_exception(
# status_code="HTTP_404_NOT_FOUND",
# error_case="UNAUTHORIZED",
# message=f"{data.iban} is not found in company related to your organization",
# data={
# "iban": data.iban,
# },
# )
bank_date = system_arrow.get(data.bank_date)
data_dict["bank_date_w"] = bank_date.weekday()
data_dict["bank_date_m"] = bank_date.month
data_dict["bank_date_d"] = bank_date.day
data_dict["bank_date_y"] = bank_date.year
if int(data.currency_value) < 0:
debit_type = ApiEnumDropdown.filter_by_one(
system=True, enum_class="DebitTypes", key="DT-D"
).data
data_dict["receive_debit"] = debit_type.id
data_dict["receive_debit_uu_id"] = str(debit_type.uu_id)
else:
debit_type = ApiEnumDropdown.filter_by_one(
system=True, enum_class="DebitTypes", key="DT-R"
).data
data_dict["receive_debit"] = debit_type.id
data_dict["receive_debit_uu_id"] = str(debit_type.uu_id)
account_record = AccountRecords.find_or_create(**data_dict)
account_record.save()
account_record.update(is_confirmed=True)
account_record.save()
return AlchemyJsonResponse(
completed=True,
message="Create Account record are successful",
result=account_record.get_dict(),
)
class AccountRecordsUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
event_description = ""
event_category = ""
__event_keys__ = {
"ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": "account_records_update",
}
__event_validation__ = {
"ec98ef2c-bcd0-432d-a8f4-1822a56c33b2": UpdateAccountRecord,
}
@classmethod
def build_area_update(
cls,
build_uu_id: str,
data: UpdateAccountRecord,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
pass
elif isinstance(token_dict, EmployeeTokenObject):
pass
return AlchemyJsonResponse(
completed=False,
message="Update Build record",
result=None,
)
class AccountRecordsPatchEventMethods(MethodToEvent):
event_type = "PATCH"
event_description = ""
event_category = ""
__event_keys__ = {
"34c38937-42a2-45f1-b2ef-a23978650aee": "account_records_patch",
}
__event_validation__ = {
"34c38937-42a2-45f1-b2ef-a23978650aee": None,
}
@classmethod
def build_area_patch(
cls,
build_uu_id: str,
data,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return AlchemyJsonResponse(
completed=False,
message="Patch Build record",
result=None,
)
AccountRecordsListEventMethod = AccountRecordsListEventMethods(
action=ActionsSchema(endpoint="/account/records/list")
)
AccountRecordsCreateEventMethod = AccountRecordsCreateEventMethods(
action=ActionsSchema(endpoint="/account/records/create")
)
AccountRecordsUpdateEventMethod = AccountRecordsUpdateEventMethods(
action=ActionsSchema(endpoint="/account/records/update")
)
AccountRecordsPatchEventMethod = AccountRecordsPatchEventMethods(
action=ActionsSchema(endpoint="/account/records/patch")
)

0
api_events/events/address/__init__.py Normal file
View File

499
api_events/events/address/address.py Normal file
View File

@@ -0,0 +1,499 @@
from typing import Union
from fastapi.exceptions import HTTPException
from fastapi.responses import JSONResponse
from api_validations.validations_response.address import (
ListAddressResponse,
AddressPostCodeResponse,
)
from databases import (
AddressPostcode,
Addresses,
RelationshipEmployee2PostCode,
AddressStreet,
)
from api_validations.validations_request import (
ListOptions,
InsertAddress,
UpdateAddress,
InsertPostCode,
UpdatePostCode,
SearchAddress,
)
from api_validations.core_response import AlchemyJsonResponse
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class AddressListEventMethods(MethodToEvent):
event_type = "SELECT"
event_description = "List Address records"
event_category = "Address"
__event_keys__ = {
"9c251d7d-da70-4d63-a72c-e69c26270442": "address_list_super_user",
"52afe375-dd95-4f4b-aaa2-4ec61bc6de52": "address_list_employee",
}
__event_validation__ = {
"9c251d7d-da70-4d63-a72c-e69c26270442": ListAddressResponse,
"52afe375-dd95-4f4b-aaa2-4ec61bc6de52": ListAddressResponse,
}
@classmethod
def address_list_super_user(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
post_code_list = RelationshipEmployee2PostCode.filter_all(
RelationshipEmployee2PostCode.company_id
== token_dict.selected_company.company_id,
).data
post_code_id_list = [post_code.member_id for post_code in post_code_list]
if not post_code_id_list:
raise HTTPException(
status_code=404,
detail="User has no post code registered. User can not list addresses.",
)
get_street_ids = [
street_id[0]
for street_id in AddressPostcode.select_only(
AddressPostcode.id.in_(post_code_id_list),
select_args=[AddressPostcode.street_id],
order_by=AddressPostcode.street_id.desc(),
).data
]
if not get_street_ids:
raise HTTPException(
status_code=404,
detail="User has no street registered. User can not list addresses.",
)
Addresses.pre_query = Addresses.filter_all(
Addresses.street_id.in_(get_street_ids),
).query
Addresses.filter_attr = list_options
records = Addresses.filter_all().data
return AlchemyJsonResponse(
completed=True,
message="List Address records",
result=records,
)
@classmethod
def address_list_employee(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
Addresses.filter_attr = list_options
records = Addresses.list_via_employee(
token_dict=token_dict,
)
return AlchemyJsonResponse(
completed=True,
message="List Address records",
result=records,
)
class AddressCreateEventMethods(MethodToEvent):
event_type = "CREATE"
event_description = ""
event_category = ""
__event_keys__ = {
"ffdc445f-da10-4ce4-9531-d2bdb9a198ae": "create_address",
}
__event_validation__ = {
"ffdc445f-da10-4ce4-9531-d2bdb9a198ae": InsertAddress,
}
@classmethod
def create_address(
cls,
data: InsertAddress,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
post_code = AddressPostcode.filter_one(
AddressPostcode.uu_id == data.post_code_uu_id,
).data
if not post_code:
raise HTTPException(
status_code=404,
detail="Post code not found. User can not create address without post code.",
)
data_dict = data.excluded_dump()
data_dict["street_id"] = post_code.street_id
data_dict["street_uu_id"] = str(post_code.street_uu_id)
del data_dict["post_code_uu_id"]
address = Addresses.find_or_create(**data_dict)
address.save()
address.update(is_confirmed=True)
address.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Address record",
"data": address.get_dict(),
},
status_code=200,
)
class AddressSearchEventMethods(MethodToEvent):
event_type = "SEARCH"
event_description = ""
event_category = ""
__event_keys__ = {
"e0ac1269-e9a7-4806-9962-219ac224b0d0": "search_address",
}
__event_validation__ = {
"e0ac1269-e9a7-4806-9962-219ac224b0d0": SearchAddress,
}
@classmethod
def search_address(
cls,
data: SearchAddress,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
import databases.sql_models
from time import perf_counter
st = perf_counter()
pre_query_first = AddressStreet.search_address_text(search_text=data.search)
query, schemas, new_data_list = (
pre_query_first.get("query"),
pre_query_first.get("schema"),
[],
)
filter_list = data.list_options.dump()
filter_table = AddressStreet
if filter_list.get("order_field") not in schemas:
filter_list["order_field"] = "uu_id"
else:
filter_table = getattr(
databases.sql_models, str(filter_list.get("order_field")).split(".")[0]
)
filter_list["order_field"] = str(filter_list.get("order_field")).split(".")[
1
]
order = (
getattr(filter_table, filter_list.get("order_field")).desc()
if str(filter_list.get("order_type"))[0] == "d"
else getattr(filter_table, filter_list.get("order_field")).asc()
)
query = (
query.order_by(order)
.limit(int(filter_list.get("size")))
.offset(int((filter_list.get("page")) - 1) * int(filter_list.get("size")))
.populate_existing()
)
records = list(query.all())
print(perf_counter() - st)
for item in records:
new_data_dict = {}
for index, schema in enumerate(schemas):
new_data_dict[schema] = str(item[index])
if "uu_id" in str(item[index]):
new_data_dict[schema] = str(new_data_dict.get(schema))
new_data_list.append(new_data_dict)
return JSONResponse(
content={
"completed": True,
"pagination": filter_list,
"count": len(new_data_list),
"data": new_data_list,
"message": "Search Address records",
},
status_code=200,
)
class AddressUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
event_description = ""
event_category = ""
__event_keys__ = {
"1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": "update_address",
}
__event_validation__ = {
"1f9c3a9c-e5bd-4dcd-9b9a-3742d7e03a27": UpdateAddress,
}
@classmethod
def update_address(
cls,
address_uu_id: str,
data: UpdateAddress,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
address = Addresses.filter_one(
Addresses.uu_id == address_uu_id,
).data
if not address:
raise HTTPException(
status_code=404,
detail=f"Address not found. User can not update with given address uuid : {address_uu_id}",
)
data_dict = data.excluded_dump()
updated_address = address.update(**data_dict)
updated_address.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Address record",
"data": updated_address.get_dict(),
},
status_code=200,
)
elif isinstance(token_dict, OccupantTokenObject):
raise HTTPException(
status_code=403,
detail="Occupant can not update address.",
)
class AddressPatchEventMethods(MethodToEvent):
event_type = "PATCH"
event_description = ""
event_category = ""
__event_keys__ = {
"b0e55a7e-af81-468c-b46c-a6b3a6b68d5d": "patch_address",
}
__event_validation__ = {
"b0e55a7e-af81-468c-b46c-a6b3a6b68d5d": None,
}
@classmethod
def patch_address(
cls,
address_uu_id: str,
data: InsertAddress,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
address = Addresses.filter_one(
Addresses.uu_id == address_uu_id,
).data
post_code = RelationshipEmployee2PostCode.filter_one(
RelationshipEmployee2PostCode.member_id == address.post_code_id,
)
if not post_code:
raise HTTPException(
status_code=404,
detail="Post code not found. User can not patch address without post code.",
)
data_dict = data.excluded_dump()
data_dict["post_code_id"] = post_code.id
del data_dict["post_code_uu_id"]
patched_address = address.patch(**data_dict)
return JSONResponse(
content={
"completed": True,
"message": "Patch Address record",
"data": patched_address.get_dict(),
},
status_code=200,
)
class AddressPostCodeCreateEventMethods(MethodToEvent):
event_type = "CREATE"
event_description = ""
event_category = ""
__event_keys__ = {
"6f1406ac-577d-4f2c-8077-71fff2252c5f": "create_post_code_address",
}
__event_validation__ = {
"6f1406ac-577d-4f2c-8077-71fff2252c5f": InsertPostCode,
}
@classmethod
def create_post_code_address(
cls,
data: InsertPostCode,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
data_dump = data.excluded_dump()
street = AddressStreet.filter_one(
AddressStreet.uu_id == data.street_uu_id,
).data
if not street:
raise HTTPException(
status_code=404,
detail="Street not found. User can not create post code without street.",
)
data_dump["street_id"] = street.id
data_dump["postcode"] = data.post_code
del data_dump["post_code"]
post_code = AddressPostcode.find_or_create(**data_dump)
relation_table = AddressPostcode.__many__table__.find_or_create(
member_id=post_code.id,
employee_id=token_dict.selected_company.employee_id,
company_id=token_dict.selected_company.company_id,
)
post_code.save()
post_code.update(is_confirmed=True)
post_code.save()
relation_table.update(is_confirmed=True)
relation_table.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Post Code record",
"data": post_code.get_dict(),
},
status_code=200,
)
class AddressPostCodeUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
event_description = ""
event_category = ""
__event_keys__ = {
"df18e489-a63c-477f-984c-aa52d30640ad": "update_post_code_address",
}
__event_validation__ = {
"df18e489-a63c-477f-984c-aa52d30640ad": UpdatePostCode,
}
@classmethod
def update_post_code_address(
cls,
post_code_uu_id: str,
data: UpdatePostCode,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
AddressPostcode.pre_query = AddressPostcode.select_action(
employee_id=token_dict.selected_company.employee_id,
)
post_code = AddressPostcode.filter_one(
AddressPostcode.uu_id == post_code_uu_id,
).data
if not post_code:
raise HTTPException(
status_code=404,
detail="Street not found. User can not update post code without street.",
)
data_dict = data.excluded_dump()
updated_post_code = post_code.update(**data_dict)
updated_post_code.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Post Code record",
"data": updated_post_code.get_dict(),
},
status_code=200,
)
elif isinstance(token_dict, OccupantTokenObject):
raise HTTPException(
status_code=403,
detail="Occupant can not update post code.",
)
return JSONResponse(
content={
"completed": True,
"message": "Update Post Code record",
"data": {},
},
status_code=404,
)
class AddressPostCodeListEventMethods(MethodToEvent):
event_type = "SELECT"
event_description = ""
event_category = ""
__event_keys__ = {
"88d37b78-1ac4-4513-9d25-090ac3a24f31": "list_post_code_address",
}
__event_validation__ = {
"88d37b78-1ac4-4513-9d25-090ac3a24f31": AddressPostCodeResponse,
}
@classmethod
def list_post_code_address(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
post_code_list = AddressPostcode.__many__table__.filter_all(
AddressPostcode.__many__table__.company_id
== token_dict.selected_company.company_id,
).data
if not post_code_list:
raise HTTPException(
status_code=404,
detail="User has no post code registered or not yet any post code created.",
)
AddressPostcode.pre_query = AddressPostcode.filter_all(
AddressPostcode.id.in_(
[post_code.member_id for post_code in post_code_list]
),
).query
AddressPostcode.filter_attr = list_options
records = AddressPostcode.filter_all().data
return AlchemyJsonResponse(
completed=True,
message="List Address records",
result=records,
)
AddressListEventMethod = AddressListEventMethods(
action=ActionsSchema(endpoint="/address/list")
)
AddressCreateEventMethod = AddressCreateEventMethods(
action=ActionsSchema(endpoint="/address/create")
)
AddressUpdateEventMethod = AddressUpdateEventMethods(
action=ActionsSchema(endpoint="/address/update")
)
AddressPatchEventMethod = AddressPatchEventMethods(
action=ActionsSchema(endpoint="/address/patch")
)
AddressPostCodeCreateEventMethod = AddressPostCodeCreateEventMethods(
action=ActionsSchema(endpoint="/postcode/create")
)
AddressPostCodeUpdateEventMethod = AddressPostCodeUpdateEventMethods(
action=ActionsSchema(endpoint="/postcode/update")
)
AddressPostCodeListEventMethod = AddressPostCodeListEventMethods(
action=ActionsSchema(endpoint="/postcode/list")
)
AddressSearchEventMethod = AddressSearchEventMethods(
action=ActionsSchema(endpoint="/address/search")
)

0
api_events/events/application/__init__.py Normal file
View File

5
api_events/events/application/api.py Normal file
View File

@@ -0,0 +1,5 @@
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class DecisionBookEvents(MethodToEvent): ...

5
api_events/events/application/application.py Normal file
View File

@@ -0,0 +1,5 @@
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class ApplicationEvents(MethodToEvent): ...

844
api_events/events/application/authentication.py Normal file
View File

@@ -0,0 +1,844 @@
import datetime
import json
import typing
from typing import Union
import arrow
from fastapi import status
from fastapi.requests import Request
from fastapi.exceptions import HTTPException
from fastapi.responses import JSONResponse
from databases import (
Companies,
Staff,
Duties,
Departments,
Employees,
BuildLivingSpace,
BuildParts,
Build,
Duty,
Event2Occupant,
Event2Employee,
Users,
UsersTokens,
OccupantTypes,
RelationshipEmployee2Build,
)
from api_services import (
redis_cli,
send_email,
get_object_via_access_key,
get_object_via_user_uu_id,
save_access_token_to_redis,
update_selected_to_redis,
password_is_changed_template,
change_your_password_template,
)
from api_configs import ApiStatic, Auth
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects import (
OccupantToken,
CompanyToken,
EmployeeTokenObject,
OccupantTokenObject,
)
from api_library.date_time_actions.date_functions import system_arrow
from databases.no_sql_models.login_handlers import load_user_with_erp_details
from api_validations.validations_request import (
Login,
Logout,
ChangePassword,
Remember,
Forgot,
CreatePassword,
OccupantSelection,
EmployeeSelection,
)
class AuthenticationLoginEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Login via domain and access key : [email] | [phone]"
event_category = "AUTHENTICATION"
__event_keys__ = {
"e672846d-cc45-4d97-85d5-6f96747fac67": "authentication_login_with_domain_and_creds",
}
__event_validation__ = {
"e672846d-cc45-4d97-85d5-6f96747fac67": "authentication_login_with_domain_and_creds",
}
@classmethod
def authentication_login_with_domain_and_creds(
cls,
data: Login,
request,
):
access_dict = Users.login_user_with_credentials(data=data, request=request)
found_user = access_dict.get("user", None)
if not found_user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials"
)
return JSONResponse(
content={
"completed": True,
"message": "User is logged in successfully",
"access_token": access_dict.get("access_token"),
"refresh_token": access_dict.get("refresher_token"),
"access_object": access_dict.get("access_object"),
"user": found_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class AuthenticationSelectEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Select Employee Duty or Occupant Type"
event_category = "AUTHENTICATION"
__event_keys__ = {
"cee96b9b-8487-4e9f-aaed-2e8c79687bf9": "authentication_select_company_or_occupant_type",
}
__event_validation__ = {
"cee96b9b-8487-4e9f-aaed-2e8c79687bf9": "authentication_select_company_or_occupant_type",
}
@classmethod
def authentication_select_company_or_occupant_type(
cls,
request: Request,
data: Union[EmployeeSelection, OccupantSelection],
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
from api_objects import OccupantToken, CompanyToken
if isinstance(token_dict, EmployeeTokenObject):
if data.company_uu_id not in token_dict.companies_uu_id_list:
return JSONResponse(
content={
"completed": False,
"message": "Company is not found in users company list",
},
status_code=status.HTTP_401_UNAUTHORIZED,
)
if selected_company := Companies.filter_one(
Companies.uu_id == data.company_uu_id,
).data:
department_ids = [
department.id
for department in Departments.filter_all(
Departments.company_id == selected_company.id,
).data
]
duties_ids = [
duties.id
for duties in Duties.filter_all(
Duties.company_id == selected_company.id,
).data
]
staff_ids = [
staff.id
for staff in Staff.filter_all(
Staff.duties_id.in_(duties_ids),
).data
]
employee = Employees.filter_one(
Employees.people_id == token_dict.person_id,
Employees.staff_id.in_(staff_ids),
).data
reachable_event_list_id = Event2Employee.get_event_id_by_employee_id(
employee_id=employee.id
)
staff = Staff.filter_one(
Staff.id == employee.staff_id,
).data
duties = Duties.filter_one(
Duties.id == staff.duties_id,
).data
department = Departments.filter_one(
Departments.id == duties.department_id,
).data
bulk_id = Duty.filter_by_one(system=True, duty_code="BULK").data
bulk_duty_id = Duties.filter_by_one(
company_id=selected_company.id,
duties_id=bulk_id.id,
**Duties.valid_record_dict,
).data
update_selected_to_redis(
request=request,
add_payload=CompanyToken(
company_uu_id=selected_company.uu_id.__str__(),
company_id=selected_company.id,
department_id=department.id,
department_uu_id=department.uu_id.__str__(),
duty_id=duties.id,
duty_uu_id=duties.uu_id.__str__(),
bulk_duties_id=bulk_duty_id.id,
staff_id=staff.id,
staff_uu_id=staff.uu_id.__str__(),
employee_id=employee.id,
employee_uu_id=employee.uu_id.__str__(),
reachable_event_list_id=reachable_event_list_id,
),
)
return JSONResponse(
content={
"completed": True,
"message": "Company is selected successfully",
},
status_code=status.HTTP_200_OK,
)
elif isinstance(token_dict, OccupantTokenObject):
occupant_type = OccupantTypes.filter_by_one(
system=True, uu_id=data.occupant_uu_id
).data
if not occupant_type:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Occupant Type is not found",
)
build_part = BuildParts.filter_by_one(
system=True, uu_id=data.build_part_uu_id
).data
if not build_part:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Build Part is not found",
)
build = Build.filter_one(
Build.id == build_part.build_id,
).data
related_company = RelationshipEmployee2Build.filter_one(
RelationshipEmployee2Build.member_id == build.id,
).data
company_related = Companies.filter_one(
Companies.id == related_company.company_id,
).data
responsible_employee = Employees.filter_one(
Employees.id == related_company.employee_id,
).data
if selected_occupant_type := BuildLivingSpace.filter_one(
BuildLivingSpace.occupant_type == occupant_type.id,
BuildLivingSpace.person_id == token_dict.person_id,
BuildLivingSpace.build_parts_id == build_part.id,
).data:
reachable_event_list_id = (
Event2Occupant.get_event_id_by_build_living_space_id(
build_living_space_id=selected_occupant_type.id
)
)
update_selected_to_redis(
request=request,
add_payload=OccupantToken(
living_space_id=selected_occupant_type.id,
living_space_uu_id=selected_occupant_type.uu_id.__str__(),
occupant_type_id=occupant_type.id,
occupant_type_uu_id=occupant_type.uu_id.__str__(),
occupant_type=occupant_type.occupant_type,
build_id=build.id,
build_uuid=build.uu_id.__str__(),
build_part_id=build_part.id,
build_part_uuid=build_part.uu_id.__str__(),
responsible_employee_id=responsible_employee.id,
responsible_employee_uuid=responsible_employee.uu_id.__str__(),
responsible_company_id=company_related.id,
responsible_company_uuid=company_related.uu_id.__str__(),
reachable_event_list_id=reachable_event_list_id,
),
)
return JSONResponse(
content={
"completed": True,
"message": "Occupant is selected successfully",
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data provided"},
status_code=status.HTTP_418_IM_A_TEAPOT,
)
class AuthenticationCheckTokenEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Check Token is valid for user"
event_category = "AUTHENTICATION"
__event_keys__ = {
"73d77e45-a33f-4f12-909e-3b56f00d8a12": "authentication_check_token_is_valid",
}
__event_validation__ = {
"73d77e45-a33f-4f12-909e-3b56f00d8a12": "authentication_check_token_is_valid",
}
@classmethod
def authentication_check_token_is_valid(
cls,
request,
):
if get_object_via_access_key(request=request):
return JSONResponse(
content={"completed": True, "message": "Access Token is valid"},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Access Token is NOT valid"},
status_code=status.HTTP_401_UNAUTHORIZED,
)
class AuthenticationRefreshEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = (
"Refresher Token for refreshing access token without credentials"
)
event_category = "AUTHENTICATION"
__event_keys__ = {
"48379bb2-ba81-4d8e-a9dd-58837cfcbf67": "authentication_refresh_user_info",
}
__event_validation__ = {
"48379bb2-ba81-4d8e-a9dd-58837cfcbf67": "authentication_refresh_user_info",
}
@classmethod
def authentication_refresh_user_info(
cls,
request,
token_dict: typing.Union[EmployeeSelection, OccupantSelection],
):
access_token = str(request.headers.get(Auth.ACCESS_TOKEN_TAG))
if token_user := get_object_via_access_key(request=request):
if found_user := Users.filter_one(
Users.uu_id == token_user.get("uu_id")
).data:
user_token = UsersTokens.filter_one(
UsersTokens.domain == found_user.domain_name,
UsersTokens.user_id == found_user.id,
UsersTokens.token_type == "RememberMe",
).data
access_dict = {
"access_token": access_token,
"refresh_token": getattr(user_token, "token", None),
}
return JSONResponse(
content={
"completed": True,
"message": "User is logged in successfully via refresh token",
"data": load_user_with_erp_details(found_user, access_dict),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data", "data": {}},
status_code=status.HTTP_401_UNAUTHORIZED,
)
class AuthenticationChangePasswordEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Change password with access token implemented on request headers without password reset token"
event_category = "AUTHENTICATION"
__event_keys__ = {
"f09f7c1a-bee6-4e32-8444-962ec8f39091": "authentication_change_password",
}
__event_validation__ = {
"f09f7c1a-bee6-4e32-8444-962ec8f39091": "authentication_change_password",
}
@classmethod
def authentication_change_password(
cls,
data: ChangePassword,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
if found_user := Users.filter_one(Users.uu_id == token_dict.uu_id).data:
if found_user.check_password(data.old_password):
found_user.set_password(data.new_password)
return JSONResponse(
content={
"completed": True,
"message": "Password is changed successfully",
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Old password is not correct",
},
status_code=status.HTTP_401_UNAUTHORIZED,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data"},
status_code=status.HTTP_401_UNAUTHORIZED,
)
class AuthenticationCreatePasswordEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Create password with password reset token requested via email"
event_category = "AUTHENTICATION"
__event_keys__ = {
"c519f9af-92e1-47b2-abf7-5a3316d075f7": "authentication_create_password",
}
__event_validation__ = {
"c519f9af-92e1-47b2-abf7-5a3316d075f7": "authentication_create_password",
}
@classmethod
def authentication_create_password(cls, data: CreatePassword):
if not data.re_password == data.password:
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE, detail="Password must match"
)
if found_user := Users.filter_one(
Users.password_token == data.password_token
).data:
found_user.create_password(found_user=found_user, password=data.password)
found_user.password_token = ""
found_user.save()
send_email_completed = send_email(
subject=f"Dear {found_user.user_tag}, your password has been changed.",
receivers=[str(found_user.email)],
html=password_is_changed_template(user_name=found_user.user_tag),
)
if not send_email_completed:
raise HTTPException(
status_code=400, detail="Email can not be sent. Try again later"
)
return JSONResponse(
content={
"completed": True,
"message": "Password is created successfully",
"data": found_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Record not found",
"data": {},
},
status_code=status.HTTP_202_ACCEPTED,
)
class AuthenticationDisconnectUserEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Disconnect all sessions of user in access token"
event_category = "AUTHENTICATION"
__event_keys__ = {
"8b586848-2fb3-4161-abbe-642157eec7ce": "authentication_disconnect_user",
}
__event_validation__ = {
"8b586848-2fb3-4161-abbe-642157eec7ce": "authentication_disconnect_user",
}
@classmethod
def authentication_disconnect_user(
cls, data: Logout, token_dict: Union[EmployeeTokenObject, OccupantTokenObject]
):
found_user = Users.filter_one(Users.uu_id == token_dict.user_uu_id).data
if not found_user:
return JSONResponse(
content={
"completed": False,
"message": "Invalid data",
"data": None,
},
status_code=status.HTTP_202_ACCEPTED,
)
if already_tokens := get_object_via_user_uu_id(user_id=str(found_user.uu_id)):
for key, token_user in already_tokens.items():
redis_cli.delete(key)
selected_user = Users.filter_one(
Users.uu_id == token_user.get("uu_id"),
).data
selected_user.remove_refresher_token(
domain=data.domain, disconnect=True
)
return JSONResponse(
content={
"completed": True,
"message": "All sessions are disconnected",
"data": selected_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data", "data": None},
status_code=status.HTTP_202_ACCEPTED,
)
class AuthenticationLogoutEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Logout only single session of user which domain is provided"
event_category = "AUTHENTICATION"
__event_keys__ = {
"5cc22e4e-a0f7-4077-be41-1871feb3dfd1": "authentication_logout_user",
}
__event_validation__ = {
"5cc22e4e-a0f7-4077-be41-1871feb3dfd1": "authentication_logout_user",
}
@classmethod
def authentication_logout_user(
cls, request: Request, data: Logout, token_dict: dict = None
):
token_user = None
if already_tokens := get_object_via_access_key(request=request):
for key in already_tokens:
token_user = json.loads(redis_cli.get(key) or {})
if token_user.get("domain") == data.domain:
redis_cli.delete(key)
selected_user = Users.filter_one(
Users.uu_id == token_user.get("uu_id"),
).data
selected_user.remove_refresher_token(domain=data.domain)
return JSONResponse(
content={
"completed": True,
"message": "Session is logged out",
"data": token_user,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Logout is not successfully completed",
"data": None,
},
status_code=status.HTTP_202_ACCEPTED,
)
class AuthenticationRefreshTokenEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Refresh access token with refresher token"
event_category = "AUTHENTICATION"
__event_keys__ = {
"c90f3334-10c9-4181-b5ff-90d98a0287b2": "authentication_refresher_token",
}
__event_validation__ = {
"c90f3334-10c9-4181-b5ff-90d98a0287b2": "authentication_refresher_token",
}
@classmethod
def authentication_refresher_token(
cls, request: Request, data: Remember, token_dict: dict = None
):
token_refresher = UsersTokens.filter_by_one(
token=data.refresh_token,
domain=data.domain,
**UsersTokens.valid_record_dict,
).data
if not token_refresher:
return JSONResponse(
content={"completed": False, "message": "Invalid data", "data": {}},
status_code=status.HTTP_202_ACCEPTED,
)
if found_user := Users.filter_one(
Users.id == token_refresher.user_id,
).data:
found_user: Users = found_user
access_key = save_access_token_to_redis(
request=request, found_user=found_user, domain=data.domain
)
found_user.last_agent = request.headers.get("User-Agent", None)
found_user.last_platform = request.headers.get("Origin", None)
found_user.last_remote_addr = getattr(
request, "remote_addr", None
) or request.headers.get("X-Forwarded-For", None)
found_user.last_seen = str(system_arrow.now())
return JSONResponse(
content={
"completed": True,
"message": "User is logged in successfully via refresher token",
"data": load_user_with_erp_details(
found_user,
{
"access_token": access_key,
"refresh_token": data.refresh_token,
},
),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data", "data": {}},
status_code=status.HTTP_202_ACCEPTED,
)
class AuthenticationForgotPasswordEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Send an email to user for a valid password reset token"
event_category = "AUTHENTICATION"
__event_keys__ = {
"e3ca6e24-b9f8-4127-949c-3bfa364e3513": "authentication_forgot_password",
}
__event_validation__ = {
"e3ca6e24-b9f8-4127-949c-3bfa364e3513": "authentication_forgot_password",
}
@classmethod
def authentication_forgot_password(
cls,
request: Request,
data: Forgot,
):
found_user: Users = Users.check_user_exits(
access_key=data.access_key, domain=data.domain
)
forgot_key = save_access_token_to_redis(
request=request, found_user=found_user, domain=data.domain
)
forgot_link = ApiStatic.forgot_link(forgot_key=forgot_key)
send_email_completed = send_email(
subject=f"Dear {found_user.user_tag}, your forgot password link has been sent.",
receivers=[str(found_user.email)],
html=change_your_password_template(
user_name=found_user.user_tag, forgot_link=forgot_link
),
)
if not send_email_completed:
raise HTTPException(
status_code=400, detail="Email can not be sent. Try again later"
)
found_user.password_token = forgot_key
found_user.password_token_is_valid = str(system_arrow.shift(days=1))
found_user.save()
return JSONResponse(
content={
"completed": True,
"message": "Password is change link is sent to your email or phone",
"data": {},
},
status_code=status.HTTP_200_OK,
)
class AuthenticationResetPasswordEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"af9e121e-24bb-44ac-a616-471d5754360e": "authentication_reset_password",
}
@classmethod
def authentication_reset_password(cls, data: Forgot):
from sqlalchemy import or_
found_user = Users.query.filter(
or_(
Users.email == str(data.access_key).lower(),
Users.phone_number == str(data.access_key).replace(" ", ""),
),
).first()
if not found_user:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Given access key or domain is not matching with the any user record.",
)
reset_password_token = found_user.reset_password_token(found_user=found_user)
send_email_completed = send_email(
subject=f"Dear {found_user.user_tag}, a password reset request has been received.",
receivers=[str(found_user.email)],
html=change_your_password_template(
user_name=found_user.user_tag,
forgot_link=ApiStatic.forgot_link(forgot_key=reset_password_token),
),
)
if not send_email_completed:
raise found_user.raise_http_exception(
status_code=400, message="Email can not be sent. Try again later"
)
return JSONResponse(
content={
"completed": True,
"message": "Password change link is sent to your email or phone",
"data": found_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class AuthenticationDownloadAvatarEventMethods(MethodToEvent):
event_type = "LOGIN"
event_description = "Download avatar icon and profile info of user"
event_category = "AUTHENTICATION"
__event_keys__ = {
"c140cd5f-307f-4046-a93e-3ade032a57a7": "authentication_download_avatar",
}
__event_validation__ = {
"c140cd5f-307f-4046-a93e-3ade032a57a7": "authentication_download_avatar",
}
@classmethod
def authentication_download_avatar(
cls, token_dict: Union[EmployeeTokenObject, OccupantTokenObject]
):
if found_user := Users.filter_one(Users.id == token_dict.user_id).data:
expired_starts = str(
system_arrow.now() - system_arrow.get(str(found_user.expiry_ends))
)
expired_int = (
system_arrow.now() - system_arrow.get(str(found_user.expiry_ends))
).days
return JSONResponse(
content={
"completed": True,
"message": "Avatar and profile is shared via user credentials",
"data": {
"lang": token_dict.lang,
"full_name": found_user.person.full_name,
"avatar": found_user.avatar,
"remember_me": found_user.remember_me,
"expiry_ends": str(found_user.expiry_ends),
"expired_str": expired_starts,
"expired_int": int(expired_int),
},
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": False, "message": "Invalid data", "data": {}},
status_code=status.HTTP_202_ACCEPTED,
)
AuthenticationLoginEventMethod = AuthenticationLoginEventMethods(
action=ActionsSchema(endpoint="/authentication/login")
)
AuthenticationSelectEventMethod = AuthenticationSelectEventMethods(
action=ActionsSchema(endpoint="/authentication/select")
)
AuthenticationCheckTokenEventMethod = AuthenticationCheckTokenEventMethods(
action=ActionsSchema(endpoint="/authentication/valid")
)
AuthenticationRefreshEventMethod = AuthenticationRefreshEventMethods(
action=ActionsSchema(endpoint="/authentication/refresh")
)
AuthenticationChangePasswordEventMethod = AuthenticationChangePasswordEventMethods(
action=ActionsSchema(endpoint="/authentication/change_password")
)
AuthenticationCreatePasswordEventMethod = AuthenticationCreatePasswordEventMethods(
action=ActionsSchema(endpoint="/authentication/create_password")
)
AuthenticationDisconnectUserEventMethod = AuthenticationDisconnectUserEventMethods(
action=ActionsSchema(endpoint="/authentication/disconnect")
)
AuthenticationLogoutEventMethod = AuthenticationLogoutEventMethods(
action=ActionsSchema(endpoint="/authentication/logout")
)
AuthenticationRefreshTokenEventMethod = AuthenticationRefreshTokenEventMethods(
action=ActionsSchema(endpoint="/authentication/refresher")
)
AuthenticationForgotPasswordEventMethod = AuthenticationForgotPasswordEventMethods(
action=ActionsSchema(endpoint="/authentication/forgot")
)
AuthenticationDownloadAvatarEventMethod = AuthenticationDownloadAvatarEventMethods(
action=ActionsSchema(endpoint="/authentication/avatar")
)
AuthenticationResetPasswordEventMethod = AuthenticationResetPasswordEventMethods(
action=ActionsSchema(endpoint="/authentication/reset_password")
)
# UserLogger.log_error(
# str(
# dict(
# user_id=found_user.id,
# domain=data.domain,
# access_key=token_user.get("access_input"),
# agent=request.headers.get("User-Agent", None),
# ip=getattr(request, "remote_addr", None)
# or request.headers.get("X-Forwarded-For", None),
# platform=request.headers.get("Origin", None),
# login_date=datetime.datetime.utcnow().__str__(),
# is_login=False,
# )
# )
# )
# UserLogger.log_error(
# str(
# dict(
# user_id=found_user.id,
# domain=data.domain,
# access_key=data.access_key,
# agent=request.headers.get("User-Agent", None),
# ip=getattr(request, "remote_addr", None)
# or request.headers.get("X-Forwarded-For", None),
# platform=request.headers.get("Origin", None),
# login_date=str(DateTimeLocal.now()),
# is_login=False,
# )
# )
# )
# UserLogger.log_error(
# str(
# dict(
# user_id=found_user.id,
# domain=data.domain,
# access_key="via_refresher",
# agent=request.headers.get("User-Agent", None),
# ip=getattr(request, "remote_addr", None)
# or request.headers.get("X-Forwarded-For", None),
# platform=request.headers.get("Origin", None),
# login_date=datetime.datetime.utcnow().__str__(),
# is_login=False,
# )
# )
# )
# UserLogger.log_error(
# str(
# dict(
# user_id=selected_user.id,
# domain=data.domain,
# access_key=token_user.get("access_input"),
# agent=request.headers.get("User-Agent", None),
# ip=getattr(request, "remote_addr", None)
# or request.headers.get("X-Forwarded-For", None),
# platform=request.headers.get("Origin", None),
# login_date=datetime.datetime.utcnow().__str__(),
# is_login=False,
# )
# )
# )

5
api_events/events/application/rules.py Normal file
View File

@@ -0,0 +1,5 @@
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class RulesEvents(MethodToEvent): ...

0
api_events/events/building/__init__.py Normal file
View File

308
api_events/events/building/building_build.py Normal file
View File

@@ -0,0 +1,308 @@
import typing
from typing import Union
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from databases import (
Build,
RelationshipEmployee2Build,
Addresses,
BuildParts,
BuildTypes,
ApiEnumDropdown,
)
from api_validations.validations_request import (
InsertBuild,
UpdateBuild,
PatchRecord,
ListOptions,
)
from api_validations.validations_response import ListBuildingResponse
from api_validations.core_response import AlchemyJsonResponse
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class BuildListEventMethods(MethodToEvent):
event_type = "SELECT"
event_description = ""
event_category = ""
__event_keys__ = {
"68b3b5ed-b74c-4a27-820f-3959214e94e9": "build_list",
}
__event_validation__ = {
"68b3b5ed-b74c-4a27-820f-3959214e94e9": ListBuildingResponse,
}
@classmethod
def build_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
Build.pre_query = Build.filter_all(
Build.id == token_dict.selected_occupant.build_id,
).query
elif isinstance(token_dict, EmployeeTokenObject):
Build.pre_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
Build.filter_attr = list_options
records = Build.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Building Records are listed",
result=records,
response_model=ListBuildingResponse,
)
class BuildCreateEventMethods(MethodToEvent):
event_type = "CREATE"
event_description = ""
event_category = ""
__event_keys__ = {
"a2271854-6b90-43da-a440-a62b70d90528": "build_create",
"b67ee709-0992-4604-9f90-fb1da10d5cf9": "create_building_employee",
}
__event_validation__ = {
"a2271854-6b90-43da-a440-a62b70d90528": InsertBuild,
"b67ee709-0992-4604-9f90-fb1da10d5cf9": InsertBuild,
}
@classmethod
def build_create(cls, data: InsertBuild, token_dict: EmployeeTokenObject):
if not token_dict.selected_company.employee_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"Employee id is not found for {token_dict.selected_company.employee_uu_id}",
)
if not token_dict.selected_company.company_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"Company id is not found for {token_dict.selected_company.company_uu_id}",
)
created_build = Build.create_action(data=data, token=token_dict)
build_type = BuildTypes.filter_by_one(
**BuildTypes.valid_record_dict, type_code="APT_YNT"
).data
if not build_type:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Build type APT_YNT is not found. Please contact with your system administrator.",
)
api_enum = ApiEnumDropdown.filter_by_one(enum_class="Directions", key="NN").data
if not api_enum:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Api Enum NN is not found. Please contact with your system administrator.",
)
build_parts = dict(
address_gov_code=f"{data.gov_address_code}-M",
build_id=int(created_build.id),
build_uu_id=str(created_build.uu_id),
part_no="0",
part_type_id=int(build_type.id),
part_type_uu_id=str(build_type.uu_id),
part_direction_id=int(api_enum.id),
part_direction_uu_id=str(api_enum.uu_id),
part_code="MAN-ROOM",
human_livable=False,
)
man_build_part = BuildParts.find_or_create(**build_parts)
created_build.save()
created_build.update(management_room_id=man_build_part.id)
created_build.save()
man_build_part.update(is_confirmed=True)
man_build_part.save()
# created_build_relation = RelationshipEmployee2Build.find_or_create(
# company_id=token_dict.selected_company.company_id,
# member_id=created_build.id,
# employee_id=token_dict.selected_company.employee_id,
# )
# created_build_relation.update(is_confirmed=True)
# created_build_relation.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Build record completed. This build is assigned to you.",
"data": created_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
@classmethod
def create_building_employee(
cls, data: InsertBuild, token_dict: EmployeeTokenObject
):
records = Addresses.list_via_employee(
token_dict=token_dict, filter_expr=[Addresses.uu_id == data.address_uu_id]
).data
if not records:
raise HTTPException(
status_code=404,
detail=f"This address {data.address_uu_id} is not found in the user's address list.",
)
if not token_dict.selected_company.employee_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"Employee id is not found for {token_dict.selected_company.employee_uu_id}",
)
if not token_dict.selected_company.company_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"Company id is not found for {token_dict.selected_company.company_uu_id}",
)
created_build = Build.create_action(data=data, token=token_dict)
created_build_relation = RelationshipEmployee2Build.find_or_create(
company_id=token_dict.selected_company.company_id,
member_id=created_build.id,
employee_id=token_dict.selected_company.employee_id,
)
created_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Build record completed. This build is assigned to you.",
"data": created_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class BuildUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
event_description = ""
event_category = ""
__class_key__ = ""
__event_keys__ = {
"5ad38a66-1189-451e-babb-77de2d63d757": "build_update",
}
__event_validation__ = {
"5ad38a66-1189-451e-babb-77de2d63d757": UpdateBuild,
}
@classmethod
def build_update(
cls,
build_uu_id: str,
data: UpdateBuild,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
Build.pre_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
updated_build = Build.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
)
Build.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Build record",
"data": updated_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
elif isinstance(token_dict, EmployeeTokenObject):
find_one_build = Build.filter_one(
Build.uu_id == build_uu_id,
).data
access_authorized_build = Build.select_action(
employee_id=token_dict.selected_company.employee_id,
filter_expr=[Build.id == find_one_build.id],
)
if access_authorized_build.count:
updated_build = Build.update_action(
data=data, token=token_dict, build_uu_id=build_uu_id
)
return JSONResponse(
content={
"completed": True,
"message": "Update Build record",
"data": updated_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=f"This user can not modify {build_uu_id} - building.",
)
class BuildPatchEventMethods(MethodToEvent):
event_type = "PATCH"
event_description = ""
event_category = ""
__event_keys__ = {
"e3876bfe-8847-4dea-ae36-e709f7431930": "build_patch",
}
__event_validation__ = {
"e3876bfe-8847-4dea-ae36-e709f7431930": "build_patch",
}
@classmethod
def build_patch(cls, build_uu_id: str, data: PatchRecord, token_dict):
find_one_build = Build.filter_one(
Build.uu_id == build_uu_id,
)
access_authorized_build = Build.select_action(
employee_id=token_dict.selected_company.employee_id,
filter_expr=[Build.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,
)
BuildListEventMethod = BuildListEventMethods(
action=ActionsSchema(endpoint="/building/build/list")
)
BuildCreateEventMethod = BuildCreateEventMethods(
action=ActionsSchema(endpoint="/building/build/create")
)
BuildUpdateEventMethod = BuildUpdateEventMethods(
action=ActionsSchema(endpoint="/building/build/update")
)
BuildPatchEventMethod = BuildPatchEventMethods(
action=ActionsSchema(endpoint="/building/build/patch")
)

176
api_events/events/building/building_build_area.py Normal file
View File

@@ -0,0 +1,176 @@
import typing
from databases import (
Build,
BuildArea,
)
from api_validations.validations_request import (
InsertBuildArea,
UpdateBuildArea,
ListOptions,
)
from api_validations.core_response import AlchemyJsonResponse
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
class BuildAreaListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"0bb51845-65a2-4340-8872-a3b5aad95468": "build_area_list",
}
__event_validation__ = {
"0bb51845-65a2-4340-8872-a3b5aad95468": None,
}
@classmethod
def build_area_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
build_ids = Build.filter_all(
Build.id == token_dict.selected_occupant.build_id,
).data
BuildArea.pre_query = BuildArea.filter_all(
BuildArea.build_id.in_([build.id for build in build_ids]),
).query
elif isinstance(token_dict, EmployeeTokenObject):
build_ids = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
BuildArea.pre_query = BuildArea.filter_all(
BuildArea.build_id.in_([build.id for build in build_ids]),
).query
BuildArea.filter_attr = list_options
records = BuildArea.filter_all()
return AlchemyJsonResponse(
completed=True, message="List of Build Area", result=records
)
class BuildAreaCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"a10571fa-ac1d-4546-9272-cacb911d8004": "build_area_create",
}
__event_validation__ = {
"a10571fa-ac1d-4546-9272-cacb911d8004": InsertBuildArea,
}
@classmethod
def build_area_create(
cls,
data: InsertBuildArea,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
data_dict = data.excluded_dump()
selected_build = None
if isinstance(token_dict, OccupantTokenObject):
if not token_dict.selected_occupant.build_uuid == data.build_uu_id:
BuildArea.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Occupant can not create build area for {data.build_uu_id}",
data={
"build_uu_id": data.build_uu_id,
},
)
selected_build = Build.filter_by_one(
system=True, uu_id=data.build_uu_id
).data
elif isinstance(token_dict, EmployeeTokenObject):
build_ids = Build.select_action(
employee_id=token_dict.selected_company.employee_id
).all()
if not str(data.build_uu_id) in [str(build.uu_id) for build in build_ids]:
BuildArea.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Employee can not create build area for {data.build_uu_id}",
data={
"build_uu_id": data.build_uu_id,
},
)
selected_build = Build.filter_by_one(
system=True, uu_id=data.build_uu_id
).data
data_dict["build_id"] = selected_build.id
data_dict["build_uu_id"] = str(selected_build.uu_id)
created_build_part = BuildArea.find_or_create(**data_dict)
created_build_part.save()
created_build_part.update(is_confirmed=True)
created_build_part.save()
return AlchemyJsonResponse(
completed=True,
message="Created Build Area",
result=created_build_part.get_dict(),
)
class BuildAreaUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"58178738-7489-4f8f-954e-5c8f083c1845": "build_area_update",
}
__event_validation__ = {
"58178738-7489-4f8f-954e-5c8f083c1845": UpdateBuildArea,
}
@classmethod
def build_area_update(
cls,
build_uu_id: str,
data: UpdateBuildArea,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return AlchemyJsonResponse(
completed=False,
message="Update Build record",
result=None,
)
class BuildAreaPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"d6bd8a5f-fa76-49da-b82e-4a95f1bcce39": "build_area_patch",
}
__event_validation__ = {
"d6bd8a5f-fa76-49da-b82e-4a95f1bcce39": None,
}
@classmethod
def build_area_patch(
cls,
build_uu_id: str,
data,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return AlchemyJsonResponse(
completed=False,
message="Patch Build record",
result=None,
)
BuildAreaListEventMethod = BuildAreaListEventMethods(
action=ActionsSchema(endpoint="/building/area/list")
)
BuildAreaCreateEventMethod = BuildAreaCreateEventMethods(
action=ActionsSchema(endpoint="/building/area/create")
)
BuildAreaUpdateEventMethod = BuildAreaUpdateEventMethods(
action=ActionsSchema(endpoint="/building/area/update")
)
BuildAreaPatchEventMethod = BuildAreaPatchEventMethods(
action=ActionsSchema(endpoint="/building/area/patch")
)

165
api_events/events/building/building_build_parts.py Normal file
View File

@@ -0,0 +1,165 @@
from typing import Union
from fastapi.responses import JSONResponse
from fastapi import status
from api_validations.validations_response.parts import BuildPartsListResponse
from databases import (
Build,
BuildParts,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
InsertBuildParts,
UpdateBuildParts,
ListOptions,
)
class BuildingBuildPartsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"b860e37a-e19b-4c45-9543-461241f7587c": "building_build_parts_list"
}
__event_validation__ = {
"b860e37a-e19b-4c45-9543-461241f7587c": BuildPartsListResponse
}
@classmethod
def building_build_parts_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
build_list_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id,
)
build_list_ids = [build.id for build in build_list_query.all()]
BuildParts.pre_query = BuildParts.filter_all(
BuildParts.build_id.in_(build_list_ids),
).query
BuildParts.filter_attr = list_options
records = BuildParts.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Building Parts Records are listed",
result=records,
cls_object=BuildParts,
response_model=BuildPartsListResponse,
filter_attributes=list_options,
)
class BuildingBuildPartsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"fb403f69-11ed-4f4f-ad71-5e6fb4a793d2": "building_build_parts_create"
}
__event_validation__ = {"fb403f69-11ed-4f4f-ad71-5e6fb4a793d2": InsertBuildParts}
@classmethod
def building_build_parts_create(
cls,
data: InsertBuildParts,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
created_build = BuildParts.create_action(data=data, token=token_dict)
created_build.save()
created_build.update(is_confirmed=True)
created_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Build Parts record",
"data": created_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class BuildingBuildPartsUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"58fdf95e-2110-4ed6-9c26-95f4be87eaee": "building_build_parts_update"
}
__event_validation__ = {"58fdf95e-2110-4ed6-9c26-95f4be87eaee": UpdateBuildParts}
@classmethod
def building_build_parts_update(
cls,
data: UpdateBuildParts,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
updated_build = BuildParts.update_action(data=data, token=token_dict)
updated_build.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Build Parts record",
"data": updated_build,
},
status_code=status.HTTP_200_OK,
)
class BuildingBuildPartsPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"87a15ade-3474-4206-b574-bbf8580cbb14": "building_build_parts_patch"
}
__event_validation__ = {"87a15ade-3474-4206-b574-bbf8580cbb14": None}
@classmethod
def building_build_parts_patch(cls, data, token_dict):
find_one_build = BuildParts.filter_one(
BuildParts.uu_id == data.uu_id,
).data
access_authorized_build = BuildParts.select_action(
duty_id=token_dict.selected_company.duty_id,
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": "Update Build Parts record",
"data": find_one_build.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Update Build Parts record",
"data": {},
},
status_code=status.HTTP_200_OK,
)
BuildingBuildPartsListEventMethod = BuildingBuildPartsListEventMethods(
action=ActionsSchema(endpoint="/building/parts/list")
)
BuildingBuildPartsCreateEventMethod = BuildingBuildPartsCreateEventMethods(
action=ActionsSchema(endpoint="/building/parts/create")
)
BuildingBuildPartsUpdateEventMethod = BuildingBuildPartsUpdateEventMethods(
action=ActionsSchema(endpoint="/building/parts/update")
)
BuildingBuildPartsPatchEventMethod = BuildingBuildPartsPatchEventMethods(
action=ActionsSchema(endpoint="/building/parts/patch")
)

175
api_events/events/building/building_build_sites.py Normal file
View File

@@ -0,0 +1,175 @@
import typing
from databases import (
Build,
BuildSites,
)
from api_validations.validations_request import (
InsertBuildArea,
UpdateBuildArea,
ListOptions,
)
from api_validations.core_response import AlchemyJsonResponse
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from databases.sql_models.identity.identity import Addresses
class BuildSitesListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"6798414c-6c7d-47f0-9d8b-6935a0f51c2e": "build_sites_list",
}
__event_validation__ = {
"6798414c-6c7d-47f0-9d8b-6935a0f51c2e": None,
}
@classmethod
def build_sites_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
occupants_build = Build.filter_one(
Build.id == token_dict.selected_occupant.build_id,
).data
BuildSites.pre_query = BuildSites.filter_all(
BuildSites.address_id == occupants_build.address_id,
).query
elif isinstance(token_dict, EmployeeTokenObject):
employees_build = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
employees_build_list = [build.address_id for build in employees_build.all()]
if not employees_build_list:
BuildSites.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="Employee has no build sites registered",
data={},
)
BuildSites.pre_query = BuildSites.filter_all(
BuildSites.address_id.in_(employees_build_list)
).query
BuildSites.filter_attr = list_options
records = BuildSites.filter_all()
return AlchemyJsonResponse(
completed=True, message="Update Build record", result=records
)
class BuildSitesCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"57edc8bf-8f29-4e75-b5e1-9ca0139a3fda": "build_sites_create",
}
__event_validation__ = {
"57edc8bf-8f29-4e75-b5e1-9ca0139a3fda": InsertBuildArea,
}
@classmethod
def build_area_create(
cls,
data: InsertBuildArea,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
if not token_dict.selected_occupant.build_uuid == data.build_uu_id:
BuildSites.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Occupant can not create build sites for {data.build_uu_id}",
data={
"build_uu_id": data.build_uu_id,
},
)
elif isinstance(token_dict, EmployeeTokenObject):
build_ids = Build.select_action(
employee_id=token_dict.selected_company.employee_id
).all()
if not str(data.build_uu_id) in [str(build.uu_id) for build in build_ids]:
BuildSites.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Employee can not create build sites for {data.build_uu_id}",
data={
"build_uu_id": data.build_uu_id,
},
)
data_dict = data.excluded_dump()
created_build_part = BuildSites.find_or_create(**data_dict)
created_build_part.save()
created_build_part.update(is_confirmed=True)
created_build_part.save()
return AlchemyJsonResponse(
completed=True,
message="Update Build record",
result=created_build_part,
)
class BuildSitesUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"b18e8e37-a62b-4a84-9972-ba17121ed393": "build_sites_update",
}
__event_validation__ = {
"b18e8e37-a62b-4a84-9972-ba17121ed393": UpdateBuildArea,
}
@classmethod
def build_area_update(
cls,
build_uu_id: str,
data: UpdateBuildArea,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return AlchemyJsonResponse(
completed=False,
message="Update Build record",
result=None,
)
class BuildSitesPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"39ba1d78-ff0d-4ec7-a363-b457cbf199a0": "build_sites_patch",
}
__event_validation__ = {
"39ba1d78-ff0d-4ec7-a363-b457cbf199a0": None,
}
@classmethod
def build_area_patch(
cls,
build_uu_id: str,
data,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return AlchemyJsonResponse(
completed=False,
message="Patch Build record",
result=None,
)
BuildSitesListEventMethod = BuildSitesListEventMethods(
action=ActionsSchema(endpoint="/building/sites/list")
)
BuildSitesCreateEventMethod = BuildSitesCreateEventMethods(
action=ActionsSchema(endpoint="/building/sites/create")
)
BuildSitesUpdateEventMethod = BuildSitesUpdateEventMethods(
action=ActionsSchema(endpoint="/building/sites/update")
)
BuildSitesPatchEventMethod = BuildSitesPatchEventMethods(
action=ActionsSchema(endpoint="/building/sites/patch")
)

48
api_events/events/building/building_build_types.py Normal file
View File

@@ -0,0 +1,48 @@
from typing import Union
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
ListOptions,
)
from databases.sql_models.building.build import BuildTypes
class BuildTypesListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"5344d03c-fc47-43ec-8c44-6c2acd7e5d9f": "build_types_list",
}
__event_validation__ = {"5344d03c-fc47-43ec-8c44-6c2acd7e5d9f": None}
@classmethod
def build_types_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
from fastapi.exceptions import HTTPException
if isinstance(token_dict, EmployeeTokenObject):
BuildTypes.filter_attr = list_options
results = BuildTypes.filter_all()
return AlchemyJsonResponse(
completed=True,
result=results,
message="Build Types are listed successfully",
)
elif isinstance(token_dict, OccupantTokenObject):
raise HTTPException(
status_code=403, detail="You are not authorized to access this endpoint"
)
else:
raise HTTPException(
status_code=403, detail="You are not authorized to access this endpoint"
)
BuildTypesListEventMethod = BuildTypesListEventMethods(
action=ActionsSchema(endpoint="/building/types/list")
)

307
api_events/events/building/building_living_spaces.py Normal file
View File

@@ -0,0 +1,307 @@
from typing import Union
from api_events.events.events.events_bind_services import (
ServiceBindOccupantEventMethods,
)
from databases import (
Modules,
BuildParts,
Build,
BuildLivingSpace,
OccupantTypes,
People,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
InsertBuildLivingSpace,
UpdateBuildLivingSpace,
ListOptions,
)
from api_validations.validations_response.living_space import LivingSpaceListResponse
from databases.sql_models.event.event import Services
class BuildingLivingSpacesListEventMethods(MethodToEvent):
event_type = "SELECT"
event_description = ""
event_category = ""
__event_keys__ = {
"36961d8a-cefa-46cc-9f7c-9d841d6351b6": "building_live_space_list",
}
__event_validation__ = {
"36961d8a-cefa-46cc-9f7c-9d841d6351b6": LivingSpaceListResponse
}
@classmethod
def building_live_space_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
records, Build.filter_attr = [], None
if isinstance(token_dict, OccupantTokenObject):
occupants_build_id = Build.filter_one(
Build.id == token_dict.selected_occupant.build_id,
).data
if not occupants_build_id:
Build.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Occupant has no build registered in the system. Contact with your company.",
data={},
)
occupants_build_parts = BuildParts.filter_all(
BuildParts.build_id.in_(occupants_build_id.id),
).data
if not occupants_build_parts:
Build.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Occupant has no build parts registered in the system. Contact with your company.",
data={},
)
BuildLivingSpace.pre_query = BuildLivingSpace.filter_all(
BuildLivingSpace.build_parts_id.in_(
[build_part.id for build_part in occupants_build_parts]
),
).query
BuildLivingSpace.filter_attr = list_options
records = BuildLivingSpace.filter_all()
elif isinstance(token_dict, EmployeeTokenObject):
build_id_list_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
if not build_id_list_query:
Build.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Employee has no build registered in the system. Contact with your supervisor.",
data={},
)
build_part_id_list_query = BuildParts.filter_all(
BuildParts.build_id.in_(
[build.id for build in build_id_list_query.all()]
),
).data
if not build_part_id_list_query:
Build.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"Employee has no build parts registered in the system. Contact with your supervisor.",
data={},
)
BuildLivingSpace.pre_query = BuildLivingSpace.filter_all(
BuildLivingSpace.build_parts_id.in_(
[build_part.id for build_part in build_part_id_list_query]
),
).query
BuildLivingSpace.filter_attr = list_options
records = BuildLivingSpace.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Building Living Spaces are listed successfully",
result=records,
response_model=LivingSpaceListResponse,
cls_object=BuildLivingSpace,
filter_attributes=list_options,
)
class BuildingLivingSpacesCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"46d90119-3b23-4784-8053-fe11da4a3584": "building_live_space_create"
}
__event_validation__ = {
"46d90119-3b23-4784-8053-fe11da4a3584": InsertBuildLivingSpace
}
@classmethod
def building_live_space_create(
cls,
data: InsertBuildLivingSpace,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
from api_library.date_time_actions.date_functions import system_arrow
data_dict = data.excluded_dump()
build_id_list_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
build_part = BuildParts.filter_one(
BuildParts.uu_id == data.build_parts_uu_id,
BuildParts.build_id.in_([build.id for build in build_id_list_query.all()]),
).data
if not build_part:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message=f"{data.build_parts_uu_id} - Build Part is not found in database. Check build part uu_id",
data={
"build_parts_uu_id": data.build_parts_uu_id,
},
)
life_person = People.filter_one(
People.uu_id == data.person_uu_id,
).data
if not life_person:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message=f"{data.person_uu_id} - Living Person is not found in database.",
data={
"person_uu_id": data.person_uu_id,
},
)
occupant_type = OccupantTypes.filter_by_one(uu_id=data.occupant_type_uu_id).data
if not occupant_type:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="UNAUTHORIZED",
message=f"{data.occupant_type_uu_id} - Occupant Type is not found in database. Check occupant type uu_id",
data={
"occupant_type_uu_id": data.occupant_type_uu_id,
},
)
data_dict["occupant_type"] = occupant_type.id
data_dict["occupant_type_uu_id"] = str(occupant_type.uu_id)
data_dict["build_parts_id"] = build_part.id
data_dict["build_parts_uu_id"] = str(build_part.uu_id)
data_dict["person_id"] = life_person.id
data_dict["person_uu_id"] = str(life_person.uu_id)
living_space_id = BuildLivingSpace.select_only(
BuildLivingSpace.build_parts_id == build_part.id,
BuildLivingSpace.person_id == life_person.id,
BuildLivingSpace.occupant_type == occupant_type.id,
select_args=[BuildLivingSpace.id],
order_by=BuildLivingSpace.expiry_starts.desc(),
limit=1,
).data
last_living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == living_space_id[0] if living_space_id else None,
).data
created_living_space = BuildLivingSpace.create_action(
data=data_dict, token_dict=token_dict
)
if last_living_space:
dt = system_arrow.get(last_living_space.expiry_ends)
if dt > system_arrow.now():
minute_df = int(dt.time().minute) - 10
last_living_space.expiry_ends = str(
dt.replace(
minute=60 - abs(minute_df) if minute_df < 0 else minute_df
)
)
last_living_space.save()
created_living_space.save_and_confirm()
occupants_service = Services.retrieve_service_via_occupant_code(
occupant_code=occupant_type.occupant_code
)
ServiceBindOccupantEventMethods.bind_services_occupant_system(
build_living_space_id=created_living_space.id,
service_id=occupants_service.id,
)
return created_living_space
class BuildingLivingSpacesUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"c786e15c-c03e-4e8f-936c-7e5e5ec9bbcc": "building_live_space_update",
}
__event_validation__ = {
"c786e15c-c03e-4e8f-936c-7e5e5ec9bbcc": UpdateBuildLivingSpace
}
@classmethod
def building_live_space_update(
cls,
build_uu_id: str,
data: UpdateBuildLivingSpace,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
from api_library.date_time_actions.date_functions import system_arrow
if isinstance(token_dict, OccupantTokenObject):
data_dict = data.dump()
build_id_list_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
build_part = BuildParts.filter_one(
BuildParts.uu_id == data.build_parts_uu_id,
BuildParts.build_id.in_(
[build.id for build in build_id_list_query.all()]
),
).data
if not build_part:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"{data.life_person_uu_id} - Living Person is not found in database.",
data={
"person_uu_id": data.life_person_uu_id,
},
)
life_person = People.filter_one(
People.uu_id == data.life_person_uu_id or ""
).data
if not life_person:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"{data.life_person_uu_id} - Living Person is not found in database.",
data={
"person_uu_id": data.life_person_uu_id,
},
)
living_space_id = BuildLivingSpace.select_only(
*BuildLivingSpace.valid_record_args(BuildLivingSpace),
select_args=[BuildLivingSpace.id],
order_by=BuildLivingSpace.expiry_starts.desc(),
limit=1,
).get(1)
last_living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == living_space_id if living_space_id else None,
).data
data_dict["expiry_starts"] = str(system_arrow.now())
data_dict["is_tenant_live"] = bool(data.is_tenant_live)
data_dict["build_parts_id"] = build_part.id
if data_dict["is_tenant_live"]:
owner_person = getattr(last_living_space, "owner_person_id", None)
if not owner_person:
BuildLivingSpace.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message="Owner person of build part is not defined. Please register owner of part first.",
data=build_part.get_dict(),
)
data_dict["life_person_id"] = life_person.id
data_dict["owner_person_id"] = owner_person
else:
data_dict["life_person_id"] = life_person.id
data_dict["owner_person_id"] = life_person.id
del data_dict["build_parts_uu_id"], data_dict["life_person_uu_id"]
BuildingLivingSpacesListEventMethod = BuildingLivingSpacesListEventMethods(
action=ActionsSchema(endpoint="/building/living_space/list")
)
BuildingLivingSpacesCreateEventMethod = BuildingLivingSpacesCreateEventMethods(
action=ActionsSchema(endpoint="/building/living_space/create")
)
BuildingLivingSpacesUpdateEventMethod = BuildingLivingSpacesUpdateEventMethods(
action=ActionsSchema(endpoint="/building/living_space/update")
)

0
api_events/events/company/__init__.py Normal file
View File

189
api_events/events/company/company_company.py Normal file
View File

@@ -0,0 +1,189 @@
import typing
from fastapi import status
from fastapi.responses import JSONResponse
from databases import Companies
from api_validations.validations_request import (
InsertCompany,
UpdateCompany,
ListOptions,
PatchRecord,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class CompanyListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"f6900cb5-ac5b-478e-8e7c-fa87e65cd2e5": "company_list",
}
__event_validation__ = {"f6900cb5-ac5b-478e-8e7c-fa87e65cd2e5": None}
@classmethod
def company_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
Companies.pre_query = Companies.select_action(
duty_id_list=[
token_dict.selected_company.duty_id,
token_dict.selected_company.bulk_duties_id,
]
)
elif isinstance(token_dict, OccupantTokenObject):
Companies.pre_query = Companies.filter_all(
Companies.id == token_dict.selected_occupant.responsible_company_id
).query
Companies.filter_attr = list_options
records = Companies.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Building Living Spaces are listed successfully",
result=records,
)
class CompanyCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"76f11a08-5f4a-4e1f-961f-aaef21699acd": "company_create",
}
__event_validation__ = {"76f11a08-5f4a-4e1f-961f-aaef21699acd": InsertCompany}
@classmethod
def company_create(
cls,
data: InsertCompany,
token_dict: EmployeeTokenObject,
):
created_company = Companies.create_action(data=data, token=token_dict)
created_company.update(
related_company=token_dict.selected_company.company_uu_id
)
created_company.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Company record",
"data": created_company.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class CompanyUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"41ea7f29-006a-4310-b5c4-b2a0e1a504bd": "company_update",
}
__event_validation__ = {
"41ea7f29-006a-4310-b5c4-b2a0e1a504bd": UpdateCompany,
}
@classmethod
def company_update(
cls, company_uu_id: str, data: UpdateCompany, token_dict: EmployeeTokenObject
):
Companies.pre_query = Companies.select_action(
duty_id_list=[
token_dict.selected_company.bulk_duties_id,
token_dict.selected_company.duty_id,
],
)
find_one_company = Companies.filter_one(
Companies.uu_id == company_uu_id,
).data
if not find_one_company:
return JSONResponse(
content={
"completed": True,
"message": "Update Company record",
"data": {},
},
status_code=200,
)
updated_company = find_one_company.update(**data.excluded_dump())
Companies.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Company record",
"data": updated_company,
},
status_code=200,
)
class CompanyPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"6320d696-1fd1-49f9-860a-8f22e5b8a68d": "company_patch",
}
__event_validation__ = {"6320d696-1fd1-49f9-860a-8f22e5b8a68d": None}
@classmethod
def company_patch(
cls, company_uu_id: str, data: PatchRecord, token_dict: EmployeeTokenObject
):
find_one_company = Companies.filter_one(
Companies.uu_id == company_uu_id,
).data
access_authorized_company = Companies.select_action(
duty_id_list=[
token_dict.selected_company.bulk_duties_id,
token_dict.selected_company.duty_id,
],
)
if access_authorized_company.count:
action = data.excluded_dump()
find_one_company.active = bool(
action.get("active", find_one_company.active)
)
find_one_company.is_confirmed = bool(
action.get("confirm", find_one_company.is_confirmed)
)
find_one_company.deleted = bool(
action.get("delete", find_one_company.deleted)
)
find_one_company.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch Company record completed",
"data": find_one_company.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Company record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
CompanyPatchEventMethod = CompanyListEventMethods(
action=ActionsSchema(endpoint="/company/list")
)
CompanyCreateEventMethod = CompanyCreateEventMethods(
action=ActionsSchema(endpoint="/company/create")
)
CompanyUpdateEventMethod = CompanyUpdateEventMethods(
action=ActionsSchema(endpoint="/company/update")
)
CompanyListEventMethod = CompanyPatchEventMethods(
action=ActionsSchema(endpoint="/company/patch")
)

178
api_events/events/company/company_department.py Normal file
View File

@@ -0,0 +1,178 @@
from typing import Optional
from fastapi import status
from fastapi.responses import JSONResponse
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
BaseModelRegular,
)
from databases import Departments
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject
from api_validations.core_response import AlchemyJsonResponse
class DepartmentListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"2cb90331-c1b4-4923-8314-8111326b621a": "department_list",
}
__event_validation__ = {"2cb90331-c1b4-4923-8314-8111326b621a": None}
@classmethod
def department_list(
cls,
list_options: ListOptions,
token_dict: EmployeeTokenObject,
):
Departments.filter_attr = list_options
records = Departments.filter_all(
Departments.company_id == token_dict.selected_company.company_id,
)
return AlchemyJsonResponse(
completed=True,
message="Departments are listed successfully",
result=records,
)
class AdminUserInsertDepartments(BaseModelRegular):
department_code: str
department_name: str
company_uu_id: Optional[str] = None
department_description: str
parent_department_uu_id: Optional[int] = None
class DepartmentCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"d8bd3985-7f3b-4267-a74e-d5017e4ea9f8": "super_user_department_create",
}
__event_validation__ = {"d8bd3985-7f3b-4267-a74e-d5017e4ea9f8": DepartmentsPydantic}
@classmethod
def super_user_department_create(
cls,
data: DepartmentsPydantic,
token_dict: EmployeeTokenObject,
):
data_dict = data.excluded_dump()
data_dict["company_id"] = token_dict.selected_company.company_id
data_dict["company_uu_id"] = token_dict.selected_company.company_uu_id
created_department = Departments.find_or_create(**data_dict)
Departments.save()
return JSONResponse(
content={
"completed": False,
"message": "Company record already exits here is the record",
"data": created_department.get_dict(),
},
status_code=status.HTTP_202_ACCEPTED,
)
class DepartmentUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"4172706f-06c9-4c38-9ac8-59085a72f80a": "department_update",
}
__event_validation__ = {"4172706f-06c9-4c38-9ac8-59085a72f80a": DepartmentsPydantic}
@classmethod
def department_update(
cls,
company_uu_id: str,
data: DepartmentsPydantic,
token_dict: EmployeeTokenObject,
):
find_one_company = Departments.filter_one(Departments.uu_id == company_uu_id)
access_authorized_company = Departments.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[Departments.id == token_dict.get("")],
)
if access_authorized_company.count:
data_dict = data.excluded_dump()
updated_company = find_one_company.update(**data_dict)
Departments.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Company record",
"data": updated_company,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update Company record", "data": {}},
status_code=status.HTTP_200_OK,
)
class DepartmentPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"1e272e4f-6c1e-418b-91a7-be8b06c875da": "department_patch",
}
__event_validation__ = {"1e272e4f-6c1e-418b-91a7-be8b06c875da": None}
@classmethod
def department_patch(
cls, company_uu_id: str, data: PatchRecord, token_dict: EmployeeTokenObject
):
find_one_company = Departments.find_one_or_abort(uu_id=company_uu_id)
access_authorized_company = Departments.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[Departments.id == find_one_company.id],
)
if access_authorized_company.count:
action = data.excluded_dump()
find_one_company.active = bool(
action.get("active", find_one_company.active)
)
find_one_company.is_confirmed = bool(
action.get("confirm", find_one_company.is_confirmed)
)
find_one_company.deleted = bool(
action.get("delete", find_one_company.deleted)
)
find_one_company.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch Company record completed",
"data": find_one_company.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Company record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
DepartmentListEventMethod = DepartmentListEventMethods(
action=ActionsSchema(endpoint="/department/list")
)
DepartmentCreateEventMethod = DepartmentCreateEventMethods(
action=ActionsSchema(endpoint="/department/create")
)
DepartmentUpdateEventMethod = DepartmentUpdateEventMethods(
action=ActionsSchema(endpoint="/department/update")
)
DepartmentPatchEventMethod = DepartmentPatchEventMethods(
action=ActionsSchema(endpoint="/department/patch")
)

232
api_events/events/company/company_duties.py Normal file
View File

@@ -0,0 +1,232 @@
from fastapi import status
from fastapi.responses import JSONResponse
from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
InsertDuties,
UpdateDuties,
SelectDuties,
PatchRecord,
ListOptions,
)
from databases import Departments, Duty, Duties
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject
class DutiesListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"44b72beb-53a8-407b-a12a-76e74b65794d": "duties_list",
}
__event_validation__ = {"44b72beb-53a8-407b-a12a-76e74b65794d": None}
@classmethod
def duties_list(
cls,
list_options: ListOptions,
token_dict: EmployeeTokenObject,
):
Duties.filter_attr = list_options
records = Duties.filter_all(
Duties.company_id == token_dict.selected_company.company_id,
)
return AlchemyJsonResponse(
completed=True,
result=records,
message="List of Duties records",
)
class DutiesGetByUUIDEventMethods(MethodToEvent):
event_type = "GET"
__event_keys__ = {
"30c54cce-3303-4d36-959a-b64e383ae177": "duties_get_by_uuid",
}
__event_validation__ = {"30c54cce-3303-4d36-959a-b64e383ae177": SelectDuties}
@classmethod
def duties_get_by_uuid(
cls,
data: SelectDuties,
token_dict: EmployeeTokenObject,
):
duty = Duty.filter_one(Duty.uu_id == data.duty_uu_id).data
if not duty:
return JSONResponse(
content={
"completed": False,
"message": "Duty record is not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
records = Duties.filter_all(
Duties.duties_id == duty.id,
Duties.company_id == token_dict.selected_company.company_id,
)
if not records.data:
return JSONResponse(
content={
"completed": False,
"message": "Duties record is not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
return {
"completed": True,
"status": "success",
"data": [record.get_dict() for record in records.data],
}
class DutiesCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"3524ae42-0825-4af7-be85-7c890a4f65d3": "duties_create",
}
__event_validation__ = {"3524ae42-0825-4af7-be85-7c890a4f65d3": InsertDuties}
@classmethod
def duties_create(
cls,
data: InsertDuties,
token_dict: EmployeeTokenObject,
):
duty = Duty.filter_one(Duty.uu_id == data.duties_uu_id).data
department = Departments.filter_one(Duty.uu_id == data.department_uu_id).data
created_duties = Duties.find_or_create(
company_id=token_dict.selected_company.company_id,
company_uu_id=token_dict.selected_company.company_uu_id,
duties_id=duty.id,
duties_uu_id=str(duty.uu_id),
department_id=department.id,
department_uu_id=str(department.uu_id),
is_confirmed=data.is_confirmed,
)
if data.is_default_duty:
created_duties.update(users_default_duty=created_duties.id)
if not created_duties:
Duty.save()
return JSONResponse(
content={
"completed": False,
"message": "Failed to create Duties record",
"data": {},
},
status_code=status.HTTP_400_BAD_REQUEST,
)
return {
"completed": created_duties.is_found,
"message": (
"Create Duties record"
if created_duties.is_found
else "This record is already created"
),
"data": created_duties.get_dict(),
}
class DutiesUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"3fc77829-f1ee-4511-a2ca-582daa03125b": "duties_update",
}
__event_validation__ = {"3fc77829-f1ee-4511-a2ca-582daa03125b": UpdateDuties}
@classmethod
def duties_update(
cls,
duties_uu_id: str,
data: UpdateDuties,
token_dict: EmployeeTokenObject,
):
find_one_duties = Duties.find_one_or_abort(uu_id=duties_uu_id)
access_authorized_duties = Duties.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[Duties.id == find_one_duties.id],
)
if access_authorized_duties.count:
data_dict = data.excluded_dump()
updated_duties = find_one_duties.update(**data_dict)
Duties.save()
return {
"completed": True,
"message": "Update Duties record",
"data": updated_duties,
}
return {
"completed": False,
"message": "Update Duties record failed",
"data": {},
}
class DutiesPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"ca81c6d1-975a-4288-a27b-1069aea84afe": "duties_patch",
}
__event_validation__ = {"ca81c6d1-975a-4288-a27b-1069aea84afe": None}
@classmethod
def duties_patch(
cls,
duties_uu_id: str,
data: PatchRecord,
token_dict: EmployeeTokenObject,
):
find_one_duties = Duties.find_one_or_abort(uu_id=duties_uu_id)
access_authorized_duties = Duties.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[Duties.id == find_one_duties.id],
)
if access_authorized_duties.count:
action = data.excluded_dump()
find_one_duties.active = bool(action.get("active", find_one_duties.active))
find_one_duties.is_confirmed = bool(
action.get("confirm", find_one_duties.is_confirmed)
)
find_one_duties.deleted = bool(
action.get("delete", find_one_duties.deleted)
)
find_one_duties.save()
return {
"completed": True,
"message": "Patch Duties record completed",
"data": find_one_duties.get_dict(),
}
return {
"completed": False,
"message": "Patch Duties record failed",
"data": {},
}
DutiesListEventMethod = DutiesListEventMethods(
action=ActionsSchema(endpoint="/duties/list")
)
DutiesGetByUUIDEventMethod = DutiesGetByUUIDEventMethods(
action=ActionsSchema(endpoint="/duties/get_by_duty_uuid")
)
DutiesCreateEventMethod = DutiesCreateEventMethods(
action=ActionsSchema(endpoint="/duties/create")
)
DutiesUpdateEventMethod = DutiesUpdateEventMethods(
action=ActionsSchema(endpoint="/duties/update")
)
DutiesPatchEventMethod = DutiesPatchEventMethods(
action=ActionsSchema(endpoint="/duties/patch")
)

163
api_events/events/company/company_duty.py Normal file
View File

@@ -0,0 +1,163 @@
from fastapi import status
from fastapi.responses import JSONResponse
from api_validations.validations_request import (
InsertCompanyDuty,
PatchRecord,
ListOptions,
)
from databases import Duty
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class DutyListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"23231c7d-4ff2-4b39-b71b-ea350d31fadf": "duty_list",
}
__event_validation__ = {"23231c7d-4ff2-4b39-b71b-ea350d31fadf": None}
@classmethod
def duty_list(
cls,
list_options: ListOptions,
token_dict: EmployeeTokenObject,
):
Duty.filter_attr = list_options
records = Duty.filter_all(system=True)
return AlchemyJsonResponse(
completed=True,
message="Duty list is brought successfully",
result=records,
)
class DutyCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"c6ea200e-fa17-4393-b390-37f5337c9c65": "duty_create",
}
__event_validation__ = {"c6ea200e-fa17-4393-b390-37f5337c9c65": InsertCompanyDuty}
@classmethod
def duty_create(
cls,
data: InsertCompanyDuty,
token_dict: EmployeeTokenObject,
):
created_duty = Duty.find_or_create(**data.excluded_dump())
Duty.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Company record",
"data": created_duty.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class DutyUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"ad952647-bcf8-482d-9e05-b2ee8086483f": "duty_update",
}
__event_validation__ = {"ad952647-bcf8-482d-9e05-b2ee8086483f": None}
@classmethod
def duty_update(
cls,
company_uu_id: str,
data,
token_dict: EmployeeTokenObject,
):
find_one_company = Duty.find_one_or_abort(uu_id=company_uu_id)
access_authorized_company = Duty.select_action(
duty_id=getattr(token_dict, "duty_id", 5), # ?
filter_expr=[Duty.id == token_dict.get("")],
)
if access_authorized_company.count:
data_dict = data.excluded_dump()
updated_company = find_one_company.update(**data_dict)
Duty.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Company record",
"data": updated_company,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update Company record", "data": {}},
status_code=status.HTTP_200_OK,
)
class DutyPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"d5c7b5c4-7b4e-4d5b-8e3b-2b9c5f5d0c0b": "duty_patch",
}
__event_validation__ = {"d5c7b5c4-7b4e-4d5b-8e3b-2b9c5f5d0c0b": None}
@classmethod
def duty_patch(
cls,
company_uu_id: str,
data: PatchRecord,
token_dict: EmployeeTokenObject,
):
find_one_company = Duty.find_one_or_abort(uu_id=company_uu_id)
access_authorized_company = Duty.select_action(
duty_id=getattr(token_dict, "duty_id", 5),
filter_expr=[Duty.id == find_one_company.id],
)
if access_authorized_company.count:
action = data.excluded_dump()
find_one_company.active = bool(
action.get("active", find_one_company.active)
)
find_one_company.is_confirmed = bool(
action.get("confirm", find_one_company.is_confirmed)
)
find_one_company.deleted = bool(
action.get("delete", find_one_company.deleted)
)
find_one_company.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch Company record completed",
"data": find_one_company.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Company record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
DutyListEventMethod = DutyListEventMethods(action=ActionsSchema(endpoint="/duty/list"))
DutyCreateEventMethod = DutyCreateEventMethods(
action=ActionsSchema(endpoint="/duty/create")
)
DutyUpdateEventMethod = DutyUpdateEventMethods(
action=ActionsSchema(endpoint="/duty/update")
)
DutyPatchEventMethod = DutyPatchEventMethods(
action=ActionsSchema(endpoint="/duty/patch")
)

343
api_events/events/company/company_employee.py Normal file
View File

@@ -0,0 +1,343 @@
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from api_library.date_time_actions.date_functions import system_arrow
from api_validations.validations_request import (
InsertEmployees,
BindEmployees2People,
PatchRecord,
ListOptions,
)
from databases import Employees, Staff, People, EmployeeHistory
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class EmployeeListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"cb677c92-6b05-4122-af5c-12766fae8095": "employee_list",
}
__event_validation__ = {"cb677c92-6b05-4122-af5c-12766fae8095": None}
@classmethod
def employee_list(
cls,
list_options: ListOptions,
token_dict: EmployeeTokenObject,
):
employees_staff = Staff.filter_all(
Staff.duties_id.in_(token_dict.duty_id_list),
).data
Employees.filter_attr = list_options
records = Employees.filter_all(
Employees.staff_id.in_([staff.id for staff in employees_staff]),
)
return AlchemyJsonResponse(
completed=True,
message="Employee are listed successfully",
result=records,
)
class EmployeeCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"1e1632c3-bb0e-46a5-8e45-da3f6d88ac43": "employee_create",
}
__event_validation__ = {"1e1632c3-bb0e-46a5-8e45-da3f6d88ac43": InsertEmployees}
@classmethod
def employee_create(
cls,
data: InsertEmployees,
token_dict: EmployeeTokenObject,
):
person = People.filter_one(
People.uu_id == data.people_uu_id,
).data
staff = Staff.filter_one(
Staff.uu_id == data.staff_uu_id,
).data
if not staff:
return JSONResponse(
content={
"completed": False,
"message": "Staff record not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
created_employee = Employees.find_or_create(
staff_id=staff.id,
staff_uu_id=str(staff.uu_id),
people_id=person.id if person else None,
people_uu_id=str(person.uu_id) if person else None,
)
Employees.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Employee record",
"data": created_employee.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class EmployeeUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"9015a076-d78c-463d-9474-ea343a125fb8": "employee_update",
}
__event_validation__ = {"9015a076-d78c-463d-9474-ea343a125fb8": None}
@classmethod
def employee_update(
cls,
employee_uu_id: str,
data: PatchRecord,
token_dict: EmployeeTokenObject,
):
find_one_employee = Employees.filter_one(
Employees.uu_id == employee_uu_id,
).data
access_authorized_employee = Employees.select_action(
employee_id=getattr(token_dict, "employee_id", 5),
filter_expr=[Employees.id == token_dict.get("")],
)
if access_authorized_employee.count:
data_dict = data.excluded_dump()
updated_employee = find_one_employee.update(**data_dict)
Employees.save()
return JSONResponse(
content={
"completed": True,
"message": "Update Employee record",
"data": updated_employee,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Update Employee record",
"data": {},
},
status_code=status.HTTP_200_OK,
)
class EmployeePatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"8446ce0b-9310-4b9f-93e2-61f56a9dacd1": "employee_patch",
}
__event_validation__ = {"8446ce0b-9310-4b9f-93e2-61f56a9dacd1": None}
@classmethod
def employee_patch(
cls,
employee_uu_id: str,
data: PatchRecord,
token_dict: EmployeeTokenObject,
):
find_one_employee = Employees.find_one_or_abort(uu_id=employee_uu_id)
access_authorized_employee = Employees.select_action(
employee_id=getattr(token_dict, "employee_id", 5),
filter_expr=[Employees.id == find_one_employee.id],
)
if access_authorized_employee.count:
action = data.excluded_dump()
find_one_employee.active = bool(
action.get("active", find_one_employee.active)
)
find_one_employee.is_confirmed = bool(
action.get("confirm", find_one_employee.is_confirmed)
)
find_one_employee.deleted = bool(
action.get("delete", find_one_employee.deleted)
)
return JSONResponse(
content={
"completed": True,
"message": "Patch Employee record completed",
"data": find_one_employee.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch Employee record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
class Employee2PeopleEmployEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"5eb04057-7a74-4555-b2c6-14eda32dae89": "company_employee_employ",
}
__event_validation__ = {
"5eb04057-7a74-4555-b2c6-14eda32dae89": BindEmployees2People
}
@classmethod
def company_employee_employ(
cls,
data: BindEmployees2People,
token_dict: EmployeeTokenObject,
):
selected_staff = Staff.filter_one(
Staff.uu_id == data.staff_uu_id,
).data
selected_people = People.filter_one(People.uu_id == data.people_uu_id).data
if not selected_staff:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Staff record not found",
)
if not selected_people:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="People record not found",
)
find_one_employee = Employees.filter_all(
Employees.staff_id == selected_staff.id,
).data
staff_name_upper = str(selected_staff.staff_name).upper()
if not find_one_employee:
return JSONResponse(
content={
"completed": False,
"message": f"There is no space for new Employee for given staff : {staff_name_upper}",
"data": {},
},
status_code=status.HTTP_406_NOT_ACCEPTABLE,
)
if not data.expiry_starts:
data.expiry_starts = str(system_arrow.now())
data.expiry_starts = str(system_arrow.get(str(data.expiry_starts)))
find_one_employee = find_one_employee.update(
people_id=selected_people.id,
expiry_starts=data.expiry_starts,
**token_dict.update_creds,
)
Employees.save()
return JSONResponse(
content={
"completed": True,
"message": "Get Employee to People record",
"data": find_one_employee.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class Employee2PeopleFireEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"caf914fa-0899-4b0b-a85a-3d40fdaa06a5": "company_employee_fire",
}
__event_validation__ = {
"caf914fa-0899-4b0b-a85a-3d40fdaa06a5": BindEmployees2People
}
@classmethod
def company_employee_fire(
cls,
data: BindEmployees2People,
token_dict: EmployeeTokenObject,
):
selected_people = People.filter_one(
People.uu_id == data.people_uu_id,
).data
if not selected_people:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="People record not found",
)
find_one_employee: Employees = Employees.filter_one(
Employees.people_id == selected_people.id,
).data
if not find_one_employee:
return JSONResponse(
content={
"completed": False,
"message": "Employee record not found for given People",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
find_one_employee = find_one_employee.update(
people_id=None, **token_dict.update_creds
)
if not find_one_employee.people_id:
employee_history = EmployeeHistory.find_or_create(
staff_id=find_one_employee.staff_id,
expiry_ends=data.expiry_ends,
people_id=selected_people.id,
created_by_id=find_one_employee.created_by_id,
updated_by_id=find_one_employee.updated_by_id,
confirmed_by_id=find_one_employee.confirmed_by_id,
replication_id=find_one_employee.replication_id,
created_by=find_one_employee.created_by,
updated_by=find_one_employee.updated_by,
confirmed_by=find_one_employee.confirmed_by,
active=find_one_employee.active,
is_confirmed=find_one_employee.is_confirmed,
deleted=find_one_employee.deleted,
expiry_starts=find_one_employee.expiry_starts,
is_notification_send=find_one_employee.is_notification_send,
cryp_uu_id=find_one_employee.cryp_uu_id,
)
Employees.save()
return JSONResponse(
content={
"completed": True,
"message": "Employee is fired from Staff",
"data": find_one_employee.get_dict(),
},
status_code=status.HTTP_200_OK,
)
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Employee record not found for given People",
)
EmployeeListEventMethod = EmployeeListEventMethods(
action=ActionsSchema(endpoint="/employee/list")
)
EmployeeCreateEventMethod = EmployeeCreateEventMethods(
action=ActionsSchema(endpoint="/employee/create")
)
EmployeeUpdateEventMethod = EmployeeUpdateEventMethods(
action=ActionsSchema(endpoint="/employee/update")
)
EmployeePatchEventMethod = EmployeePatchEventMethods(
action=ActionsSchema(endpoint="/employee/patch")
)
Employee2PeopleEmployEventMethod = Employee2PeopleEmployEventMethods(
action=ActionsSchema(endpoint="/employee/employ")
)
Employee2PeopleFireEventMethod = Employee2PeopleFireEventMethods(
action=ActionsSchema(endpoint="/employee/fire")
)

156
api_events/events/company/company_staff.py Normal file
View File

@@ -0,0 +1,156 @@
from fastapi import status
from fastapi.responses import JSONResponse
from fastapi.exceptions import HTTPException
from api_validations.validations_request import (
InsertStaff,
SelectStaff,
PatchRecord,
ListOptions,
)
from databases import Staff, Duties
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject
from api_validations.core_response import AlchemyJsonResponse
class StaffListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"8984a519-99bf-4f25-8f34-2e1aebba468c": "staff_list",
}
__event_validation__ = {"8984a519-99bf-4f25-8f34-2e1aebba468c": None}
@classmethod
def staff_list(cls, list_options: ListOptions, token_dict: EmployeeTokenObject):
Staff.filter_attr = list_options
records = Staff.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Staff are listed successfully",
result=records,
)
class StaffCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"8f619257-19fd-404f-b713-7392c588dc36": "staff_create",
}
__event_validation__ = {"8f619257-19fd-404f-b713-7392c588dc36": InsertStaff}
@classmethod
def staff_create(cls, data: InsertStaff, token_dict: EmployeeTokenObject):
data_dict = data.excluded_dump()
duties = Duties.filter_one(
Duties.uu_id == data.duties_uu_id,
).data
if not duties:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Duties not found",
)
data_dict["duties_id"] = duties.id
created_duty = Staff.find_or_create(**data_dict)
Staff.save()
return JSONResponse(
content={
"completed": True,
"message": "Create Staff record",
"data": created_duty.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class StaffGetByUUIDEventMethods(MethodToEvent):
event_type = "GET"
__event_keys__ = {
"7724cfbb-c0ee-4261-959b-61b84e88a34f": "staff_get_by_uu_id",
}
__event_validation__ = {"7724cfbb-c0ee-4261-959b-61b84e88a34f": SelectStaff}
@classmethod
def staff_get_by_uu_id(cls, data: SelectStaff, token_dict: EmployeeTokenObject):
if data.duties_uu_id:
duties_id = Duties.filter_one(
Duties.uu_id == data.duties_uu_id,
).data
selected_staffs = Staff.filter_all(Staff.duties_id == duties_id.id)
return JSONResponse(
content={
"completed": True,
"message": "Staff records are listed",
"data": [
selected_staff.get_dict()
for selected_staff in selected_staffs.data
],
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Get Staff record failed",
"data": {},
},
status_code=status.HTTP_202_ACCEPTED,
)
class StaffUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"5329f35d-ff9d-4656-a831-ba9c8204e483": "staff_update",
}
__event_validation__ = {"5329f35d-ff9d-4656-a831-ba9c8204e483": None}
@classmethod
def staff_update(cls, staff_uu_id: str, data, token_dict: EmployeeTokenObject):
return JSONResponse(
content={"completed": True, "message": "Update Staff record", "data": {}},
status_code=status.HTTP_200_OK,
)
class StaffPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"b1cd7c0a-1458-472b-894f-3adc857c8512": "staff_patch",
}
__event_validation__ = {"b1cd7c0a-1458-472b-894f-3adc857c8512": None}
@classmethod
def staff_patch(
cls, staff_uu_id: str, data: PatchRecord, token_dict: EmployeeTokenObject
):
return JSONResponse(
content={
"completed": False,
"message": "Patch Staff record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
StaffListEventMethod = StaffListEventMethods(
action=ActionsSchema(endpoint="/staff/list")
)
StaffCreateEventMethod = StaffCreateEventMethods(
action=ActionsSchema(endpoint="/staff/create")
)
StaffGetByUUIDEventMethod = StaffGetByUUIDEventMethods(
action=ActionsSchema(endpoint="/staff/get_by_duties_uu_id")
)
StaffUpdateEventMethod = StaffUpdateEventMethods(
action=ActionsSchema(endpoint="/staff/update")
)
StaffPatchEventMethod = StaffPatchEventMethods(
action=ActionsSchema(endpoint="/staff/patch")
)

0
api_events/events/decision_book/__init__.py Normal file
View File

229
api_events/events/decision_book/decision_book_decision_book.py Normal file
View File

@@ -0,0 +1,229 @@
import typing
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from databases import (
Build,
BuildDecisionBook,
Companies,
OccupantTypes,
)
from api_validations.validations_request import (
InsertDecisionBook,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_library.date_time_actions.date_functions import system_arrow
class DecisionBookListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"5c10d6ae-2aee-4243-a7c3-94826d028d13": "building_decision_book_list",
}
__event_validation__ = {"5c10d6ae-2aee-4243-a7c3-94826d028d13": None}
@classmethod
def building_decision_book_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
records = []
if isinstance(token_dict, EmployeeTokenObject):
build_id_list_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
build_id_list = build_id_list_query.all()
if not build_id_list:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"No building is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
)
BuildDecisionBook.filter_attr = list_options
records = BuildDecisionBook.filter_all(
BuildDecisionBook.build_id.in_([build.id for build in build_id_list]),
)
elif isinstance(token_dict, OccupantTokenObject):
BuildDecisionBook.filter_attr = list_options
records = BuildDecisionBook.filter_all(
BuildDecisionBook.build_id == token_dict.selected_occupant.build_id,
)
return AlchemyJsonResponse(
completed=True,
message="DecisionBook are listed successfully",
result=records,
)
class DecisionBookCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"0a68cb44-271a-4829-81f6-cd99a5f326b4": "building_decision_book_create",
}
__event_validation__ = {"0a68cb44-271a-4829-81f6-cd99a5f326b4": InsertDecisionBook}
@classmethod
def building_decision_book_create(
cls,
data: InsertDecisionBook,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
data_dict = data.excluded_dump()
if isinstance(token_dict, EmployeeTokenObject):
Build.pre_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id
)
build = Build.filter_one(
Build.uu_id == data.build_uu_id,
).data
if not build:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Emloyee UUID {token_dict.selected_company.employee_uu_id} has no build with given UUID {data_dict.get('build_uu_id')}",
)
data_dict["build_id"] = build.id
if data.resp_company_uu_id:
Companies.pre_query = Companies.select_action(
duty_id_list=[
token_dict.selected_company.duty_id,
token_dict.selected_company.bulk_duties_id,
]
)
company = Companies.filter_one(
Companies.uu_id == data.resp_company_uu_id,
).data
if not company:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Duty UUID {token_dict.selected_company.duty_uu_id} has no company with given UUID {data_dict.get('resp_company_uu_id')}",
)
data_dict["resp_company_id"] = company.id
data_dict["resp_company_uu_id"] = str(company.uu_id)
decision_period_date = system_arrow.get(build.decision_period_date)
data_dict["expiry_starts"] = system_arrow.get(
system_arrow.now().date().year,
int(decision_period_date.date().month),
int(decision_period_date.date().day),
)
data_dict["expiry_ends"] = str(
data_dict["expiry_starts"].shift(years=1, days=-1)
)
data_dict["expiry_starts"] = str(data_dict["expiry_starts"])
build_decision_book = BuildDecisionBook.find_or_create(**data_dict)
build_decision_book.save_and_confirm()
return JSONResponse(
status_code=status.HTTP_200_OK,
content=dict(
message="Decision Book has created",
completed=True,
data=build_decision_book.get_dict(),
),
)
elif isinstance(token_dict, OccupantTokenObject):
occupant_manager = OccupantTypes.filter_by_one(
occupant_category_type="BU", occupant_code="BU-MNG"
).data
if not token_dict.selected_occupant.occupant_type_id == occupant_manager.id:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only Build Manager can create decision book",
)
occupant_build = Build.filter_one(
Build.id == token_dict.selected_occupant.build_id,
).data
occupant_company = Companies.filter_one(
Companies.id == token_dict.selected_occupant.responsible_company_id,
).data
data_dict["build_id"] = occupant_build.id
data_dict["build_uu_id"] = str(occupant_build.uu_id)
data_dict["resp_company_id"] = occupant_company.id
data_dict["resp_company_uu_id"] = str(occupant_company.uu_id)
decision_period_date = system_arrow.get(occupant_build.decision_period_date)
data_dict["expiry_starts"] = system_arrow.get(
system_arrow.now().date().year,
int(decision_period_date.date().month),
int(decision_period_date.date().day),
)
data_dict["expiry_ends"] = str(
data_dict["expiry_starts"].shift(years=1, days=-1)
)
data_dict["expiry_starts"] = str(data_dict["expiry_starts"])
build_decision_book = BuildDecisionBook.find_or_create(**data_dict)
build_decision_book.save()
build_decision_book.update(is_confirmed=True)
build_decision_book.save()
return JSONResponse(
status_code=status.HTTP_200_OK,
content=dict(
message="Decision Book has created",
completed=True,
data=build_decision_book.get_dict(),
),
)
class DecisionBookUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"6bc7035c-3b53-4c0a-8cc9-1ec9c6af1e29": "building_decision_book_update",
}
__event_validation__ = {"6bc7035c-3b53-4c0a-8cc9-1ec9c6af1e29": None}
@classmethod
def building_decision_book_update(cls, data: InsertDecisionBook, token_dict: dict):
return
class DecisionBookPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"7b58ed84-9a65-4588-994d-30df8366b050": "building_decision_book_patch",
}
__event_validation__ = {"7b58ed84-9a65-4588-994d-30df8366b050": None}
@classmethod
def building_decision_book_patch(cls, data: InsertDecisionBook, token_dict: dict):
return
class DecisionBookApprovalEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"fc745142-3437-4ca2-89fa-c5a3e2b5c6c2": "building_decision_book_approval",
}
__event_validation__ = {"fc745142-3437-4ca2-89fa-c5a3e2b5c6c2": None}
@classmethod
def building_decision_book_approval(cls, data, token_dict):
return
DecisionBookListEventMethod = DecisionBookListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/list")
)
DecisionBookCreateEventMethod = DecisionBookCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/create")
)
DecisionBookUpdateEventMethod = DecisionBookUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/update")
)
DecisionBookPatchEventMethod = DecisionBookPatchEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/patch")
)
DecisionBookApprovalEventMethod = DecisionBookApprovalEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/approval")
)

570
api_events/events/decision_book/decision_book_decision_book_items.py Normal file
View File

@@ -0,0 +1,570 @@
import typing
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from api_events.events.events.events_bind_services import (
ServiceBindOccupantEventMethods,
)
from databases import (
Build,
BuildParts,
BuildDecisionBook,
BuildDecisionBookItems,
BuildDecisionBookPerson,
BuildDecisionBookPayments,
BuildDecisionBookProjects,
BuildDecisionBookProjectPerson,
ApiEnumDropdown,
OccupantTypes,
Companies,
BuildLivingSpace,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_library.date_time_actions.date_functions import system_arrow, client_arrow
from api_validations.validations_request import (
InsertBuildDecisionBookItems,
ListOptions,
ListDecisionBook,
)
from databases.sql_models.event.event import Services
class DecisionBookDecisionBookItemsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"eb36de59-8268-4d96-80b6-5d01c12bf0b1": "building_decision_book_items_list",
}
__event_validation__ = {"eb36de59-8268-4d96-80b6-5d01c12bf0b1": None}
@classmethod
def building_decision_book_items_list(
cls,
data: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
decision_book = BuildDecisionBook.filter_one(
BuildDecisionBook.uu_id == data.build_decision_book_uu_id,
).data
if not decision_book:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"No Decision Book is match with given UUID {data.build_decision_book_uu_id}",
)
if isinstance(token_dict, EmployeeTokenObject):
Build.pre_query = Build.select_action(
employee_id=token_dict.selected_company.employee_id,
filter_expr=[
Build.uu_id == str(decision_book.uu_id),
],
)
reachable_building = Build.filter_all()
if not reachable_building.data:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"No building is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
)
Companies.pre_query = Companies.select_action(
duty_id_list=[
token_dict.selected_company.duty_id,
token_dict.selected_company.bulk_duties_id,
],
filter_expr=[Companies.id == decision_book.resp_company_id],
)
reachable_companies = Companies.filter_all()
if not reachable_companies.data:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"No company is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
)
BuildDecisionBookItems.filter_attr = BuildDecisionBookItems.FilterModel(
**data.dump()
)
records = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.build_decision_book_id == decision_book.id
)
return AlchemyJsonResponse(
completed=True,
message="DecisionBook are listed successfully",
result=records,
)
# return JSONResponse(
# status_code=status.HTTP_200_OK,
# content=dict(
# total_count=records.count,
# count=len(records.data),
# message=f"Decision Book Items has found from given Decision Book UUID {data.build_decision_book_uu_id}",
# completed=True,
# data=[record.get_dict() for record in records.data],
# ),
# )
else:
# BuildDecisionBookItems.pre_query = BuildDecisionBookItems.select_action(
# occupant_id=token_dict.occupant_list["occupant_id"]
# )
# BuildDecisionBookItems.filter_attr = list_options
# records = BuildDecisionBookItems.filter_all(
# )
# return return_json_response_from_alchemy(response=records, pagination=list_options)
return
class DecisionBookDecisionBookItemsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"dce10509-0da5-46fb-af3c-a81d54d5481c": "building_decision_book_items_create",
}
__event_validation__ = {
"dce10509-0da5-46fb-af3c-a81d54d5481c": InsertBuildDecisionBookItems
}
@classmethod
def iterate_over_build_parts(
cls,
build_parts_list,
payment_types,
local_date,
end_date,
unit_price,
unit_type,
book_payment_dict,
unit_price_is_fixed,
):
start_date, payment_return_dict = local_date, {}
for build_part_single in build_parts_list:
local_date = start_date
while local_date.is_between(start_date, end_date, "[]"):
local_date = system_arrow.find_last_day_of_month(local_date)
payment_amount = unit_price
if not unit_price_is_fixed:
unit_amount = int(build_part_single.part_net_size)
payment_amount = abs(unit_price * float(unit_amount)) * -1
payment_amount = -1 * (
abs(payment_amount) + (50 - float(abs(payment_amount)) % 50)
)
created_book_payment = BuildDecisionBookPayments.find_or_create(
build_parts_id=build_part_single.id,
build_parts_uu_id=str(build_part_single.uu_id),
payment_amount=payment_amount,
payment_types_id=payment_types.id,
payment_types_uu_id=str(payment_types.uu_id),
process_date=str(local_date),
process_date_m=int(local_date.month),
process_date_y=int(local_date.year),
period_time=f"{local_date.year}-{str(local_date.month).zfill(2)}",
**book_payment_dict,
)
created_book_payment.save_and_confirm()
local_date = local_date.shift(days=2)
part_key = str(build_part_single.due_part_key).upper()
if part_key not in payment_return_dict:
payment_return_dict[part_key] = payment_amount
return payment_return_dict
@classmethod
def create_payment_records_for_each_build_part(
cls,
data_info_type,
build_id,
unit_price,
unit_type,
decision_book,
decision_book_item,
unit_price_is_fixed,
currency,
debit_start_date: str = None,
debit_end_date: str = None,
):
build_parts_list = BuildParts.filter_all(
BuildParts.human_livable == True,
BuildParts.build_id == build_id,
)
print("data_info_type.key", data_info_type.key)
book_payment_dict = dict(
payment_plan_time_periods=str(data_info_type.key),
build_decision_book_item_id=decision_book_item.id,
build_decision_book_item_uu_id=str(decision_book_item.uu_id),
currency=currency,
)
payment_types = ApiEnumDropdown.get_debit_search(search_debit="DT-D")
if data_info_type.key == "BDT-D":
local_date = system_arrow.get(
system_arrow.get(decision_book.expiry_starts).date()
)
end_date = system_arrow.get(
system_arrow.get(decision_book.expiry_ends).date()
)
payment_return_dict = cls.iterate_over_build_parts(
build_parts_list=build_parts_list.data,
payment_types=payment_types,
local_date=local_date,
end_date=end_date,
unit_price=unit_price,
unit_type=unit_type,
unit_price_is_fixed=unit_price_is_fixed,
book_payment_dict=book_payment_dict,
)
return payment_return_dict
elif data_info_type.key == "BDT-A":
local_date = system_arrow.get(system_arrow.get(debit_start_date).date())
end_date = system_arrow.get(system_arrow.get(debit_end_date).date())
payment_return_dict = cls.iterate_over_build_parts(
build_parts_list=build_parts_list.data,
payment_types=payment_types,
local_date=local_date,
end_date=end_date,
unit_price=unit_price,
unit_type=unit_type,
unit_price_is_fixed=unit_price_is_fixed,
book_payment_dict=book_payment_dict,
)
return payment_return_dict
elif data_info_type.key == "BDT-R" or data_info_type.key == "BDT-L":
local_date = system_arrow.get(system_arrow.get(debit_start_date).date())
end_date = system_arrow.get(system_arrow.get(debit_end_date).date())
decision_date = system_arrow.get(decision_book.expiry_starts).date()
meeting_date = system_arrow.get(decision_book.meeting_date).date()
already_book_projects = BuildDecisionBookProjects.filter_all(
BuildDecisionBookProjects.build_decision_book_id == decision_book.id,
BuildDecisionBookProjects.project_type
== f"{decision_book.decision_type}_{data_info_type.key}",
system=True,
)
management_room = BuildParts.filter_one(
BuildParts.build_id == build_id, BuildParts.part_no == 0, system=True
).data
occupant_man = OccupantTypes.filter_by_one(
system=True, occupant_code="MT-VPR", occupant_category_type="MT"
).data
manager_living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.build_parts_id == management_room.id,
BuildLivingSpace.occupant_type == occupant_man.id,
).data
if not manager_living_space:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"{occupant_man.occupant_description} Living Space is not found. Check manager living space and try again",
)
already_book_project_count = already_book_projects.count + 1
book_project_dict = dict(
project_no=f"{data_info_type.key}_{decision_date.year}_{already_book_project_count}",
project_name=f"{str(meeting_date)}_{decision_book.decision_type} Project {already_book_projects.count + 1}",
project_start_date=str(local_date),
project_stop_date=str(end_date),
project_type=f"{decision_book.decision_type}_{data_info_type.key}",
project_note=str(decision_book_item.item_comment),
build_decision_book_id=decision_book.id,
build_decision_book_uu_id=str(decision_book.uu_id),
build_decision_book_item_id=decision_book_item.id,
build_decision_book_item_uu_id=str(decision_book_item.uu_id),
project_response_living_space_id=manager_living_space.id,
project_response_living_space_uu_id=str(manager_living_space.uu_id),
)
book_project_created = BuildDecisionBookProjects.find_or_create(
**book_project_dict
)
book_project_created.save_and_confirm()
print("book_project_created", book_project_created)
item_comment_at_database = decision_book_item.item_comment
decision_book_item.update(
item_comment=f"{book_project_created.project_no}_{book_project_created.project_name} "
f"is assigned to {occupant_man.occupant_description} | {item_comment_at_database}"
)
decision_book_item.save_and_confirm()
project_lead = OccupantTypes.filter_by_one(
system=True, occupant_code="PRJ-LDR", occupant_category_type="PRJ"
).data
build_new_president = OccupantTypes.filter_by_one(
system=True, occupant_code="MT-VPR", occupant_category_type="MT"
).data
new_president = BuildLivingSpace.filter_one(
BuildLivingSpace.occupant_type == build_new_president.id,
BuildLivingSpace.build_parts_id == management_room.id,
).data
project_leader = BuildLivingSpace.filter_one(
BuildLivingSpace.occupant_type == project_lead.id,
BuildLivingSpace.build_parts_id == management_room.id,
BuildLivingSpace.person_id == new_president.person_id,
).data
if not project_leader:
project_leader = BuildLivingSpace.find_or_create(
person_id=new_president.person_id,
person_uu_id=str(new_president.person_uu_id),
build_parts_id=management_room.id,
build_parts_uu_id=str(management_room.uu_id),
occupant_type=project_lead.id,
occupant_type_uu_id=str(project_lead.uu_id),
)
project_leader.save_and_confirm()
related_service = Services.filter_by_one(
system=True,
related_responsibility=project_lead.occupant_code,
).data
ServiceBindOccupantEventMethods.bind_services_occupant_system(
service_id=related_service.id,
build_living_space_id=project_leader.id,
)
project_person = BuildDecisionBookProjectPerson.find_or_create(
build_decision_book_project_id=book_project_created.id,
build_decision_book_project_uu_id=str(book_project_created.uu_id),
living_space_id=project_leader.id,
living_space_uu_id=str(project_leader.uu_id),
)
project_person.save_and_confirm()
book_project_created.update(
project_response_living_space_id=project_leader.id,
project_response_living_space_uu_id=str(project_leader.uu_id),
)
book_project_created.save()
return book_project_created
elif data_info_type.key == "BDT-S":
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="BDT-S is not implemented yet. Check info type and try again",
)
elif data_info_type.key == "BDT-I":
return
else:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Payment Info Type is not valid. Check payment type and try again",
)
@classmethod
def building_decision_book_items_create(
cls,
data: InsertBuildDecisionBookItems,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="No employee can reach this event. An notification is send to admin about event registration",
)
elif isinstance(token_dict, OccupantTokenObject):
data_dict = data.dump()
occupant_wrt = OccupantTypes.filter_by_one(
system=True, occupant_code="MT-WRT", occupant_category_type="MT"
).data
if token_dict.selected_occupant.occupant_type_id != occupant_wrt.id:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Only WRITER can create decision book item. Check your occupant type and try again",
)
decision_book_person = BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.token == data.token,
).data
decision_book = BuildDecisionBook.filter_one(
BuildDecisionBook.id == decision_book_person.build_decision_book_id,
).data
book_items = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.build_decision_book_id == decision_book.id,
system=True,
)
if int(book_items.count) < 3:
BuildDecisionBookItems.check_meeting_is_valid_to_start_add_attendance(
decision_book=decision_book,
token_dict=token_dict,
)
book_items = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.build_decision_book_id == decision_book.id,
system=True,
)
data_dict["item_order"] = int(book_items.count) + 1
data_dict["build_decision_book_id"] = decision_book.id
data_dict["build_decision_book_uu_id"] = str(decision_book.uu_id)
data_info_type = ApiEnumDropdown.filter_by_one(
system=True,
enum_class="BuildDuesTypes",
key="BDT-I",
).data
data_info_types = ApiEnumDropdown.due_type_search()
for info_type in data_info_types:
if str(info_type.uu_id) == data_dict["info_type_uu_id"]:
data_info_type = info_type
break
row_is_debit = str(data_info_type.key).upper() in ["BDT-A", "BDT-D"]
row_is_project = str(data_info_type.key).upper() in [
"BDT-R",
"BDT-L",
"BDT-S",
]
debit_dates_required = (
not data_dict["debit_start_date"] or not data_dict["debit_end_date"]
)
if row_is_project and debit_dates_required:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Debit Start Date and Debit End Date is required for this payment type. "
"Check debit start date and debit end date and try again",
)
data_dict["info_type_id"] = data_info_type.id
data_dict["info_type_uu_id"] = str(data_info_type.uu_id)
unit_price, unit_type = float(data_dict["unit_price"]), str(
data_dict["unit_type"]
)
debit_start_date, debit_end_date = (
data_dict["debit_start_date"],
data_dict["debit_end_date"],
)
currency = data_dict["currency"]
del (
data_dict["token"],
data_dict["unit_price"],
data_dict["unit_type"],
data_dict["unit_price_is_fixed"],
data_dict["debit_start_date"],
data_dict["debit_end_date"],
data_dict["currency"],
)
new_decision_book_item = BuildDecisionBookItems.find_or_create(**data_dict)
new_decision_book_item.save_and_confirm()
print("new_decision_book_item", new_decision_book_item)
if created_payment_records_dict := cls.create_payment_records_for_each_build_part(
data_info_type=data_info_type,
build_id=decision_book.build_id,
unit_price=unit_price,
unit_type=unit_type.upper(),
decision_book=decision_book,
decision_book_item=new_decision_book_item,
unit_price_is_fixed=data.unit_price_is_fixed,
debit_start_date=debit_start_date,
debit_end_date=debit_end_date,
currency=currency,
):
if row_is_debit:
if data_info_type.key == "BDT-D":
item_comment = "Regular Payment Plan : "
else:
item_comment = "Additional Payment Plan : "
for key, value in dict(
sorted(
created_payment_records_dict.items(),
key=lambda x: x[1],
reverse=True,
)
).items():
item_comment += f" {key} | {abs(float(value))} {currency}, "
item_comment = item_comment[:-2]
new_decision_book_item.update(item_comment=item_comment)
new_decision_book_item.update(is_payment_created=True)
elif row_is_project:
project_no = str(created_payment_records_dict.project_no)
item_comment = (
f"{data.item_comment} | @ Project is created no : {project_no}."
)
new_decision_book_item.update(item_comment=item_comment)
new_decision_book_item.update(is_payment_created=True)
new_decision_book_item.save_and_confirm()
return JSONResponse(
status_code=status.HTTP_200_OK,
content=dict(
message=f"Decision Book Item has created for given Decision Book UUID {decision_book.uu_id}",
completed=True,
data=new_decision_book_item.get_dict(),
),
)
# raise HTTPException(
# status_code=status.HTTP_400_BAD_REQUEST,
# detail="Decision Book Item is not created. Check info type and info no and try again. Unique constraint index is implemented for info type and info no",
# )
class DecisionBookDecisionBookItemsUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"f0fdfe1b-806b-4175-ad50-a1a165c0dfb7": "building_decision_book_items_update",
}
__event_validation__ = {"f0fdfe1b-806b-4175-ad50-a1a165c0dfb7": None}
@classmethod
def building_decision_book_items_update(
cls,
data: InsertBuildDecisionBookItems,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
class DecisionBookDecisionBookItemsPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"42328809-b516-477b-82cc-2d6fadf28843": "building_decision_book_items_patch",
}
__event_validation__ = {"42328809-b516-477b-82cc-2d6fadf28843": None}
@classmethod
def building_decision_book_items_patch(
cls,
data: InsertBuildDecisionBookItems,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
DecisionBookDecisionBookItemsListEventMethod = (
DecisionBookDecisionBookItemsListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/items/list")
)
)
DecisionBookDecisionBookItemsCreateEventMethod = (
DecisionBookDecisionBookItemsCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/items/create")
)
)
DecisionBookDecisionBookItemsUpdateEventMethod = (
DecisionBookDecisionBookItemsUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/items/update")
)
)
DecisionBookDecisionBookItemsPatchEventMethod = (
DecisionBookDecisionBookItemsPatchEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/items/patch")
)
)
# if data.info_no is None:
# data_dict["info_no"] = data_dict["item_order"]
# elif data.occupant_types_uu_id:
# data_dict["info_type"] = None
# if occupant_type := OccupantTypes.find_one(
# uu_id=data.occupant_types_uu_id
# ):
# if (
# str(data.occupant_types_uu_id)
# in OccupantTypes.get_manager_occupant_type()
# ):
# if BuildDecisionBookItems.find_one(
# build_decision_book_id=decision_book.id,
# occupant_type=occupant_type.id,
# ):
# raise HTTPException(
# status_code=status.HTTP_400_BAD_REQUEST,
# detail="This Occupant Type is already exist for given Decision Book UUID. Check occupant type and try again",
# )
# data_dict["occupant_type"] = occupant_type.id
# data_dict["occupant_type_uu_id"] = str(occupant_type.uu_id)

105
api_events/events/decision_book/decision_book_decision_book_items_debits.py Normal file
View File

@@ -0,0 +1,105 @@
import typing
from databases import (
Build,
BuildParts,
BuildDecisionBook,
BuildDecisionBookItems,
BuildDecisionBookPerson,
BuildDecisionBookPayments,
BuildDecisionBookProjects,
BuildDecisionBookProjectPerson,
ApiEnumDropdown,
OccupantTypes,
Companies,
BuildLivingSpace,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_library.date_time_actions.date_functions import system_arrow, client_arrow
class DecisionBookDecisionBookItemsDebitsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"a1d2b1f6-9b8d-4f6b-8f4d-6b1f6a9d8b1a": "decision_book_decision_book_items_debits_list",
}
__event_validation__ = {"a1d2b1f6-9b8d-4f6b-8f4d-6b1f6a9d8b1a": None}
@classmethod
def decision_book_decision_book_items_debits_list(
cls,
decision_book_id: str,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
BuildDecisionBookItems.pre_query = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.decision_book_id == decision_book_id,
).query
BuildDecisionBookItems.filter_attr = None
records = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.decision_book_id == decision_book_id,
)
return AlchemyJsonResponse(
completed=True,
message="Decision Book Items Debits are listed",
result=records,
)
class DecisionBookDecisionBookItemsDebitsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"a1d2b1f6-9b8d-4f6b-8f4d-6b1f6a9d8b1a": "decision_book_decision_book_items_debits_create",
}
__event_validation__ = {"a1d2b1f6-9b8d-4f6b-8f4d-6b1f6a9d8b1a": None}
@classmethod
def decision_book_decision_book_items_debits_create(
cls,
decision_book_id: str,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
decision_book_items_debits: dict,
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_406_NOT_ACCEPTABLE,
detail="No employee can reach this event. An notification is send to admin about event registration",
)
decision_book_items_debits["decision_book_id"] = decision_book_id
decision_book_items_debits["created_at"] = system_arrow().datetime
decision_book_items_debits["created_by"] = token_dict.employee_id
decision_book_items_debits["updated_at"] = system_arrow().datetime
decision_book_items_debits["updated_by"] = token_dict.employee_id
decision_book_items_debits["is_active"] = True
decision_book_items_debits["is_confirmed"] = False
decision_book_items_debits["is_deleted"] = False
decision_book_items_debits["confirmed_at"] = None
decision_book_items_debits["confirmed_by"] = None
decision_book_items_debits["deleted_at"] = None
decision_book_items_debits["deleted_by"] = None
decision_book_items_debits["confirmed_at"] = None
decision_book_items_debits["confirmed_by"] = None
decision_book_items_debits["deleted_at"] = None
decision_book_items_debits["deleted_by"] = None
decision_book_items_debits["confirmed_at"] = None
decision_book_items_debits["confirmed_by"] = None
decision_book_items_debits["deleted_at"] = None
decision_book_items_debits["deleted_by"] = None
BuildDecisionBookItems.pre_query = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.decision_book_id == decision_book_id,
).query
BuildDecisionBookItems.filter_attr = None
records = BuildDecisionBookItems.filter_all(
BuildDecisionBookItems.decision_book_id == decision_book_id,
)
return AlchemyJsonResponse(
completed=True,
message="Decision Book Items Debits are listed",
result=records,
)

456
api_events/events/decision_book/decision_book_decision_book_person.py Normal file
View File

@@ -0,0 +1,456 @@
import typing
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from databases import (
BuildDecisionBook,
BuildDecisionBookPerson,
BuildDecisionBookInvitations,
Users,
BuildLivingSpace,
BuildParts,
BuildDecisionBookPersonOccupants,
People,
OccupantTypes,
)
from api_validations.validations_request import (
ListOptions,
RemoveDecisionBookPerson,
DecisionBookDecisionBookInvitationsAttend,
DecisionBookDecisionBookInvitationsUpdate,
DecisionBookDecisionBookInvitationsAssign,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class DecisionBookPersonListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"ea324dc0-3b08-4896-9040-7fa0401a176f": "building_decision_book_person_list",
}
__event_validation__ = {"ea324dc0-3b08-4896-9040-7fa0401a176f": None}
@classmethod
def building_decision_book_person_list(
cls,
data: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
class DecisionBookPersonAddEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"e346f720-880b-4b07-93d6-9ac76fbbaa33": "building_decision_book_person_add",
}
__event_validation__ = {
"e346f720-880b-4b07-93d6-9ac76fbbaa33": DecisionBookDecisionBookInvitationsUpdate
}
@classmethod
def building_decision_book_person_add(
cls,
data: DecisionBookDecisionBookInvitationsUpdate,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Employee cannot create decision book invitations",
)
elif isinstance(token_dict, OccupantTokenObject):
decision_book = BuildDecisionBook.filter_one(
BuildDecisionBook.uu_id == data.build_decision_book_uu_id,
).data
if not decision_book:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"No Decision Book is match with given UUID {data.build_decision_book_uu_id}",
)
manager_occupant_type = OccupantTypes.filter_by_one(
system=True, occupant_code="BU-MNG", occupant_category_type="BU"
).data
if (
not manager_occupant_type.uu_id
== token_dict.selected_occupant.occupant_type_uu_id
):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Only Build Manager can update the invitation",
)
assign_occupant_type = OccupantTypes.filter_by_one(
system=True,
uu_id=data.occupant_type_uu_id,
occupant_category_type="MT",
).data
if not assign_occupant_type:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Occupant type must be a Meeting Type {data.occupant_type_uu_id} is not a MT type occupant",
)
manger_book_person = BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.token == data.token,
BuildDecisionBookPerson.build_decision_book_uu_id
== data.build_decision_book_uu_id,
).data
if not manger_book_person:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Manager person not found. Please check token",
)
book_invite = BuildDecisionBookInvitations.filter_one(
BuildDecisionBookInvitations.id == manger_book_person.invite_id,
BuildDecisionBookInvitations.build_id
== token_dict.selected_occupant.build_id,
).data
if not book_invite:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Invitation not found. Please check token",
)
selected_book_person = BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.invite_id == book_invite.id,
BuildDecisionBookPerson.person_uu_id == data.person_uu_id,
).data
if not selected_book_person:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Selected person is not in the invitation list. Please check {data.person_uu_id}",
)
selected_book_person.update(
occupant_type=assign_occupant_type.id,
occupant_type_uu_id=str(assign_occupant_type.uu_id),
)
BuildDecisionBookPerson.save()
return JSONResponse(
status_code=status.HTTP_200_OK,
content={
"completed": True,
"message": "Invitation is updated",
"data": selected_book_person.get_dict(),
},
)
class DecisionBookPersonRemoveEventMethods(MethodToEvent):
event_type = "DELETE"
__event_keys__ = {
"30588869-04cd-48ea-ad00-0e4f8dd7f735": "building_decision_book_people_remove",
}
__event_validation__ = {
"30588869-04cd-48ea-ad00-0e4f8dd7f735": RemoveDecisionBookPerson
}
@classmethod
def building_decision_book_people_remove(
cls, data: RemoveDecisionBookPerson, token_dict: EmployeeTokenObject
):
return
class DecisionBookPersonAttendEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"bdcba521-0116-441c-ace1-84c5b68c86c7": "decision_book_invitations_attend",
}
__event_validation__ = {
"bdcba521-0116-441c-ace1-84c5b68c86c7": DecisionBookDecisionBookInvitationsAttend
}
@classmethod
def decision_book_invitations_attend(
cls,
data: DecisionBookDecisionBookInvitationsAttend,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Employee cannot create decision book invitations",
)
token_user = Users.filter_one(Users.id == token_dict.user_id).data
invitation_person = BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.token == data.token,
).data
if not invitation_person:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Invitation for the this specific user is not found. Please check token",
)
# is_token_valid = token_dict.person_id == invitation_person.person_id
# if not invitation_person.vicarious_person_id:
# if not invitation_person or not is_token_valid:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail=f"Invitation for the user {token_user.email} is not valid. Please check token",
# )
# todo check if vicarious person is valid
invitation = BuildDecisionBookInvitations.filter_one(
BuildDecisionBookInvitations.id == invitation_person.invite_id,
BuildDecisionBookInvitations.build_id
== token_dict.selected_occupant.build_id,
).data
if not invitation:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Invitation not found. Please check invitation uuid : {invitation.uu_id}",
)
invitation_person.update(
is_attending=bool(data.is_attend), vicarious_person_id=None
)
BuildDecisionBookInvitations.save()
return JSONResponse(
status_code=status.HTTP_200_OK,
content={
"completed": True,
"message": "Attendance is updated. Thank you for your response",
"data": {
"is_attending": bool(data.is_attend),
"user_uuid": str(token_user.uu_id),
"invitation_uuid": str(invitation.uu_id),
},
},
)
class DecisionBookPersonAssignOccupantEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"c0b65098-9c79-4212-b1d0-c7e7836cf141": "decision_book_invitations_assign_occupant",
}
__event_validation__ = {
"c0b65098-9c79-4212-b1d0-c7e7836cf141": DecisionBookDecisionBookInvitationsAssign
}
@classmethod
def decision_book_invitations_assign_occupant(
cls,
data: DecisionBookDecisionBookInvitationsAssign,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Employee cannot create decision book invitations",
)
book_person_manager = BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.token == data.token,
BuildDecisionBookPerson.build_living_space_id
== token_dict.selected_occupant.living_space_id,
).data
manager_occupant_type = OccupantTypes.filter_by_one(
system=True, occupant_code="BU-MNG", occupant_category_type="BU"
).data
book_person_manager.check_occupant_type(manager_occupant_type)
# supervisor_occupant_type = OccupantTypes.find_or_abort(occupant_code="BU-SPV", occupant_category_type="BU")
# book_person_supervisor.check_occupant_type(supervisor_occupant_type)
invitation = BuildDecisionBookInvitations.filter_one(
BuildDecisionBookInvitations.id == book_person_manager.invite_id,
BuildDecisionBookInvitations.build_id
== token_dict.selected_occupant.build_id,
).data
if not invitation:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Invitation not found. Please check token",
)
assign_occupant_type = OccupantTypes.filter_by_one(
system=True,
uu_id=data.occupant_type_uu_id,
).data
if not assign_occupant_type:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Occupant type must be a Meeting Type {data.occupant_type_uu_id} is not a MT type occupant",
)
build_parts_of_token = BuildParts.filter_all(
BuildParts.build_id == token_dict.selected_occupant.build_id,
).data
selected_living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.uu_id == data.build_living_space_uu_id,
BuildLivingSpace.build_parts_id.in_(
[build.id for build in build_parts_of_token]
),
).data
if not selected_living_space:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Person not found. Please check person uuid",
)
book_person_to_assign: BuildDecisionBookPerson = (
BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.build_living_space_id
== selected_living_space.id,
BuildDecisionBookPerson.invite_id == invitation.id,
).data
)
if not book_person_to_assign:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Person not found in the invitation list. Please check person uuid: {data.build_living_space_uu_id}",
)
if not book_person_to_assign.is_attending:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"Person is declined the invitation. This person is not attending the meeting. "
f"Please check person uuid: {data.build_living_space_uu_id}. Invite UUID: {invitation.uu_id}",
)
if assign_occupant_type.occupant_code in ("MT-PRS", "MT-WRT"):
occupant_type_unique = OccupantTypes.filter_by_one(
system=True,
occupant_code=assign_occupant_type.occupant_code,
occupant_category_type="MT",
).data
if assigned_book_person_occupant := BuildDecisionBookPersonOccupants.filter_one(
BuildDecisionBookPersonOccupants.invite_id == invitation.id,
BuildDecisionBookPersonOccupants.occupant_type_id
== occupant_type_unique.id,
).data:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"Only one person can be assigned to {assign_occupant_type.occupant_code} type"
f" {assigned_book_person_occupant.uu_id} is already assigned",
)
if assign_occupant_type.occupant_code == "BU-MNG":
person_occupant_manager = BuildDecisionBookPersonOccupants.filter_one(
BuildDecisionBookPersonOccupants.invite_id == invitation.id,
BuildDecisionBookPersonOccupants.occupant_type_id
== manager_occupant_type.id,
)
person_occupant_manager.query.delete()
book_person_to_assign.add_occupant_type(
occupant_type=assign_occupant_type,
build_living_space_id=selected_living_space.id,
)
BuildDecisionBookPersonOccupants.save()
return JSONResponse(
status_code=status.HTTP_200_OK,
content={
"completed": True,
"message": "Invitation is updated",
"data": book_person_to_assign.get_dict(),
},
)
DecisionBookPersonListEventMethod = DecisionBookPersonListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/people/list")
)
DecisionBookPersonAddEventMethod = DecisionBookPersonAddEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/people/add")
)
DecisionBookPersonRemoveEventMethod = DecisionBookPersonRemoveEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/people/remove")
)
DecisionBookPersonAttendEventMethod = DecisionBookPersonAttendEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/invitations/attend")
)
DecisionBookPersonAssignOccupantEventMethod = (
DecisionBookPersonAssignOccupantEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/invitations/assign")
)
)
# Build.pre_query = Build.select_action(
# employee_id=token_dict.selected_company.employee_id,
# filter_expr=[
# Build.id == decision_book.build_id,
# ],
# )
# reachable_building = Build.filter_all()
# if not reachable_building.data:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail=f"No building is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
# )
#
# Companies.pre_query = Companies.select_action(
# duty_id_list=[
# token_dict.selected_company.duty_id,
# token_dict.selected_company.bulk_duties_id,
# ],
# filter_expr=[Companies.id == decision_book.resp_company_id],
# )
# reachable_companies = Companies.filter_all()
# if not reachable_companies.data:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail=f"No company is match with given Employee UUID {token_dict.selected_company.employee_uu_id}",
# )
# person_to_add = People.find_one(uu_id=data.person_uu_id)
# if not person_to_add:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail=f"No person is match with given UUID {data.person_uu_id}",
# )
# management_typecode = ApiEnumDropdown.filter_all(
# ApiEnumDropdown.uu_id == data.management_typecode_uu_id,
# ApiEnumDropdown.enum_class.in_("BuildManagementType", "BuildDuesTypes"),
# )
# if not management_typecode.data:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail=f"No management type is match with given UUID {data.management_typecode_uu_id}",
# )
# condition_to_met = (
# data.management_typecode_uu_id
# in ApiEnumDropdown.get_management_type_codes_list()
# )
# any_type_already = BuildDecisionBookPerson.find_one(
# build_decision_book_id=decision_book.id,
# management_typecode=data.management_typecode_uu_id,
# )
# if condition_to_met and any_type_already:
# raise HTTPException(
# status_code=status.HTTP_400_BAD_REQUEST,
# detail=f"Management type is already exist in given Decision Book UUID {data.build_decision_book_uu_id}.",
# )
#
# data_dict.pop("build_decision_book_uu_id", None)
# data_dict.pop("person_uu_id", None)
# data_dict["management_typecode"] = data_dict.pop(
# "management_typecode_uu_id", None
# )
# data_dict["build_decision_book_id"] = decision_book.id
# data_dict["person_id"] = person_to_add.id
#
# created = BuildDecisionBookPerson.find_or_create(**data_dict)
# if created.is_found:
# raise HTTPException(
# status_code=status.HTTP_400_BAD_REQUEST,
# detail=f"Decision Book Person is already exist in given Decision Book UUID {data.build_decision_book_uu_id}.",
# )
# return JSONResponse(
# status_code=status.HTTP_200_OK,
# content=dict(
# message=f"Decision Book Person has added for given Decision Book UUID {data.build_decision_book_uu_id}",
# completed=True,
# data=created.get_dict(),
# ),
# )

282
api_events/events/decision_book/decision_book_invitations.py Normal file
View File

@@ -0,0 +1,282 @@
import typing
from fastapi import status, HTTPException
from fastapi.responses import JSONResponse
from databases import (
Build,
BuildLivingSpace,
BuildParts,
BuildDecisionBookInvitations,
BuildDecisionBookPerson,
BuildDecisionBook,
BuildDecisionBookPersonOccupants,
OccupantTypes,
Users,
ApiEnumDropdown,
)
from api_validations.validations_request import (
DecisionBookDecisionBookInvitationsUpdate,
DecisionBookDecisionBookInvitations,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_library.date_time_actions.date_functions import system_arrow
class BuildDecisionBookInvitationsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"e2277528-8c9c-4c0c-ae64-3ce80cae664b": "decision_book_invitations_list",
}
__event_validation__ = {"e2277528-8c9c-4c0c-ae64-3ce80cae664b": None}
@classmethod
def decision_book_invitations_list(
cls,
data,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
class BuildDecisionBookInvitationsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"d0bfa20c-841d-421c-98e6-d308f938d16a": "decision_book_invitations_create",
}
__event_validation__ = {
"d0bfa20c-841d-421c-98e6-d308f938d16a": DecisionBookDecisionBookInvitations
}
@classmethod
def decision_book_invitations_create(
cls,
data: DecisionBookDecisionBookInvitations,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Employee cannot create decision book invitations",
)
# Check token posses the occupant type of Build Manager
occupant_manager = OccupantTypes.filter_by_one(
system=True, occupant_category_type="BU", occupant_code="BU-MNG"
).data
if not token_dict.selected_occupant.occupant_type_id == occupant_manager.id:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only Build Manager can create decision book",
)
# Check decision book is valid for this token and building
decision_book = BuildDecisionBook.filter_one(
BuildDecisionBook.uu_id == data.build_decision_book_uu_id,
BuildDecisionBook.build_id == token_dict.selected_occupant.build_id,
).data
if not decision_book:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="Decision book not found. Please create decision book first",
)
occupant_building = Build.filter_one(
Build.id == token_dict.selected_occupant.build_id
).data
# Check planned decision book date is valid
if (
not system_arrow.get(data.planned_date).date()
>= system_arrow.now().shift(days=1).date()
):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Planned date must be greater than today",
)
# Create an invitation for specific invitation type to start invite sending process
planned_date_expires = str(
system_arrow.get(data.planned_date).shift(days=15).date()
)
book_invitation = BuildDecisionBookInvitations.find_or_create(
build_id=token_dict.selected_occupant.build_id,
build_uu_id=token_dict.selected_occupant.build_uuid,
decision_book_id=decision_book.id,
decision_book_uu_id=str(decision_book.uu_id),
invitation_type=str(decision_book.decision_type),
living_part_count=occupant_building.livable_part_count,
living_part_percentage=0.51,
message=data.message,
planned_date=str(system_arrow.get(data.planned_date)),
planned_date_expires=planned_date_expires,
expiry_ends=str(system_arrow.get(data.planned_date).shift(days=15).date()),
)
book_invitation.save_and_confirm()
# Get all the parts of the building that is occupant in token
build_parts = BuildParts.filter_all(
BuildParts.build_id == occupant_building.id,
)
# Get all build living spaces that is found in building with distinct person id
occupants = OccupantTypes.filter_all(system=True)
BuildLivingSpace.filter_attr = None
build_living_spaces_people = (
BuildLivingSpace.filter_all(
BuildLivingSpace.build_parts_id.in_(
[build_part.id for build_part in build_parts.data]
),
BuildLivingSpace.occupant_type.in_(
[occupant.id for occupant in occupants.data]
),
)
.query.distinct(BuildLivingSpace.person_id)
.all()
)
if not build_living_spaces_people:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="No living spaces found for the building",
)
print(
f"Tnvite UUID : {book_invitation.uu_id} Message : {data.message} Planned date : {data.planned_date}"
)
# Send invitation to all the users as attend and update the manager as build manager
attendance_occupant_type = OccupantTypes.filter_by_one(
system=True, occupant_code="MT-ATT", occupant_category_type="MT"
).data
manager_occupant_type = OccupantTypes.filter_by_one(
system=True, occupant_code="BU-MNG", occupant_category_type="BU"
).data
build_decision_book_person_dict = dict(
build_decision_book_id=decision_book.id,
build_decision_book_uu_id=str(decision_book.uu_id),
invite_id=book_invitation.id,
invite_uu_id=str(book_invitation.uu_id),
send_date=str(system_arrow.now().date()),
expiry_starts=decision_book.expiry_starts,
expiry_ends=decision_book.expiry_ends,
)
# Check if the invitation is already created at database
for build_living_spaces_user in build_living_spaces_people:
if invite := BuildDecisionBookPerson.filter_one(
BuildDecisionBookPerson.invite_id == book_invitation.id,
BuildDecisionBookPerson.build_living_space_id
== build_living_spaces_user.id,
).data:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"Invitation already send to {build_living_spaces_user.email} "
f"for invite {invite.uu_id} date : {str(book_invitation.planned_date)}",
)
invitations_person = BuildDecisionBookPerson.find_or_create(
**build_decision_book_person_dict,
build_living_space_id=build_living_spaces_user.id,
build_living_space_uu_id=str(build_living_spaces_user.uu_id),
person_id=build_living_spaces_user.person_id,
token=Users.generate_token(40),
)
invitations_person.save_and_confirm()
invitations_person.add_occupant_type(occupant_type=attendance_occupant_type)
if invitations_person:
print(f'"{invitations_person.token}",')
spaces_user = Users.filter_one(
Users.person_id == build_living_spaces_user.person_id,
).data
# print(
# f"Invitation is send : {spaces_user.email} "
# f"Token : {invitations_person.token} "
# f"Send Date : {str(invitations_person.send_date.date())}"
# )
manager_living_spaces = BuildLivingSpace.filter_all(
BuildLivingSpace.person_id == token_dict.person_id,
)
manager_people = BuildDecisionBookPerson.filter_all(
BuildDecisionBookPerson.invite_id == book_invitation.id,
BuildDecisionBookPerson.build_living_space_id.in_(
[
manager_living_space.id
for manager_living_space in manager_living_spaces.data
]
),
system=True,
)
manager_people_occupants = BuildDecisionBookPersonOccupants.filter_all(
BuildDecisionBookPersonOccupants.build_decision_book_person_id
== manager_people.get(1).id,
system=True,
)
if manager_people_occupants.count:
manager_people_occupants.query.delete()
BuildDecisionBookPersonOccupants.save()
if manager_people.count:
manager_people.query.delete()
BuildDecisionBookPerson.save()
if book_person_manager := BuildDecisionBookPerson.find_or_create(
**build_decision_book_person_dict,
build_living_space_id=token_dict.selected_occupant.living_space_id,
build_living_space_uu_id=str(
token_dict.selected_occupant.living_space_uu_id
),
person_id=token_dict.person_id,
token=Users.generate_token(40),
):
book_person_manager.save_and_confirm()
book_person_manager.add_occupant_type(occupant_type=manager_occupant_type)
print(f"Manager Token : {book_person_manager.token}")
BuildDecisionBookPerson.save()
return JSONResponse(
status_code=status.HTTP_200_OK,
content={
"completed": True,
"message": "Invitation are send to people related with building",
"data": book_invitation.get_dict(),
},
)
class BuildDecisionBookInvitationsUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"92413636-53a8-4a05-842c-1485a64e00d1": "decision_book_invitations_attend",
}
__event_validation__ = {
"92413636-53a8-4a05-842c-1485a64e00d1": DecisionBookDecisionBookInvitationsUpdate
}
@classmethod
def decision_book_invitations_attend(
cls,
data: DecisionBookDecisionBookInvitationsUpdate,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
BuildDecisionBookInvitationsListEventMethod = (
BuildDecisionBookInvitationsListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/invite/list")
)
)
BuildDecisionBookInvitationsCreateEventMethod = (
BuildDecisionBookInvitationsCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/invite/create")
)
)
BuildDecisionBookInvitationsUpdateEventMethod = (
BuildDecisionBookInvitationsUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/invite/update")
)
)

169
api_events/events/decision_book/decision_book_payment.py Normal file
View File

@@ -0,0 +1,169 @@
from typing import Union
from fastapi.responses import JSONResponse
from fastapi import status
from api_validations.validations_response.parts import BuildPartsListResponse
from databases import (
Build,
BuildParts,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_validations.validations_request import (
InsertBuildParts,
UpdateBuildParts,
ListOptions,
)
from databases.sql_models.building.decision_book import BuildDecisionBookPayments
class DecisionBookPaymentListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"49bb8ab8-520d-4676-a159-aaf84f37f372": "decision_book_payment_list"
}
__event_validation__ = {"49bb8ab8-520d-4676-a159-aaf84f37f372": None}
@classmethod
def decision_book_payment_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
"""
SELECT payment_plan_time_periods, process_date, payment_amount, currency, payment_types_id,
payment_types_uu_id, period_time, process_date_y, process_date_m, build_decision_book_item_id,
build_decision_book_item_uu_id, decision_book_project_id, decision_book_project_uu_id, build_parts_id,
build_parts_uu_id, id, uu_id, ref_id, created_at, updated_at, cryp_uu_id, created_by, created_by_id,
updated_by, updated_by_id, confirmed_by, confirmed_by_id, is_confirmed, replication_id, deleted,
active, is_notification_send, is_email_send, expiry_starts, expiry_ends, account_records_id,
account_records_uu_id FROM public.build_decision_book_payments;
"""
from sqlalchemy import func, select, union_all, extract, Integer
build_parts_id, build_decision_book_id = 7, ""
payment_types_id_recv, payment_types_id_deb = 46, 45
BuildDecisionBookPayments.filter_attr = list_options
# Define the subqueries
debit_subquery = (
select(
BuildDecisionBookPayments.payment_plan_time_periods,
func.sum(BuildDecisionBookPayments.payment_amount).label("debit"),
func.cast(0, Integer).label("recv"),
func.max(BuildDecisionBookPayments.process_date).label("ls"),
)
.where(
BuildDecisionBookPayments.build_parts_id == build_parts_id,
BuildDecisionBookPayments.payment_types_id == payment_types_id_deb,
BuildDecisionBookPayments.build_decision_book_id
== build_decision_book_id,
extract("year", func.current_date())
== extract("year", BuildDecisionBookPayments.process_date),
extract("month", func.current_date())
== extract("month", BuildDecisionBookPayments.process_date),
)
.group_by(BuildDecisionBookPayments.payment_plan_time_periods)
)
recv_subquery = (
select(
BuildDecisionBookPayments.payment_plan_time_periods,
func.cast(0, Integer).label("debit"),
func.sum(BuildDecisionBookPayments.payment_amount).label("recv"),
func.max(BuildDecisionBookPayments.process_date).label("ls"),
)
.where(
BuildDecisionBookPayments.build_parts_id == build_parts_id,
BuildDecisionBookPayments.payment_types_id == payment_types_id_recv,
BuildDecisionBookPayments.build_decision_book_id
== build_decision_book_id,
extract("year", func.current_date())
== extract("year", BuildDecisionBookPayments.process_date),
extract("month", func.current_date())
== extract("month", BuildDecisionBookPayments.process_date),
)
.group_by(BuildDecisionBookPayments.payment_plan_time_periods)
)
# Combine the subqueries using union_all
combined_subquery = union_all(debit_subquery, recv_subquery).alias("AA")
# Final query
final_query = select(
combined_subquery.c.payment_plan_time_periods,
func.sum(combined_subquery.c.debit).label("debit"),
func.sum(combined_subquery.c.recv).label("recv"),
combined_subquery.c.ls.label("Last Seen"),
).group_by(
combined_subquery.c.payment_plan_time_periods, combined_subquery.c.ls
)
# Execute the query
book_payments_month = BuildDecisionBookPayments.session.execute(
final_query
).fetchall()
print("book_payments_month", book_payments_month)
debit_subquery = (
select(
BuildDecisionBookPayments.payment_plan_time_periods,
func.sum(BuildDecisionBookPayments.payment_amount).label("debit"),
func.cast(0, Integer).label("recv"),
func.max(BuildDecisionBookPayments.process_date).label("ls"),
)
.where(
BuildDecisionBookPayments.build_parts_id == build_parts_id,
BuildDecisionBookPayments.payment_types_id == payment_types_id_deb,
BuildDecisionBookPayments.build_decision_book_id
== build_decision_book_id,
)
.group_by(BuildDecisionBookPayments.payment_plan_time_periods)
)
recv_subquery = (
select(
BuildDecisionBookPayments.payment_plan_time_periods,
func.cast(0, Integer).label("debit"),
func.sum(BuildDecisionBookPayments.payment_amount).label("recv"),
func.max(BuildDecisionBookPayments.process_date).label("ls"),
)
.where(
BuildDecisionBookPayments.build_parts_id == build_parts_id,
BuildDecisionBookPayments.payment_types_id == payment_types_id_recv,
BuildDecisionBookPayments.build_decision_book_id
== build_decision_book_id,
)
.group_by(BuildDecisionBookPayments.payment_plan_time_periods)
)
# Combine the subqueries using union_all
combined_subquery = union_all(debit_subquery, recv_subquery).alias("AA")
# Final query
final_query = select(
combined_subquery.c.payment_plan_time_periods,
func.sum(combined_subquery.c.debit).label("debit"),
func.sum(combined_subquery.c.recv).label("recv"),
combined_subquery.c.ls.label("Last Seen"),
).group_by(
combined_subquery.c.payment_plan_time_periods, combined_subquery.c.ls
)
# Execute the query
book_payments = BuildDecisionBookPayments.session.execute(
final_query
).fetchall()
print("book_payments", book_payments)
return AlchemyJsonResponse(
completed=True,
message="Building Parts Records are listed",
result=[book_payments, book_payments_month],
cls_object=BuildParts,
response_model=BuildPartsListResponse,
filter_attributes=list_options,
)

372
api_events/events/decision_book/project_decision_book.py Normal file
View File

@@ -0,0 +1,372 @@
from typing import Union
from api_library.date_time_actions.date_functions import system_arrow, client_arrow
from databases import (
BuildDecisionBookProjects,
BuildDecisionBookProjectPerson,
BuildDecisionBookPayments,
OccupantTypes,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.validations_request import (
InsertBuildDecisionBookProjects,
UpdateBuildDecisionBookProjects,
ApprovalsBuildDecisionBookProjects,
ListOptions,
)
from api_validations.core_response import AlchemyJsonResponse
from databases import Build, BuildLivingSpace, BuildParts, ApiEnumDropdown
from databases.sql_models.building.decision_book import (
BuildDecisionBookProjectItems,
BuildDecisionBookItems,
BuildDecisionBook,
)
class ProjectDecisionBookListEventMethods(MethodToEvent):
event_type = "LIST"
__event_keys__ = {
"96459b36-37f2-4d5b-8370-c459058d5bce": "project_decision_book_list",
}
__event_validation__ = {"96459b36-37f2-4d5b-8370-c459058d5bce": None}
@classmethod
def project_decision_book_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
build_decision_book = BuildDecisionBook.filter_one(
BuildDecisionBook.build_id == token_dict.selected_occupant.build_id,
).data
if not build_decision_book:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="Build decision book not found",
data={},
)
BuildDecisionBookProjects.filter_attr = list_options
decision_book_projects = BuildDecisionBookProjects.filter_all(
BuildDecisionBookProjects.build_decision_book_id
== build_decision_book.id,
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book_projects,
)
class ProjectDecisionBookCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"b8e44bb2-f157-4dd5-8a24-0e02db4877c9": "project_decision_book_create",
}
__event_validation__ = {
"b8e44bb2-f157-4dd5-8a24-0e02db4877c9": InsertBuildDecisionBookProjects
}
@classmethod
def project_decision_book_create(
cls,
data: InsertBuildDecisionBookProjects,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == token_dict.selected_occupant.living_space_id,
).data
if not living_space:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="Living space not found",
data={},
)
occupant_type = OccupantTypes.filter_by_one(
occupant_category_type="PRJ",
occupant_code="PRJ-LDR",
id=living_space.occupant_type,
).data
if not occupant_type:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message=f"{token_dict.selected_occupant.occupant_type_uu_id} occupant type is not allowed, only PRJ-LDR occupant type is allowed",
data={},
)
decision_book_project_person = BuildDecisionBookProjectPerson.filter_one(
BuildDecisionBookProjectPerson.living_space_id
== token_dict.selected_occupant.living_space_id,
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book_project_person,
)
class ProjectDecisionBookUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"bfe3ef13-030f-495f-b692-94bcb746d700": "project_decision_book_update",
}
__event_validation__ = {
"bfe3ef13-030f-495f-b692-94bcb746d700": UpdateBuildDecisionBookProjects
}
@classmethod
def project_decision_book_update(
cls,
data: UpdateBuildDecisionBookProjects,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == token_dict.selected_occupant.living_space_id,
).data
if not living_space:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="Living space not found",
data={},
)
occupant_type = OccupantTypes.filter_by_one(
occupant_category_type="PRJ",
occupant_code="PRJ-LDR",
id=living_space.occupant_type,
).data
if not occupant_type:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message=f"{token_dict.selected_occupant.occupant_type_uu_id} occupant type is not allowed, only PRJ-LDR occupant type is allowed",
data={},
)
decision_book_project_person = BuildDecisionBookProjectPerson.filter_one(
BuildDecisionBookProjectPerson.build_decision_book_project_uu_id
== data.build_decision_book_project_uu_id,
BuildDecisionBookProjectPerson.living_space_id
== token_dict.selected_occupant.living_space_id,
).data
if not decision_book_project_person:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="This project is not allowed for this occupant",
data={},
)
decision_book_project = BuildDecisionBookProjects.filter_one(
BuildDecisionBookProjects.id
== decision_book_project_person.build_decision_book_project_id,
)
if decision_book_project.is_completed:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Project decision book is closed. No modification is allowed",
data={},
)
data_dict = data.excluded_dump()
decision_book_project.update(**data_dict)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book_project_person,
)
class ProjectDecisionBookApprovalEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"a83a83fe-8446-4c60-9ae5-d1c06adbf626": "project_decision_book_approval",
}
__event_validation__ = {
"a83a83fe-8446-4c60-9ae5-d1c06adbf626": ApprovalsBuildDecisionBookProjects
}
@classmethod
def project_decision_book_approval(
cls,
data: ApprovalsBuildDecisionBookProjects,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
BuildDecisionBookPayments.client_arrow = client_arrow
BuildDecisionBookPayments.client_arrow.timezone = token_dict.timezone or "GMT+3"
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == token_dict.selected_occupant.living_space_id,
).data
if not living_space:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="Living space not found",
data={},
)
occupant_type = OccupantTypes.filter_by_one(
system=True,
occupant_category_type="PRJ",
occupant_code="PRJ-LDR",
id=living_space.occupant_type,
).data
if not occupant_type:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message=f"{token_dict.selected_occupant.occupant_type_uu_id} occupant type is not allowed, only PRJ-LDR occupant type is allowed",
data={},
)
decision_book_project_person = BuildDecisionBookProjectPerson.filter_one(
BuildDecisionBookProjectPerson.build_decision_book_project_uu_id
== data.build_decision_book_project_uu_id,
BuildDecisionBookProjectPerson.living_space_id
== token_dict.selected_occupant.living_space_id,
).data
if not decision_book_project_person:
raise BuildDecisionBookProjectPerson.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message="This project is not allowed for this occupant",
data={},
)
decision_book_project = BuildDecisionBookProjects.filter_one(
BuildDecisionBookProjects.id
== decision_book_project_person.build_decision_book_project_id,
).data
if decision_book_project.is_completed:
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Project decision book is closed. No modification is allowed",
data={},
)
data_dict = data.excluded_dump()
data_dict["is_completed"] = True
build_parts_list = BuildParts.filter_all(
BuildParts.human_livable == True,
BuildParts.build_id == token_dict.selected_occupant.build_id,
).data
decision_book_project_item = BuildDecisionBookItems.filter_one(
BuildDecisionBookItems.id
== decision_book_project.build_decision_book_item_id
).data
book_payment_dict = dict(
build_decision_book_item_id=decision_book_project_item.id,
build_decision_book_item_uu_id=str(decision_book_project_item.uu_id),
currency=decision_book_project.currency,
)
payment_type = ApiEnumDropdown.get_debit_search(search_debit="DT-D")
for final_price in data.final_price_list or []:
for build_part_single in build_parts_list:
local_date = BuildDecisionBookPayments.client_arrow.get(
str(final_price["date"])
)
local_date = system_arrow.get(local_date)
payment_amount = abs(float(final_price["price"])) * -1
created_book_payment = BuildDecisionBookPayments.find_or_create(
build_parts_id=build_part_single.id,
build_parts_uu_id=str(build_part_single.uu_id),
payment_amount=payment_amount,
payment_types_id=payment_type.id,
payment_types_uu_id=str(payment_type.uu_id),
process_date=str(local_date),
process_date_m=int(local_date.month),
process_date_y=int(local_date.year),
payment_plan_time_periods=str(
decision_book_project.project_type
),
period_time=f"{local_date.year}-{str(local_date.month).zfill(2)}",
decision_book_project_id=decision_book_project.id,
decision_book_project_uu_id=str(decision_book_project.uu_id),
**book_payment_dict,
)
created_book_payment.save_and_confirm()
updated_decision_book_project = decision_book_project.update(**data_dict)
updated_decision_book_project.save_and_confirm()
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=updated_decision_book_project,
)
class ProjectDecisionBookPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"444d67a0-b3a8-4ca2-9d8d-f1acc75011e0": "project_decision_book_patch",
}
__event_validation__ = {"444d67a0-b3a8-4ca2-9d8d-f1acc75011e0": None}
@classmethod
def project_decision_book_patch(
cls,
data,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
return
ProjectDecisionBookListEventMethod = ProjectDecisionBookListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/list")
)
ProjectDecisionBookCreateEventMethod = ProjectDecisionBookCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/create")
)
ProjectDecisionBookUpdateEventMethod = ProjectDecisionBookUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/update")
)
ProjectDecisionBookApprovalEventMethod = ProjectDecisionBookApprovalEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/approval")
)
ProjectDecisionBookPatchEventMethod = ProjectDecisionBookPatchEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/patch")
)

156
api_events/events/decision_book/project_decision_book_items.py Normal file
View File

@@ -0,0 +1,156 @@
from typing import Union
from databases import (
BuildDecisionBookProjectItems,
BuildDecisionBookProjectPerson,
)
from api_validations.validations_request import (
InsertBuildDecisionBookProjectItems,
UpdateBuildDecisionBookProjectItems,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from databases.sql_models.building.decision_book import BuildDecisionBookProjects
class BuildDecisionBookProjectItemsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"ce3630e4-2bf9-4433-bdab-1ee72117e54b": "build_decision_book_project_items_list",
}
__event_validation__ = {"ce3630e4-2bf9-4433-bdab-1ee72117e54b": None}
@staticmethod
def build_decision_book_project_items_list(
requester: Union[EmployeeTokenObject, OccupantTokenObject],
list_options: ListOptions,
):
response = BuildDecisionBookProjectItems.list_items(
requester=requester,
list_options=list_options,
)
return AlchemyJsonResponse(
message="Build Decision Book Project Items List",
result=response,
)
class BuildDecisionBookProjectItemsCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"b27e4fd0-6e3e-441b-9b33-806ac7082444": "build_decision_book_project_items_create",
}
__event_validation__ = {
"b27e4fd0-6e3e-441b-9b33-806ac7082444": InsertBuildDecisionBookProjectItems,
}
@staticmethod
def build_decision_book_project_items_create(
data: InsertBuildDecisionBookProjectItems,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjectItems.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"No permission to create decision book project items",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
book_project = BuildDecisionBookProjects.filter_one(
BuildDecisionBookProjects.uu_id
== data.build_decision_book_project_uu_id,
BuildDecisionBookProjects.project_response_living_space_id
== token_dict.selected_occupant.living_space_id,
).data
if not book_project:
raise BuildDecisionBookProjectItems.raise_http_exception(
status_code="HTTP_404_NOT_FOUND",
error_case="NOT_FOUND",
message=f"This user can not create project item for this project uu_id : {data.build_decision_book_project_uu_id}",
data={},
)
data_dict = data.excluded_dump()
data_dict["build_decision_book_project_id"] = book_project.id
created_project_item = BuildDecisionBookProjectItems.find_or_create(
**data_dict
)
created_project_item.save_and_confirm()
return AlchemyJsonResponse(
message="Build Decision Book Project Items Create",
result=created_project_item.get_dict(),
)
class BuildDecisionBookProjectItemsUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"b2b7cdce-9a0c-4722-90ff-8bef36b4ec6b": "build_decision_book_project_items_update",
}
__event_validation__ = {
"b2b7cdce-9a0c-4722-90ff-8bef36b4ec6b": UpdateBuildDecisionBookProjectItems
}
@staticmethod
def build_decision_book_project_items_update(
requester: Union[EmployeeTokenObject, OccupantTokenObject],
decision_book_project_items: UpdateBuildDecisionBookProjectItems,
):
raise BuildDecisionBookProjectItems.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="UNAUTHORIZED",
message=f"No permission to update decision book project items",
data={},
)
class BuildDecisionBookProjectItemsPatchEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"e59d50df-dd22-4823-aeae-b9490332885c": "build_decision_book_project_items_patch",
}
__event_validation__ = {"e59d50df-dd22-4823-aeae-b9490332885c": None}
@staticmethod
def build_decision_book_project_items_patch(
requester: Union[EmployeeTokenObject, OccupantTokenObject],
decision_book_project_items: UpdateBuildDecisionBookProjectItems,
):
response = BuildDecisionBookProjectItems.delete_item(
requester=requester,
decision_book_project_items=decision_book_project_items,
)
return AlchemyJsonResponse(
message="Build Decision Book Project Items Patch",
result=response,
)
BuildDecisionBookProjectItemsListEventMethod = (
BuildDecisionBookProjectItemsListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/items/list")
)
)
BuildDecisionBookProjectItemsCreateEventMethod = (
BuildDecisionBookProjectItemsCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/items/create")
)
)
BuildDecisionBookProjectItemsUpdateEventMethod = (
BuildDecisionBookProjectItemsUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/items/update")
)
)
BuildDecisionBookProjectItemsPatchEventMethod = (
BuildDecisionBookProjectItemsPatchEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/items/patch")
)
)

189
api_events/events/decision_book/project_decision_book_person.py Normal file
View File

@@ -0,0 +1,189 @@
from typing import Union
from databases import (
BuildDecisionBookProjects,
BuildDecisionBookProjectPerson,
)
from api_validations.validations_request import (
InsertBuildDecisionBookProjectPerson,
UpdateBuildDecisionBookProjectPerson,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class ProjectDecisionBookPersonListEventMethods(MethodToEvent):
event_type = "LIST"
__event_keys__ = {
"7101b5ca-8bef-40f9-8b4d-646d9994e18f": "project_decision_book_person_list",
}
__event_validation__ = {"7101b5ca-8bef-40f9-8b4d-646d9994e18f": None}
@classmethod
def project_decision_book_person_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
project_person = BuildDecisionBookProjectPerson.filter_all(
BuildDecisionBookProjects.living_space_id
== token_dict.selected_occupant.living_space_id,
)
decision_book_ids = [
_.build_decision_book_project_id for _ in project_person.data
]
decision_book_projects = BuildDecisionBookProjects.filter_all(
BuildDecisionBookProjects.build_decision_book_project_id.in_(
decision_book_ids
),
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision person book listed successfully",
result=decision_book_projects,
)
class ProjectDecisionBookPersonCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"9c88e314-84e8-435e-8c1e-6a5aae80b2e6": "project_decision_book_person_create",
}
__event_validation__ = {
"9c88e314-84e8-435e-8c1e-6a5aae80b2e6": InsertBuildDecisionBookProjectPerson
}
@classmethod
def project_decision_book_create(
cls,
data: InsertBuildDecisionBookProjectPerson,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
decision_book = BuildDecisionBookProjects.filter_one(
BuildDecisionBookProjects.build_decision_book_uu_id
== data.get("build_decision_book_uu_id"),
BuildDecisionBookProjects.project_response_living_space_id
== token_dict.selected_occupant.living_space_id,
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book,
)
class ProjectDecisionBookPersonUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"7fbd18a0-c099-4494-ada1-bb23e39bb141": "project_decision_book_update_person",
}
__event_validation__ = {
"7fbd18a0-c099-4494-ada1-bb23e39bb141": UpdateBuildDecisionBookProjectPerson
}
@classmethod
def project_decision_book_update(
cls,
data: UpdateBuildDecisionBookProjectPerson,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
decision_book_project_person = BuildDecisionBookProjectPerson.filter_one(
BuildDecisionBookProjects.build_decision_book_project_uu_id
== data.get("build_decision_book_uu_id"),
BuildDecisionBookProjects.living_space_id
== token_dict.selected_occupant.living_space_id,
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book_project_person,
)
class ProjectDecisionBookPersonPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"a122e84a-5556-4bf7-b680-1f47c438d4f7": "project_decision_book_person_patch",
}
__event_validation__ = {"a122e84a-5556-4bf7-b680-1f47c438d4f7": None}
@classmethod
def project_decision_book_patch(
cls,
data,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
raise BuildDecisionBookProjects.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
error_case="NOT_ALLOWED",
message="Employee cannot create project project decision book",
data={},
)
elif isinstance(token_dict, OccupantTokenObject):
decision_book_project_person = BuildDecisionBookProjectPerson.filter_one(
BuildDecisionBookProjects.build_decision_book_project_uu_id
== data.get("build_decision_book_uu_id"),
BuildDecisionBookProjects.living_space_id
== token_dict.selected_occupant.living_space_id,
)
return AlchemyJsonResponse(
status_code="HTTP_200_OK",
message="Project decision book created successfully",
result=decision_book_project_person,
)
ProjectDecisionBookPersonListEventMethod = ProjectDecisionBookPersonListEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/people/list")
)
ProjectDecisionBookPersonCreateEventMethod = (
ProjectDecisionBookPersonCreateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/people/create")
)
)
ProjectDecisionBookPersonUpdateEventMethod = (
ProjectDecisionBookPersonUpdateEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/people/update")
)
)
ProjectDecisionBookPersonPatchEventMethod = ProjectDecisionBookPersonPatchEventMethods(
action=ActionsSchema(endpoint="/build/decision_book/project/people/patch")
)

0
api_events/events/events/__init__.py Normal file
View File

157
api_events/events/events/events_bind_modules.py Normal file
View File

@@ -0,0 +1,157 @@
import typing
from databases import (
Modules,
BuildLivingSpace,
)
from api_validations.validations_request import (
RegisterModules2Occupant,
RegisterModules2Employee,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_events.events.events.events_bind_services import (
ServiceBindOccupantEventMethods,
)
from api_library.date_time_actions.date_functions import system_arrow
from api_validations.core_response import AlchemyJsonResponse
from databases.sql_models.company.employee import Employees
from databases.sql_models.event.event import Event2Occupant, Event2Employee
class ModulesBindOccupantEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"91003e90-8ead-4705-98a3-f8731c6ecb38": "modules_bind_occupant",
}
__event_validation__ = {
"91003e90-8ead-4705-98a3-f8731c6ecb38": None,
}
@classmethod
def bind_default_module_for_first_init_occupant(
cls, build_living_space_id: int, expires_at: str = None
):
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == build_living_space_id, system=True
).data
modules = Modules.filter_all(Modules.is_default_module == True).data
print("living_space", living_space, "modules", modules)
if not living_space or not modules:
print(f"Giving living Space or Modules: Default not found")
return
service_build_dict = dict(build_living_space_id=living_space.id)
if expires_at:
service_build_dict["expires_at"] = str(system_arrow.get(expires_at))
else:
expiry_ends = str(system_arrow.get(living_space.expiry_ends))
service_build_dict["expires_at"] = expiry_ends
for module in modules:
for service in module.retrieve_services():
event_occupant = Event2Occupant.find_or_create(
event_service_id=service.id,
event_service_uu_id=str(service.uu_id),
build_living_space_id=living_space.id,
build_living_space_uu_id=str(living_space.uu_id),
)
event_occupant.save_and_confirm()
return True
# @classmethod
# def modules_bind_occupant_system(
# cls, build_living_space_id: int, modules_id: int, expires_at: str = None
# ):
#
# living_space = BuildLivingSpace.filter_one(
# BuildLivingSpace.id == build_living_space_id,
# ).data
# modules = Modules.filter_one(Modules.id == modules_id).data
#
# if not living_space or not modules:
# print(f"Giving living Space or Modules: {modules.module_name} not found")
# return
# service_build_dict = dict(build_living_space_id=living_space.id)
# if expires_at:
# service_build_dict["expires_at"] = str(system_arrow.get(expires_at))
# else:
# service_build_dict["expires_at"] = str(
# system_arrow.get(living_space.expiry_ends)
# )
#
# for service in modules.retrieve_services():
# ServiceBindOccupantEventMethods.bind_services_occupant_system(
# **service_build_dict,
# service_id=service.id,
# )
# BuildLivingSpace.save()
# return True
@classmethod
def modules_bind_occupant(
cls,
data: RegisterModules2Occupant,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
class ModulesBindEmployeeEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"d4ed23db-62e9-4015-b7c0-698a7917aa0c": "modules_bind_employee",
}
__event_validation__ = {
"d4ed23db-62e9-4015-b7c0-698a7917aa0c": None,
}
@classmethod
def bind_default_module_for_first_init_occupant(
cls, employee_id: int, expires_at: str = None
):
employee = Employees.filter_one(
Employees.id == employee_id,
).data
modules = Modules.filter_all(Modules.is_default_module == True).data
print("living_space", employee, "modules", modules)
if not employee or not modules:
print(f"Giving living Space or Modules: Default not found")
return
service_build_dict = dict(build_living_space_id=employee.id)
if expires_at:
service_build_dict["expires_at"] = str(system_arrow.get(expires_at))
else:
expiry_ends = str(system_arrow.get(employee.expiry_ends))
service_build_dict["expires_at"] = expiry_ends
for module in modules:
for service in module.retrieve_services():
event_employee = Event2Employee.find_or_create(
event_service_id=service.id,
event_service_uu_id=str(service.uu_id),
employee_id=employee.id,
employee_uu_id=str(employee.uu_id),
)
event_employee.save_and_confirm()
return True
@classmethod
def modules_bind_employee(
cls,
data: RegisterModules2Employee,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
return
ModulesBindOccupantEventMethod = ModulesBindOccupantEventMethods(
action=ActionsSchema(endpoint="/bind/modules/occupant")
)
ModulesBindEmployeeEventMethod = ModulesBindEmployeeEventMethods(
action=ActionsSchema(endpoint="/bind/modules/employee")
)

321
api_events/events/events/events_bind_services.py Normal file
View File

@@ -0,0 +1,321 @@
import typing
from fastapi import status
from fastapi.responses import JSONResponse
from fastapi.exceptions import HTTPException
from api_library.date_time_actions.date_functions import system_arrow
from databases import (
Modules,
Employees,
BuildParts,
BuildLivingSpace,
Services,
OccupantTypes,
Event2Employee,
Event2Occupant,
)
from api_validations.validations_request import (
RegisterServices2Occupant,
RegisterServices2Employee,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class ServiceBindOccupantEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"0d2bc5c9-d4b1-4951-8305-69da4a687fdc": "bind_services_occupant",
}
__event_validation__ = {
"0d2bc5c9-d4b1-4951-8305-69da4a687fdc": RegisterServices2Occupant
}
@classmethod
def bind_services_occupant_system(
cls, build_living_space_id: int, service_id: int, expires_at: str = None
):
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.id == build_living_space_id,
).data
service = Services.filter_one(Services.id == service_id).data
if not service:
print("Service is not valid. Service can not be binded")
return
if not living_space:
print("Living Space is not valid. Service is not binded")
return
if expires_at:
expires_at = str(system_arrow.get(expires_at))
else:
expires_at = str(system_arrow.get(living_space.expiry_ends))
occupants_event = Event2Occupant.find_or_create(
event_service_id=service.id,
event_service_uu_id=str(service.uu_id),
build_living_space_id=living_space.id,
build_living_space_uu_id=str(living_space.uu_id),
expiry_ends=expires_at,
)
occupants_event.save_and_confirm()
print(f"{service.service_name} is added to occupant {str(living_space.uu_id)}")
@classmethod
def bind_services_occupant(
cls,
data: RegisterServices2Occupant,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
from sqlalchemy.dialects.postgresql import insert
if isinstance(token_dict, EmployeeTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Employee is not authorized to add service to any occupant",
)
occupants_build_part = BuildParts.filter_one(
BuildParts.uu_id == data.build_part_uu_id,
BuildParts.build_id == token_dict.selected_occupant.build_id,
).data
if not occupants_build_part:
return JSONResponse(
content={
"completed": False,
"message": "User is not authorized to add service to this occupant or flat",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
occupant_occupant_type = OccupantTypes.filter_by_one(
uu_id=data.occupant_uu_id
).data
if not occupant_occupant_type:
return JSONResponse(
content={
"completed": False,
"message": "Occupant Types is not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
service = Services.filter_one(Services.uu_id == data.service_uu_id).data
if not service:
return JSONResponse(
content={
"completed": False,
"message": "Service is not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
# service_events = Service2Events.filter_all(
# Service2Events.service_id == service.id,
# ).data
# if not service_events:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail="Service has no events registered. Please contact with your manager",
# )
living_space = BuildLivingSpace.filter_one(
BuildLivingSpace.build_parts_id == occupants_build_part.id,
BuildLivingSpace.occupant_types_id == occupant_occupant_type.id,
BuildLivingSpace.person_id == token_dict.person_id,
).data
if not living_space:
return JSONResponse(
content={
"completed": False,
"message": "Living Space is not found with given data. Please check flat and occupant type",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
# event_ids_list = [
# {
# "build_living_space_id": living_space.id,
# "build_living_space_uu_id": str(living_space.uu_id),
# "event_id": service_event.event_id,
# "event_uu_id": str(service_event.event_uu_id),
# "is_confirmed": True,
# }
# for service_event in service_events
# ]
#
# session_execute = Services.session.execute(
# insert(Event2Occupant)
# .values(event_ids_list)
# .on_conflict_do_nothing(
# index_elements=["employee_id", "event_id"],
# )
# )
# count_row = session_execute.rowcount
# print(f"{count_row} events are added to employee {str(living_space.uu_id)}")
# Services.save()
class ServiceBindEmployeeEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"50f84023-d8ec-4257-bfce-08ddf077c101": "bind_services_employee_super_user",
}
__event_validation__ = {"50f84023-d8ec-4257-bfce-08ddf077c101": None}
@classmethod
def bind_services_employee(cls, service_id: int, employee_id: int):
employee = Employees.filter_by_one(
id=employee_id, **Employees.valid_record_dict
).data
service = Services.filter_by_one(
id=service_id, **Services.valid_record_dict
).data
if not service:
print("Service is not valid. Service can not be binded")
return
if not employee:
print("Employee is not valid. Service is not binded")
return
# service_events = Service2Events.filter_all(
# Service2Events.service_id == service.id,
# ).data
# if not service_events:
# raise Exception(
# "Service has no events registered. Please contact with your manager"
# )
# event_ids_list = [
# {
# "employee_id": employee_id,
# "employee_uu_id": str(employee.uu_id),
# "event_id": service_event.event_id,
# "event_uu_id": str(service_event.event_uu_id),
# "is_confirmed": True,
# }
# for service_event in service_events
# ]
#
# session_execute = Services.session.execute(
# insert(Event2Employee)
# .values(event_ids_list)
# .on_conflict_do_nothing(
# index_elements=["employee_id", "event_id"],
# )
# )
# count_row = session_execute.rowcount
# print(f"{count_row} events are added to employee {employee.uu_id}")
# for service_event in service_events:
# service_event.save_and_confirm()
@classmethod
def bind_services_employee_super_user(
cls,
data: RegisterServices2Employee,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Occupant is not authorized to add service to any employee",
)
employee = Employees.filter_by_one(
uu_id=data.employee_uu_id, **Employees.valid_record_dict
).data
if not employee:
return JSONResponse(
content={
"completed": False,
"message": "This employee is not authorized to add event to this employee",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
service = Services.filter_by_one(
uu_id=data.service_uu_id, **Services.valid_record_dict
).data
if not service:
return JSONResponse(
content={
"completed": False,
"message": "Service is not found",
"data": {},
},
status_code=status.HTTP_404_NOT_FOUND,
)
event_of_employee = Event2Employee.find_or_create(
event_service_id=service.id,
event_service_uu_id=str(service.uu_id),
employee_id=employee.id,
employee_uu_id=str(employee.uu_id),
)
event_of_employee.save_and_confirm()
print(f"{service.service_name} is added to employee {str(employee.uu_id)}")
# service_events = Service2Events.filter_all(
# Service2Events.service_id == service.id,
# ).data
# if not service_events:
# raise HTTPException(
# status_code=status.HTTP_404_NOT_FOUND,
# detail="Service has no events registered. Please contact with your manager",
# )
#
# event_ids_list = [
# {
# "employee_id": employee.id,
# "employee_uu_id": employee.uu_id,
# "event_id": service_event.event_id,
# "event_uu_id": service_event.event_uu_id,
# "is_confirmed": True,
# }
# for service_event in service_events
# ]
#
# session_execute = Services.session.execute(
# insert(Event2Employee)
# .values(event_ids_list)
# .on_conflict_do_nothing(
# index_elements=["employee_id", "event_id"],
# )
# )
# count_row = session_execute.rowcount
# if not count_row:
# Services.save()
# return JSONResponse(
# content={
# "completed": False,
# "message": "No events are added to employee",
# "data": {},
# },
# status_code=status.HTTP_200_OK,
# )
# return JSONResponse(
# content={
# "completed": True,
# "message": f"{count_row} events are added to employee",
# "data": {},
# },
# status_code=status.HTTP_200_OK,
# )
ServiceBindOccupantEventMethod = ServiceBindOccupantEventMethods(
action=ActionsSchema(endpoint="/bind/services/occupant")
)
ServiceBindEmployeeEventMethod = ServiceBindEmployeeEventMethods(
action=ActionsSchema(endpoint="/bind/services/employee")
)

270
api_events/events/events/events_events.py Normal file
View File

@@ -0,0 +1,270 @@
from typing import Union
from fastapi.exceptions import HTTPException
from api_events.events.events.events_services import ServicesEvents
from databases import (
Events,
Employees,
Staff,
Duties,
Event2Occupant,
Event2Employee,
BuildLivingSpace,
)
from api_validations.validations_request import (
RegisterEvents2Employee,
RegisterEvents2Occupant,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class EventsListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"9fa01bef-c0e8-4fe1-b9ed-2ff1c4f35faa": "events_list",
}
__event_validation__ = {"9fa01bef-c0e8-4fe1-b9ed-2ff1c4f35faa": None}
@classmethod
def events_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
list_options.page = 1
list_options.size = 10000
Events.filter_attr = list_options
if isinstance(token_dict, OccupantTokenObject):
occupant_events = Event2Occupant.filter_all(
Event2Occupant.build_living_space_id
== token_dict.selected_occupant.living_space_id
).data
records = Events.filter_all(
Events.id.in_([event.event_id for event in occupant_events])
)
return AlchemyJsonResponse(
completed=True,
message="Events are listed successfully",
result=records,
)
elif isinstance(token_dict, EmployeeTokenObject):
employee_events = Event2Employee.filter_all(
Event2Employee.employee_id == token_dict.selected_company.employee_id
).data
records = Events.filter_all(
Events.id.in_([event.event_id for event in employee_events])
)
return AlchemyJsonResponse(
completed=True,
message="Events are listed successfully",
result=records,
)
return AlchemyJsonResponse(
completed=False,
message="Events are NOT listed successfully",
result=[],
)
class EventsBindEventToOccupantMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"d9aa58aa-37f7-4c27-861d-3105f76f5cdc": "bind_events_employee",
}
__event_validation__ = {
"d9aa58aa-37f7-4c27-861d-3105f76f5cdc": RegisterEvents2Employee
}
@classmethod
def bind_events_employee(cls, data: RegisterEvents2Employee, token_dict):
events = Events.filter_all(
Events.uu_id.in_(data.event_id),
).data
if not events:
raise HTTPException(
status_code=401,
detail="No event found. Please contact your super user.",
)
employee_is_not_valid = False
employee = Employees.filter_one(
Employees.employee_uu_id == data.employee_uu_id,
).data
if employee:
staff = Staff.filter_one(
Staff.id == employee.staff_id,
).data
duties = Duties.filter_one(
Duties.id == staff.duties_id,
).data
if duties.company_id not in token_dict.companies_id_list:
employee_is_not_valid = True
if employee_is_not_valid:
raise HTTPException(
status_code=401,
detail="This employee can not be reached by this user. Please contact your super user.",
)
for event in events:
employee = Event2Employee.find_or_create(
**token_dict.user_creds, employee_id=employee.id, event_id=event.id
)
Events.save()
return {
"status": "success",
"message": "Events registered successfully.",
"events": [event.uu_id for event in events.data],
}
class EventsBindEventToEmployeeMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"8bb4f4fc-b474-427e-90b3-d8681f308bb5": "bind_events_occupant",
}
__event_validation__ = {
"8bb4f4fc-b474-427e-90b3-d8681f308bb5": RegisterEvents2Occupant
}
@classmethod
def bind_events_occupant(cls, data: RegisterEvents2Occupant, token_dict):
events = Events.filter_all(
Events.uu_id.in_(data.event_id),
).data
if not events:
raise HTTPException(
status_code=401,
detail="No event found. Please contact your super user.",
)
occupant = BuildLivingSpace.filter_one(
BuildLivingSpace.uu_id == data.build_living_space_uu_id,
).data
if not occupant:
raise HTTPException(
status_code=401,
detail="This occupant can not be reached by this user. Please contact your super user.",
)
for event in events:
occupant = Event2Occupant.find_or_create(
**token_dict.user_creds,
build_living_space_id=occupant.id,
event_id=event.id,
)
Events.save()
return {
"status": "success",
"message": "Events registered successfully.",
"events": [event.uu_id for event in events.data],
}
EventsBindEventToOccupantMethod = EventsBindEventToOccupantMethods(
action=ActionsSchema(endpoint="/bind/events/occupant")
)
EventsBindEventToEmployeeMethod = EventsBindEventToEmployeeMethods(
action=ActionsSchema(endpoint="/bind/events/employee")
)
EventsListEventMethod = EventsListEventMethods(
action=ActionsSchema(endpoint="/event/list")
)
# EventsCreateEventMethod = EventsCreateEventMethods(
# action=ActionsSchema(endpoint="/event/create")
# )
# EventsUpdateEventMethod = EventsUpdateEventMethods(
# action=ActionsSchema(endpoint="/event/update")
# )
# EventsPatchEventMethod = EventsPatchEventMethods(
# action=ActionsSchema(endpoint="/event/patch")
# )
#
# class EventsCreateEventMethods(MethodToEvent):
#
# event_type = "CREATE"
# __event_keys__ = {
# "514a9f8f-e5e5-4e10-9d0b-2de8f461fc1b": "events_create",
# }
#
# @classmethod
# def events_create(cls, data: CreateEvents, token_dict):
# event = Events.find_or_create(
# **token_dict.user_creds,
# event_name=data.event_name,
# event_description=data.event_description,
# event_date=data.event_date,
# event_location=data.event_location,
# active=True,
# deleted=False,
# )
# Events.save()
# return {
# "status": "success",
# "message": "Event created successfully.",
# "event": event.uu_id,
# }
# class EventsUpdateEventMethods(MethodToEvent):
#
# event_type = "UPDATE"
# __event_keys__ = {
# "f94e7b79-2369-4840-bf2b-244934ca3136": "events_update",
# }
#
# @classmethod
# def events_update(cls, data: CreateEvents, token_dict):
# event = Events.filter_by_one(uu_id=data.uu_id, **Events.valid_record_dict).data
# if not event:
# raise HTTPException(
# status_code=404,
# detail="No event found. Please contact your responsible company.",
# )
# event.update(
# **token_dict.user_creds,
# event_name=data.event_name,
# event_description=data.event_description,
# event_date=data.event_date,
# event_location=data.event_location,
# )
# Events.save()
# return {
# "status": "success",
# "message": "Event updated successfully.",
# "event": event.uu_id,
# }
#
#
# class EventsPatchEventMethods(MethodToEvent):
#
# event_type = "PATCH"
# __event_keys__ = {
# "41944c63-22d3-4866-affd-34bcd49da58b": "events_patch",
# }
#
# @classmethod
# def events_patch(cls, data: CreateEvents, token_dict):
# event = Events.filter_by_one(uu_id=data.uu_id, **Events.valid_record_dict).data
# if not event:
# raise HTTPException(
# status_code=404,
# detail="No event found. Please contact your responsible company.",
# )
# event.update(
# **token_dict.user_creds,
# event_name=data.event_name,
# event_description=data.event_description,
# event_date=data.event_date,
# event_location=data.event_location,
# )
# return {
# "status": "success",
# "message": "Event patched successfully.",
# "event": event.uu_id,
# }

28
api_events/events/events/events_models.py Normal file
View File

@@ -0,0 +1,28 @@
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class ModelEvents(MethodToEvent):
@classmethod
def model_list(cls, list_options: ListOptions, token_dict):
return
@classmethod
def model_create(cls, data: DepartmentsPydantic, token_dict):
return
@classmethod
def model_update(cls, company_uu_id: str, data: DepartmentsPydantic, token_dict):
return
@classmethod
def model_patch(cls, company_uu_id: str, data: PatchRecord, token_dict):
return

24
api_events/events/events/events_modules.py Normal file
View File

@@ -0,0 +1,24 @@
from api_validations.validations_request import DepartmentsPydantic, PatchRecord
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class ModulesEvents(MethodToEvent):
@classmethod
def modules_list(cls, request, list_options):
return
@classmethod
def modules_create(cls, data: DepartmentsPydantic, token_dict):
return
@classmethod
def modules_update(cls, module_uu_id: str, data: DepartmentsPydantic, token_dict):
return
@classmethod
def modules_patch(cls, module_uu_id: str, data: PatchRecord, token_dict):
return

64
api_events/events/events/events_services.py Normal file
View File

@@ -0,0 +1,64 @@
from typing import Union
from api_validations.validations_request import (
DepartmentsPydantic,
PatchRecord,
ListOptions,
)
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class ServicesEvents(MethodToEvent):
@classmethod
def services_list(
cls,
list_options: ListOptions,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
return
@classmethod
def services_create(
cls,
data: DepartmentsPydantic,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
return
@classmethod
def services_update(
cls,
service_uu_id: str,
data: DepartmentsPydantic,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
return
@classmethod
def services_patch(
cls,
service_uu_id: str,
data: PatchRecord,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
return
@classmethod
def bind_service_to_action(
cls, data, token_dict: Union[EmployeeTokenObject, OccupantTokenObject]
):
return
@classmethod
def bind_module_to_service(
cls, data, token_dict: Union[EmployeeTokenObject, OccupantTokenObject]
):
return
@classmethod
def bind_events_patch(cls, company_uu_id: str, data: PatchRecord):
return

0
api_events/events/identity/__init__.py Normal file
View File

219
api_events/events/identity/people.py Normal file
View File

@@ -0,0 +1,219 @@
from typing import Union
from fastapi import status
from fastapi.responses import JSONResponse
from api_validations.validations_response.people import PeopleListResponse
from databases import (
Build,
People,
Users,
Companies,
)
from api_validations.validations_request import InsertPerson, UpdateUsers
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
class PeopleListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"0a05f03c-6ed8-4230-a4ff-6e7cf886909b": "super_users_people_list",
"b5612538-0445-4a4a-ab13-d2a06037f7a5": "sales_users_people_list",
"25cbbaf8-117a-470f-a844-2cfc70f71dde": "human_resources_users_people_list",
"cdf62f06-ec50-40de-b19e-adb3dd34bb95": "people_list_only_occupant_tenant_or_owner",
}
__event_validation__ = {
"0a05f03c-6ed8-4230-a4ff-6e7cf886909b": PeopleListResponse,
"b5612538-0445-4a4a-ab13-d2a06037f7a5": None,
"25cbbaf8-117a-470f-a844-2cfc70f71dde": None,
"cdf62f06-ec50-40de-b19e-adb3dd34bb95": None,
}
@classmethod
def super_users_people_list(
cls, list_options, token_dict: Union[EmployeeTokenObject, OccupantTokenObject]
):
records = []
if isinstance(token_dict, EmployeeTokenObject):
People.pre_query = People.select_action(
duty_id_list=[
token_dict.selected_company.duty_id,
token_dict.selected_company.bulk_duties_id,
],
)
People.filter_attr = list_options
records = People.filter_all()
elif isinstance(token_dict, OccupantTokenObject):
related_users = Users.filter_all(
Users.related_company
== token_dict.selected_occupant.responsible_company_id,
).data
People.pre_query = People.filter_all(
People.id.in_([user.person_id for user in related_users]),
).query
People.filter_attr = list_options
records = People.filter_all()
return AlchemyJsonResponse(
completed=True,
message="People are listed successfully",
result=records,
cls_object=People,
filter_attributes=list_options,
response_model=PeopleListResponse,
)
@classmethod
def sales_users_people_list(
cls,
list_options,
token_dict: EmployeeTokenObject,
):
People.filter_attr = list_options
records = People.filter_all().data
return AlchemyJsonResponse(
completed=True,
message="People are listed successfully",
result=records,
)
@classmethod
def human_resources_users_people_list(
cls,
list_options,
token_dict: EmployeeTokenObject,
):
if isinstance(token_dict, EmployeeTokenObject):
People.filter_attr = list_options
records = People.filter_all().data
return AlchemyJsonResponse(
completed=True,
message="People are listed successfully",
result=records,
)
class PeopleCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"2d1513f4-44ed-4fa3-84d1-dfbd0eadf9a1": "people_create",
}
__event_validation__ = {
"2d1513f4-44ed-4fa3-84d1-dfbd0eadf9a1": InsertPerson,
}
@classmethod
def people_create(
cls,
data: InsertPerson,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, EmployeeTokenObject):
created_user = People.create_action(data=data, token=token_dict)
People.save()
elif isinstance(token_dict, OccupantTokenObject):
created_user = People.create_action(data=data, token=token_dict)
People.save()
return JSONResponse(
content={
"completed": True,
"message": "Create User record",
"data": created_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
class PeopleUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"e05cf22c-16c4-450b-86c8-417896a26afc": "people_update",
}
__event_validation__ = {"e05cf22c-16c4-450b-86c8-417896a26afc": UpdateUsers}
@classmethod
def people_update(
cls,
data: UpdateUsers,
user_uu_id: str,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
data_dict = data.excluded_dump()
if isinstance(token_dict, EmployeeTokenObject):
find_one_user = Users.filter_one(
Users.uu_id == user_uu_id,
).data
access_authorized_company = Companies.select_action(
duty_id_list=[
token_dict.selected_company.duty_id,
token_dict.selected_company.bulk_duties_id,
],
)
if access_authorized_company.count:
updated_user = find_one_user.update(**data_dict)
Users.save()
return JSONResponse(
content={
"completed": True,
"message": "Update User record",
"data": updated_user,
},
status_code=status.HTTP_200_OK,
)
elif isinstance(token_dict, OccupantTokenObject):
find_one_user = People.filter_one(
People.uu_id == user_uu_id,
).data
access_authorized_company = Companies.select_action(
duty_id_list=[getattr(token_dict, "duty_id")],
filter_expr=[Companies.id == find_one_user.id],
)
if access_authorized_company.count:
data_dict = data.excluded_dump()
updated_user = find_one_user.update(**data_dict)
People.save()
return JSONResponse(
content={"completed": True, "message": "Update User record", "data": {}},
status_code=status.HTTP_200_OK,
)
class PeoplePatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"3ae16d66-090b-4d27-b567-cce1b10a1c3b": "people_patch",
}
__event_validation__ = {"3ae16d66-090b-4d27-b567-cce1b10a1c3b": None}
@classmethod
def people_patch(cls):
return
class PeopleDeleteEventMethods(MethodToEvent):
event_type = "DELETE"
__event_keys__ = {
"7f84c7a2-a120-4867-90d4-6767a41320db": "people_delete",
}
__event_validation__ = {"7f84c7a2-a120-4867-90d4-6767a41320db": None}
PeopleListEventMethod = PeopleListEventMethods(
action=ActionsSchema(endpoint="/people/list")
)
PeopleCreateEventMethod = PeopleCreateEventMethods(
action=ActionsSchema(endpoint="/people/create")
)
PeopleUpdateEventMethod = PeopleUpdateEventMethods(
action=ActionsSchema(endpoint="/people/update")
)
PeoplePatchEventMethod = PeoplePatchEventMethods(
action=ActionsSchema(endpoint="/people/patch")
)

217
api_events/events/identity/users.py Normal file
View File

@@ -0,0 +1,217 @@
import typing
from fastapi import status
from fastapi.responses import JSONResponse
from api_configs import ApiStatic
from databases import MongoQueryIdentity, Users, Companies, People
from databases.no_sql_models.validations import DomainViaUser
from api_events.events.abstract_class import MethodToEvent, ActionsSchema
from api_objects.auth.token_objects import EmployeeTokenObject, OccupantTokenObject
from api_validations.core_response import AlchemyJsonResponse
from api_services.email.service import send_email
from api_services.templates.password_templates import change_your_password_template
from api_validations.validations_request import (
InsertUsers,
UpdateUsers,
PatchRecord,
ListOptions,
RegisterServices2Occupant,
)
class UserListEventMethods(MethodToEvent):
event_type = "SELECT"
__event_keys__ = {
"1483a8a2-d244-4593-b9f8-f1b4bcbefcd5": "user_list",
}
__event_validation__ = {"1483a8a2-d244-4593-b9f8-f1b4bcbefcd5": None}
@classmethod
def user_list(
cls,
list_options: ListOptions,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
raise Users.raise_http_exception(
status_code="HTTP_403_FORBIDDEN",
message="Occupant object can not list users",
error_case="NOTAUTHORIZED",
data={},
)
if "user_uu_id_list" in list_options.query:
people_ids = list_options.query.pop("user_uu_id_list")
people_id_list = (
user.person_id
for user in Users.filter_all(Users.uu_id.in_(people_ids)).data
)
Users.filter_attr = list_options
records = Users.filter_all(
Users.person_id.in_(people_id_list),
)
return AlchemyJsonResponse(
completed=True,
message="Users are listed successfully",
result=records,
)
Users.filter_attr = list_options
records = Users.filter_all()
return AlchemyJsonResponse(
completed=True,
message="Users are listed successfully",
result=records,
)
class UserCreateEventMethods(MethodToEvent):
event_type = "CREATE"
__event_keys__ = {
"8eb50c24-4bdc-4309-9836-f7048daee409": "user_create",
}
__event_validation__ = {"8eb50c24-4bdc-4309-9836-f7048daee409": InsertUsers}
@classmethod
def user_create(
cls,
data: InsertUsers,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
created_user = Users.create_action(create_user=data, token_dict=token_dict)
domain_via_user = DomainViaUser(
**{"user_uu_id": str(created_user.uu_id), "main_domain": "evyos.com.tr"}
)
created_user.save_and_confirm()
mongo_query_identity = MongoQueryIdentity(
company_uuid=created_user.related_company,
)
mongo_query_identity.create_domain_via_user(payload=domain_via_user)
reset_password_token = created_user.reset_password_token(
found_user=created_user
)
send_email_completed = send_email(
subject=f"Dear {created_user.user_tag}, your password has been changed.",
receivers=[str(created_user.email)],
html=change_your_password_template(
user_name=created_user.user_tag,
forgot_link=ApiStatic.forgot_link(forgot_key=reset_password_token),
),
)
if not send_email_completed:
raise created_user.raise_http_exception(
status_code=400, message="Email can not be sent. Try again later"
)
return JSONResponse(
content={
"completed": True,
"message": "Create User record",
"data": created_user.get_dict(),
"password_token": {
"password_token": created_user.password_token,
"password_expires_day": str(created_user.password_expires_day),
"password_expiry_begins": str(created_user.password_expiry_begins),
"hash_password": created_user.hash_password,
"related_company": created_user.related_company,
},
},
status_code=status.HTTP_200_OK,
)
class UserUpdateEventMethods(MethodToEvent):
event_type = "UPDATE"
__event_keys__ = {
"d08a9470-1eb0-4890-a9e8-b6686239d7e9": "user_update",
}
__event_validation__ = {"d08a9470-1eb0-4890-a9e8-b6686239d7e9": UpdateUsers}
@classmethod
def user_update(
cls,
data: UpdateUsers,
user_uu_id: str,
token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
):
find_one_user = Users.filter_one(
Users.uu_id == user_uu_id,
*Users.valid_record_args(Users),
).data
access_authorized_company = Companies.select_action(
duty_id_list=[getattr(token_dict, "duty_id", 5)],
filter_expr=[Companies.id == token_dict.get("")],
)
if access_authorized_company.count:
data_dict = data.excluded_dump()
updated_user = find_one_user.update(**data_dict)
Users.save()
return JSONResponse(
content={
"completed": True,
"message": "Update User record",
"data": updated_user,
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={"completed": True, "message": "Update User record", "data": {}},
status_code=status.HTTP_200_OK,
)
class UserPatchEventMethods(MethodToEvent):
event_type = "PATCH"
__event_keys__ = {
"d26a1a3c-eaeb-4d01-b35b-a5ed714e29c0": "user_patch",
}
__event_validation__ = {"d26a1a3c-eaeb-4d01-b35b-a5ed714e29c0": None}
@classmethod
def user_patch(cls, data: PatchRecord, user_uu_id: str, token_dict):
find_one_user = Users.filter_one(
Users.uu_id == user_uu_id,
).data
access_authorized_company = Companies.select_action(
duty_id_list=[getattr(token_dict, "duty_id", 5)],
filter_expr=[Companies.id == find_one_user.id],
)
if access_authorized_company.count:
action = data.excluded_dump()
find_one_user.active = bool(action.get("active", find_one_user.active))
find_one_user.is_confirmed = bool(
action.get("confirm", find_one_user.is_confirmed)
)
find_one_user.deleted = bool(action.get("delete", find_one_user.deleted))
find_one_user.save()
return JSONResponse(
content={
"completed": True,
"message": "Patch User record completed",
"data": find_one_user.get_dict(),
},
status_code=status.HTTP_200_OK,
)
return JSONResponse(
content={
"completed": False,
"message": "Patch User record failed",
"data": {},
},
status_code=status.HTTP_200_OK,
)
UserListEventMethod = UserListEventMethods(action=ActionsSchema(endpoint="/user/list"))
UserCreateEventMethod = UserCreateEventMethods(
action=ActionsSchema(endpoint="/user/create")
)
UserUpdateEventMethod = UserUpdateEventMethods(
action=ActionsSchema(endpoint="/user/update")
)
UserPatchEventMethod = UserPatchEventMethods(
action=ActionsSchema(endpoint="/user/patch")
)