events updated

api_events/events/company/company_duties.py

@@ -1,6 +1,7 @@
 from fastapi import status
 from fastapi.responses import JSONResponse
 
+from api_validations.core_response import AlchemyJsonResponse
 from api_validations.validations_request import (
     InsertDuties,
     UpdateDuties,
@@ -32,12 +33,11 @@ class DutiesListEventMethods(MethodToEvent):
         records = Duties.filter_all(
             Duties.company_id == token_dict.selected_company.company_id,
         )
-        return {
+        return AlchemyJsonResponse(
-            "completed": True if records.count else False,
+            completed=True,
-            "status": "success",
+            result=records,
-            "data": records.get_dict(),
+            message="List of Duties records",
-        }
+        )
-
 
 class DutiesGetByUUIDEventMethods(MethodToEvent):
 

api_events/events/decision_book/decision_book_decision_book_items.py

@@ -45,7 +45,7 @@ class DecisionBookDecisionBookItemsListEventMethods(MethodToEvent):
         decision_book = BuildDecisionBook.filter_one(
             BuildDecisionBook.uu_id == data.build_decision_book_uu_id,
             *BuildDecisionBook.valid_record_args(BuildDecisionBook),
-        )
+        ).data
         if not decision_book:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
@@ -55,7 +55,7 @@ class DecisionBookDecisionBookItemsListEventMethods(MethodToEvent):
             Build.pre_query = Build.select_action(
                 employee_id=token_dict.selected_company.employee_id,
                 filter_expr=[
-                    Build.uu_id == decision_book.build_decision_book_uu_id,
+                    Build.uu_id == str(decision_book.uu_id),
                 ],
             )
             reachable_building = Build.filter_all()
@@ -70,7 +70,7 @@ class DecisionBookDecisionBookItemsListEventMethods(MethodToEvent):
                     token_dict.selected_company.duty_id,
                     token_dict.selected_company.bulk_duties_id,
                 ],
-                filter_expr=[Companies.id == decision_book.company_id],
+                filter_expr=[Companies.id == decision_book.resp_company_id],
             )
             reachable_companies = Companies.filter_all()
             if not reachable_companies.data:

api_events/events/identity/users.py

@@ -34,10 +34,13 @@ class UserListEventMethods(MethodToEvent):
         list_options: ListOptions,
         token_dict: typing.Union[EmployeeTokenObject, OccupantTokenObject],
     ):
-        # Users.pre_query = Users.select_action(duty_id_list=[
+        if isinstance(token_dict, OccupantTokenObject):
-        #     token_dict.selected_company.duty_id,
+            raise Users.raise_http_exception(
-        #     token_dict.selected_company.bulk_duties_id
+                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 = (
@@ -46,11 +49,11 @@ class UserListEventMethods(MethodToEvent):
                     Users.uu_id.in_(people_ids), *Users.valid_record_args(Users)
                 ).data
             )
-            People.filter_attr = list_options
+            Users.filter_attr = list_options
-            records = People.filter_all(
+            records = Users.filter_all(
-                People.id.in_(people_id_list),
+                Users.person_id.in_(people_id_list),
-                *People.valid_record_args(People),
+                *Users.valid_record_args(Users),
-            ).data
+            )
             return AlchemyJsonResponse(
                 completed=True,
                 message="Users are listed successfully",
@@ -59,7 +62,7 @@ class UserListEventMethods(MethodToEvent):
         Users.filter_attr = list_options
         records = Users.filter_all(
             *Users.valid_record_args(Users),
-        ).data
+        )
         return AlchemyJsonResponse(
             completed=True,
             message="Users are listed successfully",

api_services/redis/auth_actions/token.py

@@ -14,7 +14,7 @@ def parse_token_object_to_dict(request):  # from requests import Request
             return valid_token
         endpoint_active = EndpointRestriction.filter_one(
             EndpointRestriction.endpoint_name.ilike(f"%{endpoint_name}%"),
-            *EndpointRestriction.valid_record_args(EndpointRestriction),
+            system=True,
         ).data
         if not endpoint_active:
             raise HTTPException(
@@ -24,7 +24,7 @@ def parse_token_object_to_dict(request):  # from requests import Request
         if valid_token.user_type == 1:
             if not valid_token.selected_company:
                 raise HTTPException(
-                    status_code=status.HTTP_418_IM_A_TEAPOT,
+                    status_code=status.HTTP_401_UNAUTHORIZED,
                     detail="Selected company is not found in the token object.",
                 )
             selected_event = Events.filter_one(

api_validations/core_response.py

@@ -68,7 +68,7 @@ class AlchemyJsonResponse:
 
         filter_model = first_item.filter_attr
         total_count = cls.result.query.limit(None).offset(None).count()
-        total_page_number = round(total_count / int(first_item.filter_attr.size), 0) + 1
+        total_page_number = round(total_count / int(first_item.filter_attr.size), 0)
 
         pagination_dict = {
             "size/total_count": [cls.result.count, total_count],

databases/sql_models/postgres_database.py

@@ -10,13 +10,12 @@ engine_config = {
     "pool_size": 10,
     "max_overflow": 0,
     "echo": False,
+    "isolation_level": "READ COMMITTED"
 }
 
 engine = create_engine(**engine_config)
-session_config = {"autoflush": True, "bind": engine, "echo": True}
+SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False, echo=True)
-SessionLocal = sessionmaker(**session_config)
 session = scoped_session(sessionmaker(bind=engine))
-session.expunge_all()
 
 Base = declarative_base()
 Base.session = session

databases/sql_models/response_model.py

@@ -19,8 +19,18 @@ class AlchemyResponse:
     @property
     def data(self):
         if self.first:
-            return self.__query.first()
+            try:
-        return self.__query.all()
+                return self.__query.first()
+            except Exception as e:
+                err = e
+                self.__query.session.expunge_all()
+                return None
+        try:
+            return self.__query.all()
+        except Exception as e:
+            err = e
+            self.__query.session.expunge_all()
+            return []
 
     @property
     def count(self):

service_app/handlers_exception/api_exception_handlers/http_exception_handler.py

@@ -21,10 +21,13 @@ def exception_handler_http(request: Request, exc: HTTPException):
             },
         )
     except Exception as e:
-        err = e
         return JSONResponse(
             status_code=exc.status_code,
-            content={"detail": str(exc_detail), "mesasage": f"{e}"},
+            content={
+                "Error": str(exc_detail),
+                "Message": f"{str(e)}",
+                "Data": {}
+            },
         )
 
 

service_app/routers/events/modules/router.py

@@ -16,39 +16,27 @@ modules_route.include_router(modules_route, include_in_schema=True)
 
 @modules_route.post(path="/list", summary="List Active/Delete/Confirm Modules")
 def modules_list(request: Request, list_options: ListOptions):
-    from events.events_modules import ModulesEvents
-
     token_dict = parse_token_object_to_dict(request=request)
-    active_function = getattr(ModulesEvents, "modules_list")
+    return token_dict.available_event(list_options=list_options, token_dict=token_dict)
-    return active_function(list_options=list_options, token_dict=token_dict)
 
 
 @modules_route.post(path="/create", summary="Create Modules with given auth levels")
 def modules_create(request: Request, data: DepartmentsPydantic):
-    from events.events_modules import ModulesEvents
-
     token_dict = parse_token_object_to_dict(request=request)
-    active_function = getattr(ModulesEvents, "modules_create")
+    return token_dict.available_event(data=data, token_dict=token_dict)
-    return active_function(data=data, token_dict=token_dict)
 
 
 @modules_route.post(
     path="/update/{module_uu_id}", summary="Update Modules with given auth levels"
 )
 def modules_update(request: Request, module_uu_id: str, data: DepartmentsPydantic):
-    from events.events_modules import ModulesEvents
-
     token_dict = parse_token_object_to_dict(request=request)
-    active_function = getattr(ModulesEvents, "modules_update")
+    return token_dict.available_event(data=data, module_uu_id=module_uu_id, token_dict=token_dict)
-    return active_function(data=data, module_uu_id=module_uu_id, token_dict=token_dict)
 
 
 @modules_route.patch(
     path="/patch/{module_uu_id}", summary="Patch Modules with given auth levels"
 )
 def modules_patch(request: Request, module_uu_id: str, data: PatchRecord):
-    from events.events_modules import ModulesEvents
-
     token_dict = parse_token_object_to_dict(request=request)
-    active_function = getattr(ModulesEvents, "modules_patch")
+    return token_dict.available_event(data=data, module_uu_id=module_uu_id, token_dict=token_dict)
-    return active_function(data=data, token_dict=token_dict)