Berkay/wag-managment-api-service-version-5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

events initated first endpoint tested

Browse Source
This commit is contained in:
berkay
2025-01-30 16:56:40 +03:00
parent b664f64eb4
commit 9781cae858
31 changed files with 576 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Events/AllEvents/events/account/__init__.py
View File

@@ -1,9 +0,0 @@
"""
Account records package initialization.
"""
from .endpoints import ACCOUNT_RECORDS_CONFIG
__all__ = [
"ACCOUNT_RECORDS_CONFIG",
]

36
Events/AllEvents/events/account/account_records.py
View File

@@ -1,39 +1,51 @@
"""
template related API endpoints.
"""
from typing import Any, Dict
from fastapi import Request
from Events.Engine.abstract_class import MethodToEvent
from Events.base_request_model import EndpointBaseRequestModel, ContextRetrievers
from .account_records import template_event
from ApiLayers.Middleware.token_event_middleware import TokenEventMiddleware
from ApiLayers.ApiValidations.Response.default_response import EndpointSuccessListResponse
from .api_events import account_insert_super_user_event
from .function_handlers import AccountListEventMethods
AuthenticationLoginEventMethods = MethodToEvent(
name="AuthenticationLoginEventMethods",
AccountRecordsEventMethods = MethodToEvent(
name="AccountRecordsEventMethods",
events={
template_event.key: template_event,
account_insert_super_user_event.key: account_insert_super_user_event,
},
headers=[],
errors=[],
url="/login",
decorators_list=[TokenEventMiddleware.event_required],
url="/list",
method="POST",
summary="Login via domain and access key : [email] | [phone]",
description="Login to the system via domain, access key : [email] | [phone]",
)
def authentication_login_with_domain_and_creds_endpoint(
def account_insert_event_endpoint(
request: Request, data: EndpointBaseRequestModel
) -> Dict[str, Any]:
event_2_catch = AuthenticationLoginEventMethods.retrieve_event(
event_function_code=f"{template_event.key}"
context_retriever = ContextRetrievers(func=account_insert_event_endpoint)
event_2_catch = AccountRecordsEventMethods.retrieve_event(
event_function_code=f"{account_insert_super_user_event.key}"
)
context_retriever.event = event_2_catch
data = event_2_catch.REQUEST_VALIDATOR(**data.data)
return event_2_catch.endpoint_callable(request=request, data=data)
AccountListEventMethods.context_retriever = context_retriever
pagination_result = event_2_catch.endpoint_callable(data=data)
return EndpointSuccessListResponse(
code="ACCOUNTS_LIST", lang=context_retriever.token.lang
).as_dict(
data=pagination_result.data, pagination=pagination_result.pagination.as_dict()
)
AuthenticationLoginEventMethods.endpoint_callable = (
authentication_login_with_domain_and_creds_endpoint
AccountRecordsEventMethods.endpoint_callable = (
account_insert_event_endpoint
)

30
Events/AllEvents/events/account/api_events.py
View File

@@ -0,0 +1,30 @@
from ApiLayers.ApiValidations.Request import ListOptions
from ApiLayers.Schemas import AccountRecords
from ApiLayers.LanguageModels.Request import (
LoginRequestLanguageModel,
SelectRequestLanguageModel,
)
from Events.Engine.abstract_class import Event
from .models import AccountRequestValidators
from .function_handlers import (
AccountListEventMethods,
)
# Auth Login
account_insert_super_user_event = Event(
name="account_insert_super_user_event",
key="36a165fe-a2f3-437b-80ee-1ee44670fe70",
request_validator=ListOptions,
# response_validator=SelectRequestLanguageModel,
# language_models=[AccountRecords.__language_model__],
language_models=[],
statics="ACCOUNTS_LIST",
description="List all types of accounts by validation list options and queries.",
)
account_insert_super_user_event.endpoint_callable = (
AccountListEventMethods.account_records_list
)

11
Events/AllEvents/events/account/cluster.py
View File

@@ -1,15 +1,18 @@
from Events.Engine.abstract_class import CategoryCluster
# from info import template_page_info
from .account_records import AccountRecordsEventMethods
from .info import account_page_info
AccountCluster = CategoryCluster(
name="AccountCluster",
tags=["template"],
tags=["accounts"],
prefix="/accounts",
description="Account Cluster",
pageinfo=None,
endpoints={},
pageinfo=account_page_info,
endpoints={
"AccountRecordsEventMethods": AccountRecordsEventMethods,
},
include_in_schema=True,
sub_category=[],
)

131
Events/AllEvents/events/account/endpoints.py
View File

@@ -1,131 +0,0 @@
"""
Account records endpoint configurations.
"""
from ApiEvents.abstract_class import (
RouteFactoryConfig,
EndpointFactoryConfig,
endpoint_wrapper,
)
from ApiEvents.base_request_model import EndpointBaseRequestModel
from Services.PostgresDb.Models.alchemy_response import DictJsonResponse
from fastapi import Request, Path, Body
@endpoint_wrapper("/account/records/list")
async def address_list(request: "Request", data: EndpointBaseRequestModel):
"""Handle address list endpoint."""
auth_dict = address_list.auth
code_dict = getattr(address_list, "func_code", {"function_code": None})
return {"auth_dict": auth_dict, "code_dict": code_dict, "data": data}
@endpoint_wrapper("/account/records/create")
async def address_create(request: "Request", data: EndpointBaseRequestModel):
"""Handle address creation endpoint."""
return {
"data": data,
"request": str(request.headers),
"request_url": str(request.url),
"request_base_url": str(request.base_url),
}
@endpoint_wrapper("/account/records/search")
async def address_search(request: "Request", data: EndpointBaseRequestModel):
"""Handle address search endpoint."""
auth_dict = address_search.auth
code_dict = getattr(address_search, "func_code", {"function_code": None})
return {"auth_dict": auth_dict, "code_dict": code_dict, "data": data}
@endpoint_wrapper("/account/records/{address_uu_id}")
async def address_update(
request: Request,
address_uu_id: str = Path(..., description="UUID of the address to update"),
request_data: EndpointBaseRequestModel = Body(..., description="Request body"),
):
"""
Handle address update endpoint.
Args:
request: FastAPI request object
address_uu_id: UUID of the address to update
request_data: Request body containing updated address data
Returns:
DictJsonResponse: Response containing updated address info
"""
auth_dict = address_update.auth
return DictJsonResponse(
data={
"address_uu_id": address_uu_id,
"data": request_data.root,
"request": str(request.headers),
"request_url": str(request.url),
"request_base_url": str(request.base_url),
}
)
prefix = "/account/records"
# Account Records Router Configuration
ACCOUNT_RECORDS_CONFIG = RouteFactoryConfig(
name="account_records",
prefix=prefix,
tags=["Account Records"],
include_in_schema=True,
endpoints=[
EndpointFactoryConfig(
url_prefix=prefix,
url_endpoint="/list",
url_of_endpoint=f"{prefix}/list",
endpoint="/list",
method="POST",
summary="List Active/Delete/Confirm Address",
description="List Active/Delete/Confirm Address",
is_auth_required=True,
is_event_required=True,
endpoint_function=address_list,
),
EndpointFactoryConfig(
url_prefix=prefix,
url_endpoint="/create",
url_of_endpoint=f"{prefix}/create",
endpoint="/create",
method="POST",
summary="Create Address with given auth levels",
description="Create Address with given auth levels",
is_auth_required=False,
is_event_required=False,
endpoint_function=address_create,
),
EndpointFactoryConfig(
url_prefix=prefix,
url_endpoint="/search",
url_of_endpoint=f"{prefix}/search",
endpoint="/search",
method="POST",
summary="Search Address with given auth levels",
description="Search Address with given auth levels",
is_auth_required=True,
is_event_required=True,
endpoint_function=address_search,
),
EndpointFactoryConfig(
url_prefix=prefix,
url_endpoint="/{address_uu_id}",
url_of_endpoint="{prefix}/" + "{address_uu_id}",
endpoint="/{address_uu_id}",
method="PUT",
summary="Update Address with given auth levels",
description="Update Address with given auth levels",
is_auth_required=True,
is_event_required=True,
endpoint_function=address_update,
),
],
).as_dict()

469
Events/AllEvents/events/account/function_handlers.py
View File

@@ -2,253 +2,215 @@
Account records service implementation.
"""
from typing import Union
from pydantic import Field
from typing import Any, Union, Optional
from Events.base_request_model import TokenDictType, BaseRouteModel
from ApiLayers.ApiLibrary import system_arrow
from ApiLayers.ApiValidations.Custom.token_objects import (
OccupantTokenObject,
EmployeeTokenObject,
)
from ApiLayers.ApiLibrary import system_arrow
from ApiLayers.ApiValidations.Request.account_records import (
from ApiLayers.ApiValidations.Request import (
InsertAccountRecord,
UpdateAccountRecord,
ListOptions,
)
from ApiLayers.ApiValidations.Request.base_validations import ListOptions
from ApiLayers.Schemas import (
BuildLivingSpace,
BuildDecisionBookPayments,
AccountRecords,
BuildIbans,
BuildDecisionBookPayments,
ApiEnumDropdown,
)
from Services.PostgresDb.Models.response import (
PostgresResponse,
)
from ApiLayers.ApiValidations.Response import AccountRecordResponse
from .models import (
InsertAccountRecordRequestModel,
UpdateAccountRecordRequestModel,
ListOptionsRequestModel,
)
from Events.base_request_model import BaseRouteModel, ListOptionsBase
from Services.PostgresDb.Models.pagination import PaginationResult
class AccountListEventMethod(BaseRouteModel):
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": (
AccountRecordResponse,
[AccountRecords.__language_model__],
),
"208e6273-17ef-44f0-814a-8098f816b63a": (
AccountRecordResponse,
[AccountRecords.__language_model__],
),
}
class AccountListEventMethods(BaseRouteModel):
"""
Account records list by with full privileges.
Accepts List Options
{
"data": {
"page": 1,
"size": 10,
"order_field": ["uu_id",]
"order_type": ["desc"],
"query": {
"process_date__gt": "2021-09-01",
}
}
}
"""
@classmethod
def account_records_list(
cls,
list_options: ListOptionsRequestModel,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
db_session = AccountRecords.new_session()
if isinstance(token_dict, OccupantTokenObject):
def account_records_list(cls, data: Optional[Union[dict, ListOptions]]) -> PaginationResult:
list_options_base = ListOptionsBase(
table=AccountRecords, list_options=data, model_query=None,
)
db_session, query_options = list_options_base.init_list_options()
if cls.context_retriever.token.is_occupant:
AccountRecords.pre_query = AccountRecords.filter_all(
AccountRecords.company_id
== token_dict.selected_occupant.responsible_company_id,
== cls.context_retriever.token.selected_occupant.responsible_company_id,
db=db_session,
).query
elif isinstance(token_dict, EmployeeTokenObject):
elif cls.context_retriever.token.is_employee:
AccountRecords.pre_query = AccountRecords.filter_all(
AccountRecords.company_id == token_dict.selected_company.company_id,
AccountRecords.company_id ==
cls.context_retriever.token.selected_company.company_id,
db=db_session,
).query
AccountRecords.filter_attr = list_options
records = AccountRecords.filter_all(db=db_session)
return AlchemyJsonResponse(
completed=True,
message="Account records listed successfully",
result=records,
cls_object=AccountRecords,
filter_attributes=list_options,
response_model=AccountRecordResponse,
)
records = AccountRecords.filter_all(*query_options.convert(), db=db_session)
return list_options_base.paginated_result(records=records)
# @classmethod
# def account_records_list_flt_res(cls, list_options: ListOptions) -> PaginationResult:
# list_options_base = ListOptionsBase(
# table=AccountRecords, list_options=list_options, model_query=None,
# )
# db_session, query_options = list_options_base.init_list_options()
# if not cls.context_retriever.token.is_occupant:
# 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=cls.context_retriever.token.selected_occupant.living_space_id, db=db_session
# ).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
# == cls.context_retriever.token.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 AlchemyJsonResponse(
# completed=True,
# message="Account records listed successfully",
# result=return_list,
# cls_object=AccountRecords,
# filter_attributes=list_options,
# response_model=AccountRecordResponse,
# )
class AccountCreateEventMethods(BaseRouteModel):
@classmethod
def account_records_list_flt_res(
cls,
list_options: ListOptionsRequestModel,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
db_session = AccountRecords.new_session()
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 AlchemyJsonResponse(
completed=True,
message="Account records listed successfully",
result=return_list,
cls_object=AccountRecords,
filter_attributes=list_options,
response_model=AccountRecordResponse,
)
class AccountCreateEventMethod(BaseRouteModel):
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,
[AccountRecords.__language_model__],
),
}
@classmethod
def account_records_create(
cls,
data: InsertAccountRecordRequestModel,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
def account_records_create(cls, data: Any):
data_dict = data.excluded_dump()
if isinstance(token_dict, OccupantTokenObject):
db_session = AccountRecords.new_session()
db_session = AccountRecords.new_session()
if cls.context_retriever.token.is_occupant:
build_iban = BuildIbans.filter_one(
BuildIbans.iban == data.iban,
BuildIbans.build_id == token_dict.selected_occupant.build_id,
BuildIbans.build_id == cls.context_retriever.token.selected_occupant.build_id,
db=db_session,
).data
if not build_iban:
@@ -256,17 +218,15 @@ class AccountCreateEventMethod(BaseRouteModel):
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,
},
data={"iban": data.iban},
)
account_record = AccountRecords.find_or_create(**data.excluded_dump())
return AlchemyJsonResponse(
completed=True,
message="Account record created successfully",
result=account_record,
)
elif isinstance(token_dict, EmployeeTokenObject):
# return AlchemyJsonResponse(
# completed=True,
# message="Account record created successfully",
# result=account_record,
# )
elif cls.context_retriever.token.is_employee:
# Build.pre_query = Build.select_action(
# employee_id=token_dict.selected_employee.employee_id,
# )
@@ -293,58 +253,39 @@ class AccountCreateEventMethod(BaseRouteModel):
if int(data.currency_value) < 0:
debit_type = ApiEnumDropdown.filter_by_one(
system=True, enum_class="DebitTypes", key="DT-D"
system=True, enum_class="DebitTypes", key="DT-D", db=db_session
).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"
system=True, enum_class="DebitTypes", key="DT-R", db=db_session
).data
data_dict["receive_debit"] = debit_type.id
data_dict["receive_debit_uu_id"] = str(debit_type.uu_id)
account_record = AccountRecords.insert_one(data_dict).data
return AlchemyJsonResponse(
completed=True,
message="Account record created successfully",
result=account_record,
)
account_record = AccountRecords.find_or_create(data_dict, db=db_session).data
# return AlchemyJsonResponse(
# completed=True,
# message="Account record created successfully",
# result=account_record,
# )
class AccountUpdateEventMethod(BaseRouteModel):
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,
[AccountRecords.__language_model__],
),
}
class AccountUpdateEventMethods(BaseRouteModel):
@classmethod
def account_records_update(
cls,
build_uu_id: str,
data: UpdateAccountRecordRequestModel,
token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
):
if isinstance(token_dict, OccupantTokenObject):
def account_records_update(cls, build_uu_id: str, data: Any):
if cls.context_retriever.token.is_occupant:
pass
elif isinstance(token_dict, EmployeeTokenObject):
elif cls.context_retriever.token.is_employee:
pass
AccountRecords.build_parts_id = token_dict.selected_occupant.build_part_id
AccountRecords.build_parts_id = cls.context_retriever.token.selected_occupant.build_part_id
account_record = AccountRecords.update_one(build_uu_id, data).data
return AlchemyJsonResponse(
completed=True,
message="Account record updated successfully",
result=account_record,
cls_object=AccountRecords,
response_model=UpdateAccountRecord,
)
# return AlchemyJsonResponse(
# completed=True,
# message="Account record updated successfully",
# result=account_record,
# cls_object=AccountRecords,
# response_model=UpdateAccountRecord,
# )

14
Events/AllEvents/events/account/info.py Normal file
View File

@@ -0,0 +1,14 @@
from Events.Engine.abstract_class import PageInfo
account_page_info = PageInfo(
name="Accounts",
title={"en": "Account Records", "tr": "Hesap Kayıtları"},
description={
"en": "Account Records for reaching user all types account information",
"tr": "Kullanıcı tüm hesap bilgilerine ulaşmak için Hesap Kayıtları"
},
icon="",
parent="",
url="",
)

156
Events/AllEvents/events/account/models.py
View File

@@ -2,53 +2,133 @@
Account records request and response models.
"""
from typing import TYPE_CHECKING, Dict, Any
from pydantic import BaseModel, Field, RootModel
from ApiEvents.base_request_model import BaseRequestModel
from typing import TYPE_CHECKING, Dict, Any, Optional
from pydantic import BaseModel
if TYPE_CHECKING:
from ApiValidations.Request import (
InsertAccountRecord,
UpdateAccountRecord,
ListOptions,
)
from ApiLayers.ApiValidations.Request import PydanticBaseModel
class AddressUpdateRequest(RootModel[Dict[str, Any]]):
"""Request model for address update."""
class InsertAccountRecord(PydanticBaseModel):
model_config = {
"json_schema_extra": {
"example": {
"street": "123 Main St",
"city": "Example City",
"country": "Example Country",
}
}
}
iban: str
bank_date: str
currency_value: float
bank_balance: float
currency: str
additional_balance: float
channel_branch: str
process_name: str
process_type: str
process_comment: str
bank_reference_code: str
add_comment_note: Optional[str] = None
is_receipt_mail_send: Optional[bool] = None
found_from: Optional[str] = None
similarity: Optional[float] = None
remainder_balance: Optional[float] = None
bank_date_y: Optional[int] = None
bank_date_m: Optional[int] = None
bank_date_w: Optional[int] = None
bank_date_d: Optional[int] = None
approving_accounting_record: Optional[bool] = None
accounting_receipt_date: Optional[str] = None
accounting_receipt_number: Optional[int] = None
approved_record: Optional[bool] = None
import_file_name: Optional[str] = None
# receive_debit_uu_id: Optional[str] = None
budget_type_uu_id: Optional[str] = None
company_uu_id: Optional[str] = None
send_company_uu_id: Optional[str] = None
customer_id: Optional[str] = None
customer_uu_id: Optional[str] = None
send_person_uu_id: Optional[str] = None
approving_accounting_person_uu_id: Optional[str] = None
build_parts_uu_id: Optional[str] = None
build_decision_book_uu_id: Optional[str] = None
class AddressUpdateResponse(BaseModel):
"""Response model for address update."""
class UpdateAccountRecord(PydanticBaseModel):
address_uu_id: str = Field(..., description="UUID of the updated address")
data: Dict[str, Any] = Field(..., description="Updated address data")
function_code: str = Field(..., description="Function code for the endpoint")
iban: Optional[str] = None
bank_date: Optional[str] = None
currency_value: Optional[float] = None
bank_balance: Optional[float] = None
currency: Optional[str] = None
additional_balance: Optional[float] = None
channel_branch: Optional[str] = None
process_name: Optional[str] = None
process_type: Optional[str] = None
process_comment: Optional[str] = None
bank_reference_code: Optional[str] = None
add_comment_note: Optional[str] = None
is_receipt_mail_send: Optional[bool] = None
found_from: Optional[str] = None
similarity: Optional[float] = None
remainder_balance: Optional[float] = None
bank_date_y: Optional[int] = None
bank_date_m: Optional[int] = None
bank_date_w: Optional[int] = None
bank_date_d: Optional[int] = None
approving_accounting_record: Optional[bool] = None
accounting_receipt_date: Optional[str] = None
accounting_receipt_number: Optional[int] = None
approved_record: Optional[bool] = None
import_file_name: Optional[str] = None
receive_debit_uu_id: Optional[str] = None
budget_type_uu_id: Optional[str] = None
company_uu_id: Optional[str] = None
send_company_uu_id: Optional[str] = None
customer_id: Optional[str] = None
customer_uu_id: Optional[str] = None
send_person_uu_id: Optional[str] = None
approving_accounting_person_uu_id: Optional[str] = None
build_parts_uu_id: Optional[str] = None
build_decision_book_uu_id: Optional[str] = None
class InsertAccountRecordRequestModel(BaseRequestModel["InsertAccountRecord"]):
"""Request model for inserting account records."""
class ListAccountRecord(PydanticBaseModel):
pass
iban: Optional[str] = None
bank_date: Optional[str] = None
currency_value: Optional[float] = None
bank_balance: Optional[float] = None
currency: Optional[str] = None
additional_balance: Optional[float] = None
channel_branch: Optional[str] = None
process_name: Optional[str] = None
process_type: Optional[str] = None
process_comment: Optional[str] = None
bank_reference_code: Optional[str] = None
add_comment_note: Optional[str] = None
is_receipt_mail_send: Optional[bool] = None
found_from: Optional[str] = None
similarity: Optional[float] = None
remainder_balance: Optional[float] = None
bank_date_y: Optional[int] = None
bank_date_m: Optional[int] = None
bank_date_w: Optional[int] = None
bank_date_d: Optional[int] = None
approving_accounting_record: Optional[bool] = None
accounting_receipt_date: Optional[str] = None
accounting_receipt_number: Optional[int] = None
approved_record: Optional[bool] = None
import_file_name: Optional[str] = None
receive_debit_uu_id: Optional[str] = None
budget_type_uu_id: Optional[str] = None
company_uu_id: Optional[str] = None
send_company_uu_id: Optional[str] = None
customer_id: Optional[str] = None
customer_uu_id: Optional[str] = None
send_person_uu_id: Optional[str] = None
approving_accounting_person_uu_id: Optional[str] = None
build_parts_uu_id: Optional[str] = None
build_decision_book_uu_id: Optional[str] = None
class UpdateAccountRecordRequestModel(BaseRequestModel["UpdateAccountRecord"]):
"""Request model for updating account records."""
pass
class ListOptionsRequestModel(BaseRequestModel["ListOptions"]):
"""Request model for list options."""
pass
class AccountRequestValidators:
InsertAccountRecord = InsertAccountRecord
UpdateAccountRecord = UpdateAccountRecord
ListAccountRecord = ListAccountRecord