init defaults completed

api_events/events/__init__.py

@@ -1,7 +1,6 @@
 from api_events.events.identity.people import (
     PeopleListEventMethod,
     PeopleCreateEventMethod,
-    PeopleDeleteEventMethod,
     PeopleUpdateEventMethod,
     PeoplePatchEventMethod,
 )
@@ -136,7 +135,6 @@ __all__ = [
     "AddressPostCodeUpdateEventMethod",
     "AddressPostCodeListEventMethod",
     "PeopleListEventMethod",
-    "PeopleDeleteEventMethod",
     "PeopleUpdateEventMethod",
     "PeoplePatchEventMethod",
     "PeopleCreateEventMethod",

api_events/events/abstract_class.py

@@ -14,8 +14,9 @@ class ActionsSchema(ABC):
         from databases import EndpointRestriction
 
         endpoint_restriction = EndpointRestriction.filter_one(
-            EndpointRestriction.endpoint_name.ilike(f"%{self.endpoint}%")
+            EndpointRestriction.endpoint_name.ilike(f"%{self.endpoint}%"),
-        ).get(1)
+            system=True
+        ).data
         if not endpoint_restriction:
             raise HTTPException(
                 status_code=404,
@@ -32,7 +33,7 @@ class ActionsSchemaFactory:
             self.action_match = self.action.retrieve_action_from_endpoint()
         except Exception as e:
             err = e
-            self.action_match = None
+            print(f"ActionsSchemaFactory Error: {e}")
 
 
 class MethodToEvent(ABC, ActionsSchemaFactory):

api_events/events/address/address.py

@@ -154,7 +154,7 @@ class AddressSearchEventMethods(MethodToEvent):
         data: SearchAddress,
         token_dict: Union[EmployeeTokenObject, OccupantTokenObject],
     ):
-        import databases as database_sql_models
+        import databases.sql_models
         from time import perf_counter
 
         st = perf_counter()
@@ -171,7 +171,7 @@ class AddressSearchEventMethods(MethodToEvent):
             filter_list["order_field"] = "uu_id"
         else:
             filter_table = getattr(
-                database_sql_models, str(filter_list.get("order_field")).split(".")[0]
+                databases.sql_models, str(filter_list.get("order_field")).split(".")[0]
             )
             filter_list["order_field"] = str(filter_list.get("order_field")).split(".")[
                 1

api_events/events/application/authentication.py

@@ -558,7 +558,7 @@ class AuthenticationRefreshTokenEventMethods(MethodToEvent):
         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
+            token=data.refresh_token, domain=data.domain, **UsersTokens.valid_record_dict
         ).data
         if not token_refresher:
             return JSONResponse(

api_events/events/authentication.py

@@ -155,7 +155,7 @@ class AuthenticationSelectEventMethods(MethodToEvent):
                     Departments.id == duties.department_id,
                 ).data
                 bulk_id = Duty.filter_by_one(
-                    duty_code="BULK", *Duty.valid_record_args(Duty)
+                    duty_code="BULK", **Duty.valid_record_args(Duty)
                 ).data
                 bulk_duty_id = Duties.filter_by_one(
                     company_id=selected_company.id,

api_events/events/building/building_build.py

@@ -84,7 +84,7 @@ class BuildCreateEventMethods(MethodToEvent):
         created_build = Build.create_action(data=data, token=token_dict)
 
         build_type = BuildTypes.filter_by_one(
-            type_code="APT_YNT", *BuildTypes.valid_record_dict
+            **BuildTypes.valid_record_dict, type_code="APT_YNT"
         ).data
         if not build_type:
             raise HTTPException(

api_events/events/events/events_bind_services.py

@@ -188,8 +188,8 @@ class ServiceBindEmployeeEventMethods(MethodToEvent):
     def bind_services_employee(cls, service_id: int, employee_id: int):
         from sqlalchemy.dialects.postgresql import insert
 
-        employee = Employees.filter_by_one(id=employee_id, *Employees.valid_record_dict).data
+        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
+        service = Services.filter_by_one(id=service_id, **Services.valid_record_dict).data
         service_events = Service2Events.filter_all(
             Service2Events.service_id == service.id,
             *Service2Events.valid_record_args(Service2Events),
@@ -236,7 +236,7 @@ class ServiceBindEmployeeEventMethods(MethodToEvent):
             )
 
         employee = Employees.filter_by_one(
-            uu_id=data.employee_uu_id, *Employees.valid_record_dict
+            uu_id=data.employee_uu_id, **Employees.valid_record_dict
         ).data
         if not employee:
             return JSONResponse(
@@ -249,7 +249,7 @@ class ServiceBindEmployeeEventMethods(MethodToEvent):
             )
 
         service = Services.filter_by_one(
-            uu_id=data.service_uu_id, *Services.valid_record_dict
+            uu_id=data.service_uu_id, **Services.valid_record_dict
         ).data
         if not service:
             return JSONResponse(

api_events/events/events/events_events.py

@@ -83,7 +83,7 @@ class EventsUpdateEventMethods(MethodToEvent):
 
     @classmethod
     def events_update(cls, data: CreateEvents, token_dict):
-        event = Events.filter_by_one(uu_id=data.uu_id, *Events.valid_record_dict).data
+        event = Events.filter_by_one(uu_id=data.uu_id, **Events.valid_record_dict).data
         if not event:
             raise HTTPException(
                 status_code=404,
@@ -113,7 +113,7 @@ class EventsPatchEventMethods(MethodToEvent):
 
     @classmethod
     def events_patch(cls, data: CreateEvents, token_dict):
-        event = Events.filter_by_one(uu_id=data.uu_id, *Events.valid_record_dict).data
+        event = Events.filter_by_one(uu_id=data.uu_id, **Events.valid_record_dict).data
         if not event:
             raise HTTPException(
                 status_code=404,

api_events/events/identity/people.py

@@ -166,6 +166,3 @@ PeopleUpdateEventMethod = PeopleUpdateEventMethods(
 PeoplePatchEventMethod = PeoplePatchEventMethods(
     action=ActionsSchema(endpoint="/people/patch")
 )
-PeopleDeleteEventMethod = PeopleDeleteEventMethods(
-    action=ActionsSchema(endpoint="/people/delete")
-)

api_events/tasks2events/default_abstract.py

@@ -2,15 +2,13 @@ class AddEventFunctionality:
 
     @classmethod
     def retrieve_events(cls, events) -> list[tuple[int, str]]:
-        from database_sql_models import Events
+        from databases import Events
-        from sqlalchemy import select
 
-        get_event_ids = Events.session.execute(
+        get_event_ids = Events.filter_all(
-            select(Events.id, Events.uu_id).where(
+            Events.function_code.in_([event["function_code"] for event in events]),
-                Events.function_code.in_([event["function_code"] for event in events])
+            system=True
-            )
+        ).data
-        ).all()
         if get_event_ids:
-            return [(get_event[0], str(get_event[1])) for get_event in get_event_ids]
+            return [(get_event.id, str(get_event.uu_id)) for get_event in get_event_ids]
         else:
             raise Exception("No event found")

api_library/date_time_actions/date_functions.py

@@ -47,6 +47,3 @@ class DateTimeLocal:
 
 client_arrow = DateTimeLocal(is_client=True)
 system_arrow = DateTimeLocal(is_client=False)
-
-print(client_arrow.string_time_only(arrow.utcnow()))
-print(system_arrow.string_time_only(arrow.utcnow()))

api_services/redis/auth_actions/auth.py

@@ -5,16 +5,6 @@ from fastapi import status
 from fastapi.exceptions import HTTPException
 
 from api_configs import Auth
-from databases import (
-    BuildLivingSpace,
-    BuildParts,
-    Companies,
-    Duties,
-    Departments,
-    Duty,
-    Employees,
-    Staff,
-)
 from api_objects import (
     OccupantTokenObject,
     EmployeeTokenObject,
@@ -50,6 +40,16 @@ def save_object_to_redis(
 def save_access_token_to_redis(
     request, found_user, domain: str, access_token: str = None
 ):
+    from databases import (
+        BuildLivingSpace,
+        BuildParts,
+        Companies,
+        Duties,
+        Departments,
+        Duty,
+        Employees,
+        Staff,
+    )
     if not found_user:
         raise HTTPException(
             status_code=400,

api_services/redis/auth_actions/token.py

@@ -1,12 +1,10 @@
 from fastapi import HTTPException, status
 from fastapi.requests import Request
 
-from databases import Events
-
 
 def parse_token_object_to_dict(request: Request):  # from requests import Request
     from api_services.redis.functions import get_object_via_access_key
-    from databases import EndpointRestriction
+    from databases import EndpointRestriction, Events
     import api_events.events as events
 
     if valid_token := get_object_via_access_key(request=request):

databases/extensions/auth.py

@@ -8,13 +8,6 @@ from datetime import timedelta
 from fastapi.exceptions import HTTPException
 from fastapi import status
 
-from databases import (
-    Users,
-    People,
-    Companies,
-    UsersTokens,
-    MongoQueryIdentity,
-)
 from databases.no_sql_models.validations import (
     PasswordHistoryViaUser,
     AccessHistoryViaUser,
@@ -46,7 +39,7 @@ class AuthModule(PasswordModule):
 
     @classmethod
     def check_user_exits(cls, access_key, domain):
-        found_user: Users = cls.filter_one(
+        found_user = cls.filter_one(
             or_(
                 cls.email == str(access_key).lower(),
                 cls.phone_number == str(access_key).replace(" ", ""),
@@ -72,6 +65,9 @@ class AuthModule(PasswordModule):
         return self.generate_token(Auth.ACCESS_TOKEN_LENGTH)
 
     def remove_refresher_token(self, domain, disconnect: bool = False):
+        from databases import (
+            UsersTokens,
+        )
         if disconnect:
             registered_tokens = UsersTokens.filter_all(
                 UsersTokens.user_id == self.id, system=True
@@ -110,6 +106,9 @@ class AuthModule(PasswordModule):
             )
 
     def create_password(self, password, password_token=None):
+        from databases import (
+            MongoQueryIdentity,
+        )
         if self.password_token:
             replace_day = 0
             try:
@@ -161,6 +160,9 @@ class AuthModule(PasswordModule):
         self.save()
 
     def generate_refresher_token(self, domain: str, remember_me=False):
+        from databases import (
+            UsersTokens,
+        )
         if remember_me:
             refresh_token = self.generate_token(Auth.REFRESHER_TOKEN_LENGTH)
             if already_token := UsersTokens.find_one(
@@ -200,7 +202,11 @@ class UserLoginModule(AuthModule):
 
     @classmethod
     def login_user_with_credentials(cls, data, request):
-
+        from databases import (
+            Users,
+            People,
+            MongoQueryIdentity,
+        )
         found_user = Users.check_user_exits(
             access_key=data.access_key, domain=data.domain
         )

databases/no_sql_models/mongo_database.py

@@ -40,8 +40,8 @@ class MongoQuery:
 
     def __init__(self, table_name: str, database_name: str):
         database = MongoClient(MongoConfig.url)[database_name]
-        if table_name not in database.collection_names():
+        # if table_name not in database.collection_names():
-            database.create_collection(name=table_name)
+        #     database.create_collection(name=table_name)
         self.table: Collection = database[table_name]
 
     @staticmethod

databases/sql_models/building/decision_book.py

@@ -438,7 +438,7 @@ class BuildDecisionBookPerson(CrudCollection):
             if build_living_space_id:
                 related_service = Services.filter_by_one(
                     related_responsibility=str(occupant_type.occupant_code),
-                    *Services.valid_record_dict,
+                    **Services.valid_record_dict,
                 ).data
                 if not related_service:
                     raise HTTPException(

databases/sql_models/company/company.py

@@ -194,14 +194,14 @@ class Companies(CrudCollection, SelectAction):
     parent_id = mapped_column(Integer, nullable=True)
     workplace_no: Mapped[str] = mapped_column(String, nullable=True)
 
-    official_address_id: Mapped[int] = mapped_column(ForeignKey("addresses.id"))
+    official_address_id: Mapped[int] = mapped_column(ForeignKey("addresses.id"), nullable=True)
-    official_address_uu_id = mapped_column(
+    official_address_uu_id: Mapped[str] = mapped_column(
         String, nullable=True, comment="Official Address UUID"
     )
-    top_responsible_company_id = mapped_column(
+    top_responsible_company_id: Mapped[int] = mapped_column(
         ForeignKey("companies.id"), nullable=True
     )
-    top_responsible_company_uu_id = mapped_column(
+    top_responsible_company_uu_id: Mapped[str] = mapped_column(
         String, nullable=True, comment="Top Responsible Company UUID"
     )
 

databases/sql_models/company/department.py

@@ -90,6 +90,7 @@ class Duties(CrudCollection):
         active_row = dict(
             is_confirmed=True, active=True, deleted=False, is_notification_send=True
         )
+        list_of_created = []
 
         execution = Departments.find_or_create(
             department_name="Execution Office",
@@ -98,6 +99,7 @@ class Duties(CrudCollection):
             company_uu_id=str(company_uu_id),
             **active_row,
         )
+        list_of_created.append(execution)
         it_dept = Departments.find_or_create(
             department_name="IT Department",
             department_code="ITD001",
@@ -105,39 +107,46 @@ class Duties(CrudCollection):
             company_uu_id=str(company_uu_id),
             **active_row,
         )
+        list_of_created.append(it_dept)
         bm_duty = Duty.find_or_create(
             duty_name="Business Manager",
             duty_code="BM0001",
             duty_description="Business Manager",
             **active_row,
         )
+        list_of_created.append(bm_duty)
         it_duty = Duty.find_or_create(
             duty_name="IT Manager",
             duty_code="IT0001",
             duty_description="IT Manager",
             **active_row,
         )
+        list_of_created.append(it_duty)
         bulk_duty = Duty.find_or_create(
             duty_name="BULK",
             duty_code="BULK",
             duty_description="BULK RECORDS OF THE COMPANY",
             **active_row,
         )
+        list_of_created.append(bulk_duty)
         occu_duty = Duty.find_or_create(
             duty_name="OCCUPANT",
             duty_code="OCCUPANT",
             duty_description="OCCUPANT RECORDS OF THE COMPANY",
             **active_row,
         )
-        cls.find_or_create(
+        list_of_created.append(occu_duty)
+        duties_created_bm = cls.find_or_create(
             company_id=company_id,
             company_uu_id=str(company_uu_id),
             duties_id=bm_duty.id,
             duties_uu_id=str(bm_duty.uu_id),
             department_id=execution.id,
+            department_uu_id=str(execution.uu_id),
             **active_row,
         )
-        cls.find_or_create(
+        list_of_created.append(duties_created_bm)
+        duties_created_it = cls.find_or_create(
             company_id=company_id,
             company_uu_id=str(company_uu_id),
             duties_id=it_duty.id,
@@ -146,7 +155,8 @@ class Duties(CrudCollection):
             department_uu_id=str(it_dept.uu_id),
             **active_row,
         )
-        cls.find_or_create(
+        list_of_created.append(duties_created_it)
+        duties_created__ex = cls.find_or_create(
             company_id=company_id,
             company_uu_id=str(company_uu_id),
             duties_id=bulk_duty.id,
@@ -155,7 +165,8 @@ class Duties(CrudCollection):
             department_uu_id=str(execution.uu_id),
             **active_row,
         )
-        cls.find_or_create(
+        list_of_created.append(duties_created__ex)
+        duties_created_at = cls.find_or_create(
             company_id=company_id,
             company_uu_id=str(company_uu_id),
             duties_id=occu_duty.id,
@@ -164,6 +175,9 @@ class Duties(CrudCollection):
             department_uu_id=str(execution.uu_id),
             **active_row,
         )
+        list_of_created.append(duties_created_at)
+        return list_of_created
+
 
     @classmethod
     def get_bulk_duties_of_a_company(cls, company_id):

databases/sql_models/core_mixin.py

@@ -1,6 +1,5 @@
 import datetime
 from decimal import Decimal
-from typing import Union
 
 from sqlalchemy import (
     TIMESTAMP,
@@ -24,8 +23,6 @@ from sqlalchemy_mixins.repr import ReprMixin
 from sqlalchemy_mixins.smartquery import SmartQueryMixin
 
 from api_library.date_time_actions.date_functions import DateTimeLocal, client_arrow
-from api_objects import EmployeeTokenObject, OccupantTokenObject
-from api_objects.auth.token_objects import Credentials
 
 from databases.sql_models.sql_operations import FilterAttributes
 from databases.sql_models.postgres_database import Base
@@ -80,7 +77,7 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
         "created_by_id",
     ]
 
-    creds: Credentials = None  # The credentials to use in the model.
+    creds = None  # The credentials to use in the model.
     client_arrow: DateTimeLocal = None  # The arrow to use in the model.
     valid_record_dict: dict = {"active": True, "deleted": False}
     valid_record_args = lambda class_: [class_.active == True, class_.deleted == False]
@@ -94,7 +91,7 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
 
     @classmethod
     def set_user_define_properties(
-        cls, token: Union[EmployeeTokenObject, OccupantTokenObject]
+        cls, token
     ):
         cls.creds = token.credentials
         cls.client_arrow = DateTimeLocal(is_client=True, timezone=token.timezone)
@@ -149,7 +146,6 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
                 formatted_date = client_arrow.get(str(val)).format(
                     "DD-MM-YYYY HH:mm:ss"
                 )
-                print(key, "isinstance(value_type, datetime) | ", formatted_date)
                 return str(formatted_date) if val else None
             elif isinstance(value_type, bool):
                 return bool(val) if val else None
@@ -175,7 +171,7 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
         """
         check_kwargs = cls.extract_system_fields(kwargs)
         cls.pre_query = cls.query.filter(cls.expiry_ends < system_arrow.now().date())
-        already_record = cls.filter_by_one(**check_kwargs, system=True).data
+        already_record = cls.filter_by_one(system=True, **check_kwargs).data
         cls.pre_query = None
         if already_record:
             if already_record.deleted:
@@ -202,9 +198,10 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
         created_record = cls()
         for key, value in check_kwargs.items():
             setattr(created_record, key, value)
-        created_record.flush()
+        if getattr(cls.creds, 'person_id', None) and getattr(cls.creds, 'person_name', None):
             cls.created_by_id = cls.creds.person_id
             cls.created_by = cls.creds.person_name
+        created_record.flush()
         return created_record
 
     def update(self, **kwargs):
@@ -223,9 +220,11 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
             setattr(self, key, value)
 
         if is_confirmed_argument:
+            if getattr(self.creds, 'person_id', None) and getattr(self.creds, 'person_name', None):
                 self.confirmed_by_id = self.creds.person_id
                 self.confirmed_by = self.creds.person_name
         else:
+            if getattr(self.creds, 'person_id', None) and getattr(self.creds, 'person_name', None):
                 self.updated_by_id = self.creds.person_id
                 self.updated_by = self.creds.person_name
         self.flush()
@@ -252,8 +251,6 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
             exclude.extend(
                 list(set(self.__exclude__fields__ or []).difference(exclude))
             )
-            for i in self.__system_default_model__:
-                print("i", str(i)[-2:])
             exclude.extend(
                 [
                     element
@@ -278,27 +275,27 @@ class CrudMixin(Base, SmartQueryMixin, SessionMixin, FilterAttributes):
                 if value_of_database is not None:
                     return_dict[key] = value_of_database
 
-        all_arguments = [
+        # all_arguments = [
-            record
+        #     record
-            for record in self.__class__.__dict__
+        #     for record in self.__class__.__dict__
-            if "_" not in record[0] and "id" not in record[-2:]
+        #     if "_" not in record[0] and "id" not in record[-2:]
-        ]
+        # ]
-
+        #
-        for all_argument in all_arguments:
+        # for all_argument in all_arguments:
-            column = getattr(self.__class__, all_argument)
+        #     column = getattr(self.__class__, all_argument)
-            is_populate = isinstance(column, InstrumentedAttribute) and not hasattr(
+        #     is_populate = isinstance(column, InstrumentedAttribute) and not hasattr(
-                column, "foreign_keys"
+        #         column, "foreign_keys"
-            )
+        #     )
-            if is_populate and all_argument in include_joins or []:
+        #     if is_populate and all_argument in include_joins or []:
-                populate_arg = getattr(self, all_argument, None)
+        #         populate_arg = getattr(self, all_argument, None)
-                if isinstance(populate_arg, list):
+        #         if isinstance(populate_arg, list):
-                    return_dict[all_argument] = [
+        #             return_dict[all_argument] = [
-                        arg.get_dict() if arg else [] for arg in populate_arg
+        #                 arg.get_dict() if arg else [] for arg in populate_arg
-                    ]
+        #             ]
-                elif getattr(populate_arg, "get_dict", None):
+        #         elif getattr(populate_arg, "get_dict", None):
-                    return_dict[all_argument] = (
+        #             return_dict[all_argument] = (
-                        populate_arg.get_dict() if populate_arg else []
+        #                 populate_arg.get_dict() if populate_arg else []
-                    )
+        #             )
         return dict(sorted(return_dict.items(), reverse=False))
 
 

databases/sql_models/identity/identity.py

@@ -36,7 +36,9 @@ class UsersTokens(CrudCollection):
     token_type: Mapped[str] = mapped_column(String(16), server_default="RememberMe")
     token: Mapped[str] = mapped_column(String, server_default="")
     domain: Mapped[str] = mapped_column(String, server_default="")
-    expires_at = mapped_column(TIMESTAMP, default=str(system_arrow.shift(days=3)))
+    expires_at = mapped_column(
+        TIMESTAMP, default=str(system_arrow.shift(date=system_arrow.now(),days=3))
+    )
 
     # users = relationship("Users", back_populates="tokens", foreign_keys=[user_id])
 

docker-compose.yml

@@ -1,24 +1,24 @@
 services:
 
-#  commercial_mongo_service:
+  commercial_mongo_service:
-#    container_name: commercial_mongo_service
+    container_name: commercial_mongo_service
-#    image: "bitnami/mongodb:latest"
+    image: "bitnami/mongodb:latest"
-##    image: "bitnami/mongodb:4.4.1-debian-10-r3"
+#    image: "bitnami/mongodb:4.4.1-debian-10-r3"
-#    networks:
+    networks:
-#      - network_store_services
+      - network_store_services
-#    environment:
+    environment:
-#      - MONGODB_DISABLE_ENFORCE_AUTH=true
+      - MONGODB_DISABLE_ENFORCE_AUTH=true
-#      - MONGODB_ROOT_PASSWORD=root
+      - MONGODB_ROOT_PASSWORD=root
-#      - MONGODB_DATABASE=mongo_database
+      - MONGODB_DATABASE=mongo_database
-#      - MONGODB_USERNAME=mongo_user
+      - MONGODB_USERNAME=mongo_user
-#      - MONGODB_PASSWORD=mongo_password
+      - MONGODB_PASSWORD=mongo_password
-#      - MONGO_INITDB_ROOT_USERNAME=mongo_user
+      - MONGO_INITDB_ROOT_USERNAME=mongo_user
-#      - MONGO_INITDB_ROOT_PASSWORD=mongo_password
+      - MONGO_INITDB_ROOT_PASSWORD=mongo_password
-#      - MONGO_INITDB_DATABASE=mongo_database
+      - MONGO_INITDB_DATABASE=mongo_database
-#    volumes:
+    volumes:
-#      - wag_commercial_mongodb_data:/bitnami/mongodb
+      - wag_commercial_mongodb_data:/bitnami/mongodb
-#    ports:
+    ports:
-#      - "11110:27017"
+      - "11110:27017"
 
   commercial_memory_service:
     container_name: commercial_memory_service
@@ -44,6 +44,8 @@ services:
       - POSTGRES_DB=wag_database
       - POSTGRES_USER=berkay_wag_user
       - POSTGRES_PASSWORD=berkay_wag_user_password
+    depends_on:
+      - commercial_mongo_service
     ports:
       - "5434:5432"
     volumes:
@@ -60,6 +62,7 @@ services:
     networks:
       - network_store_services
     depends_on:
+      - wag_management_init_service
       - grafana
 
   wag_management_service_second:
@@ -73,6 +76,7 @@ services:
     networks:
       - network_store_services
     depends_on:
+      - wag_management_init_service
       - grafana
 
   wag_management_init_service:
@@ -83,7 +87,7 @@ services:
     networks:
       - network_store_services
     depends_on:
-      - wag_management_service
+      - postgres_commercial
 
   wag_management_test_service:
     container_name: wag_management_test_service
@@ -164,7 +168,7 @@ volumes:
   wag_cronjob-volume:
   wag_postgres_commercial_data:
   grafana_data:
-#  wag_commercial_mongodb_data:
+  wag_commercial_mongodb_data:
 
 #    environment:
 #      - DATABASE_URL=postgresql+psycopg2://berkay_wag_user:berkay_wag_user_password@postgres_commercial:5432/wag_database

service_app/app.py

@@ -5,16 +5,14 @@ from fastapi.exceptions import HTTPException
 
 from middlewares.token_middleware import AuthHeaderMiddleware
 from application.create_file import create_app
-from application.app_runner_init import create_endpoints_from_api_functions
 from handlers_exception import (
     exception_handler_http,
     exception_handler_exception,
 )
 from prometheus_fastapi_instrumentator import Instrumentator
-# from prometheus_client import Counter, Histogram
+import routers
 
-
+app = create_app(routers=routers)
-app = create_app()
 Instrumentator().instrument(app=app).expose(app=app)
 
 app.add_middleware(
@@ -30,7 +28,6 @@ app.add_middleware(AuthHeaderMiddleware)
 
 app.add_exception_handler(HTTPException, exception_handler_http)
 app.add_exception_handler(Exception, exception_handler_exception)
-create_endpoints_from_api_functions(api_app=app)
 
 if __name__ == "__main__":
     uvicorn_config = {

service_app/application/app_runner_init.py

@@ -1,34 +0,0 @@
-from databases import EndpointRestriction
-
-
-def create_endpoints_from_api_functions(api_app):
-
-    for route in api_app.routes:
-        route_path, route_summary = (
-            str(getattr(route, "path")),
-            str(getattr(route, "name")) or "",
-        )
-        # if route_path in Config.INSECURE_PATHS:
-        #     continue
-        # print('route_path ', route_path, 'route_summary', route_summary)
-        create_dict = dict(
-            is_confirmed=True,
-            active=True,
-            deleted=False,
-            is_notification_send=True,
-        )
-        methods = [method.lower() for method in getattr(route, "methods")]
-        for route_method in methods:
-            restriction = EndpointRestriction.find_or_create(
-                **dict(
-                    endpoint_method=route_method,
-                    endpoint_name=route_path,
-                    endpoint_desc=route_summary.replace("_", " "),
-                    endpoint_function=route_summary,
-                    **create_dict,
-                )
-            )
-            if not restriction.is_found:
-                restriction.endpoint_code = f"AR{str(restriction.id).zfill(3)}"
-                restriction.save()
-    return

service_app/application/create_file.py

@@ -1,11 +1,10 @@
-def create_app():
+def create_app(routers):
     from fastapi import FastAPI
     from fastapi.responses import JSONResponse
     from fastapi.openapi.utils import get_openapi
     from fastapi.responses import RedirectResponse
 
     from api_configs import Config
-    import routers
 
     api_app = FastAPI(title=str(Config.TITLE), default_response_class=JSONResponse)
 

service_app/requirements.txt

@@ -1,4 +1,5 @@
 arrow
+requests
 Deprecated
 fastapi
 python-dotenv

service_app/routers/__init__.py

@@ -1 +1,89 @@
-__all__ = []
+from .authentication.router import login_route
+from .people.router import people_router
+from .users.router import user_route
+
+from .company.company.router import company_route
+from .company.department.router import department_route
+from .company.duty.router import duty_route
+from .company.duties.router import duties_route
+
+from .building.build.router import build_route
+from .building.buildparts.router import build_parts_route
+from .building.buildarea.router import build_area_route
+from .building.buildsites.router import build_sites_route
+from .building.buildtypes.router import build_types_route
+from .building.livingspaces.router import build_living_space
+
+from .decision_book.decision_book.router import build_decision_book_route
+
+from .decision_book.decision_book_person.router import (
+    build_decision_book_people_route,
+)
+from .decision_book.decision_book_items.router import (
+    build_decision_book_items_route,
+)
+from .project_decision_book.project_decision_book.router import (
+    build_project_decision_book_route,
+)
+from .project_decision_book.project_decision_book_person.router import (
+    build_project_decision_book_person_route,
+)
+from .api.router import internal_route
+from .events.events.router import event_route
+from .company.staff.router import staff_route
+from .company.employee.router import employee_route
+
+from .events.events.bind_events_router import bind_events_route
+from .events.models.router import model_route
+from .events.models.bind_events_router import bind_modules_route
+
+from .events.modelentities.router import model_entities_route
+from .events.modules.router import modules_route
+from .events.services.bind_services_router import bind_services_route
+from .events.services.router import services_route
+
+from .rules.router import endpoint_restriction_route
+from .address.address.router import address_router
+from .address.post_code.router import post_code_router
+from .application.enums_and_drops.router import enums_route
+from .application.occupants.router import occupant_types_route
+from .decision_book.decision_book_invitations.router import build_decision_book_invitations
+
+
+__all__ = [
+    "enums_route",
+    "occupant_types_route",
+    "internal_route",
+    "address_router",
+    "post_code_router",
+    "login_route",
+    "duty_route",
+    "duties_route",
+    "people_router",
+    "user_route",
+    "company_route",
+    "department_route",
+    "build_route",
+    "build_parts_route",
+    "build_sites_route",
+    "build_area_route",
+    "build_living_space",
+    "build_decision_book_route",
+    "build_decision_book_people_route",
+    "build_decision_book_items_route",
+    "build_project_decision_book_route",
+    "staff_route",
+    "employee_route",
+    "build_types_route",
+    "bind_events_route",
+    "event_route",
+    "model_route",
+    "model_entities_route",
+    "modules_route",
+    "bind_services_route",
+    "bind_modules_route",
+    "services_route",
+    "build_project_decision_book_person_route",
+    "endpoint_restriction_route",
+    "build_decision_book_invitations",
+]

service_app/routers/api/router.py

@@ -39,7 +39,7 @@ class BankReceive(BaseModel):
     summary="Receive isbank xls service from mail reader service",
 )
 def is_bank_retrieve_account_records(request: Request, bank_data: ApiReceive):
-    from database_sql_models import AccountRecords
+    from databases import AccountRecords
 
     data_dict = bank_data.model_dump()
     data_bulk = json.loads(zlib.decompress(b64decode(data_dict["data"])))

service_app/routers/events/models/bind_events_router.py

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

service_app_init/Dockerfile

@@ -17,6 +17,10 @@ COPY ../api_configs ./service_app_init/api_configs
 COPY ../api_events ./service_app_init/api_events
 COPY ../api_library ./service_app_init/api_library
 COPY ../api_validations ./service_app_init/api_validations
+COPY ../api_objects ./service_app_init/api_objects
+COPY ../api_services ./service_app_init/api_services
+COPY ../service_app/application ./service_app_init/application
+COPY ../service_app/routers ./service_app_init/routers
 
 WORKDIR /service_app_init
 

service_app_init/initialize_app/__init__.py

@@ -1,20 +1,20 @@
-from service_app_init.initialize_app.initialize_default_department import (
+from .initialize_default_department import (
     create_occupant_types_defaults,
     create_application_defaults,
 )
-from service_app_init.initialize_app.initiator import init_api_enums_build_types
+from .initiator import init_api_enums_build_types
-from service_app_init.initialize_app.model_initator import copy_validations_to_database
+from .model_initator import copy_validations_to_database
-from service_app_init.initialize_app.modules_and_services_init import (
+from .modules_and_services_init import (
     create_endpoints_from_api_functions,
     create_modules_and_services_and_actions,
 )
 
-from service_app_init.initialize_app.event_initator import (
+from .event_initator import (
     add_events_all_services_and_occupant_types,
     create_all_events_from_actions,
     add_events_to_system_super_user,
 )
-from service_app_init.initialize_app.initialize_identity_address_defaults import (
+from .initialize_identity_address_defaults import (
     create_identity_address_defaults,
 )
 

service_app_init/initialize_app/event_initator.py

@@ -21,7 +21,7 @@ active_confirmed = dict(
 
 def create_all_events_from_actions():
     import api_events.events as events
-
+    from databases import EndpointRestriction
     an_empty_list, duplicate_list = [], []
 
     for event in events.__all__:
@@ -32,26 +32,34 @@ def create_all_events_from_actions():
         ) in event_selected.__event_keys__.items():
             an_empty_list.append(event_selected_key)
             event_selected_function = getattr(event_selected, event_selected_one, None)
-
+            if not event_selected.action.endpoint:
-            if endpoint_match := event_selected.action_match:
+                raise Exception(
+                    f"Endpoint not found in {event_selected.__name__} class"
+                )
+            endpoint_restriction = EndpointRestriction.filter_one(
+                EndpointRestriction.endpoint_name.ilike(f"%{event_selected.action.endpoint}%"),
+                system=True
+            ).data
+            if endpoint_restriction:
                 if event_selected_function:
                     selected_event = Events.filter_one(
                         Events.event_type==event_selected.event_type,
                         Events.function_class==event,
                         Events.function_code==event_selected_key,
-                        Events.endpoint_id==endpoint_match.id,
+                        Events.endpoint_id==endpoint_restriction.id,
-                        Events.endpoint_uu_id==str(endpoint_match.uu_id),
+                        Events.endpoint_uu_id==str(endpoint_restriction.uu_id),
-                        *Events.valid_record_args(Events)
+                        system=True
                     ).data
                     if not selected_event:
-                        created_event = Events.create(
+                        created_event = Events.find_or_create(
                             event_type=event_selected.event_type,
                             function_class=event,
                             function_code=event_selected_key,
-                            endpoint_id=endpoint_match.id,
+                            endpoint_id=endpoint_restriction.id,
-                            endpoint_uu_id=str(endpoint_match.uu_id),
+                            endpoint_uu_id=str(endpoint_restriction.uu_id),
                             **active_confirmed
                         )
+                        Events.save()
                         print(f"Event created: {created_event.uu_id}")
 
     for item in an_empty_list:
@@ -63,19 +71,17 @@ def create_all_events_from_actions():
         raise Exception(
             f"Duplicate events found: {duplicate_list}. Check events folder look for given uu-ids."
         )
-
     return True
 
 
 def add_events_all_services_and_occupant_types():
     import api_events.tasks2events as tasks2events
 
-
     for event_block in tasks2events.__all__:
         event_block_class = getattr(tasks2events, event_block)
         service_selected = Services.filter_one(
             Services.service_code==getattr(event_block_class, "service_code", None),
-            *Services.valid_record_args(Services)
+            system=True
         ).data
         if not service_selected:
             raise Exception(f"{event_block_class.service_code} service is not found")
@@ -90,21 +96,24 @@ def add_events_all_services_and_occupant_types():
                 service_uu_id=str(service_selected.uu_id),
                 event_id=event_id,
                 event_uu_id=event_uu_id,
-                **active_confirmed
             )
+            Service2Events.save()
+            Service2Events.is_confirmed = True
+            Service2Events.save()
+    return
 
 
 def add_events_to_system_super_user():
 
-    add_service = Services.filter_by_one(service_code="SRE-SUE", **Services.valid_record_dict).data
+    add_service = Services.filter_by_one(system=True, service_code="SRE-SUE").data
     if not add_service:
         raise Exception("Service not found")
 
-    find_staff = Staff.filter_by_one(staff_code="SUE", **Staff.valid_record_dict).data
+    find_staff = Staff.filter_by_one(system=True, staff_code="SUE").data
     if not find_staff:
         raise Exception("Super User not found")
 
-    add_employee = Employees.filter_by_one(staff_id=find_staff.id, **Employees.valid_record_dict).data
+    add_employee = Employees.filter_by_one(system=True, staff_id=find_staff.id).data
     if not add_employee:
         raise Exception("Super User Employee not found")
 
@@ -112,3 +121,4 @@ def add_events_to_system_super_user():
         service_id=add_service.id,
         employee_id=add_employee.id,
     )
+    Employees.save()

service_app_init/initialize_app/initialize_default_department.py

@@ -140,7 +140,10 @@ def create_occupant_types_defaults():
     ]
 
     for list_occupant_type in list_occupant_types:
-        OccupantTypes.find_or_create(**{"is_confirmed": True, **list_occupant_type})
+        created_type = OccupantTypes.find_or_create(**{"is_confirmed": True, **list_occupant_type})
+        created_type.save()
+        created_type.is_confirmed = True
+        created_type.save()
 
 
 def create_application_defaults():
@@ -157,6 +160,7 @@ def create_application_defaults():
         RelationshipDutyCompany,
     )
 
+    created_list = []
     created_by, confirmed_by = "System", "System"
     company_management = Companies.find_or_create(
         **{
@@ -171,40 +175,28 @@ def create_application_defaults():
             "created_by": created_by,
             "confirmed_by": confirmed_by,
             "is_commercial": True,
-            **dict(
-                is_confirmed=True, active=True, deleted=False, is_notification_send=True
-            ),
         }
     )
+    created_list.append(company_management)
 
-    Duties.init_a_company_default_duties(
+    another_list = Duties.init_a_company_default_duties(
         company_id=company_management.id, company_uu_id=str(company_management.uu_id)
     )
+    created_list.extend(another_list)
     bulk_duty = Duty.filter_by_one(
+        system=True,
         duty_code="BULK",
     ).data
 
-    RelationshipDutyCompany.find_or_create(
-        duties_id=bulk_duty.id,
-        owner_id=company_management.id,
-        member_id=company_management.id,
-        parent_id=None,
-        is_confirmed=True,
-        active=True,
-        deleted=False,
-        is_notification_send=True,
-    )
-
     it_dept = Departments.filter_by_one(
+        system=True,
         department_name="IT Department",
         department_code="ITD001",
         company_id=company_management.id,
         company_uu_id=str(company_management.uu_id),
-        **Departments.valid_record_dict,
-        is_confirmed=True,
     ).data
 
-    Duty.find_or_create(
+    created_duty = Duty.find_or_create(
         **dict(
             duty_name="Database Manager",
             duty_code="DM",
@@ -217,7 +209,9 @@ def create_application_defaults():
             is_notification_send=True,
         )
     )
-    Duty.find_or_create(
+    created_list.append(created_duty)
+
+    created_duty = Duty.find_or_create(
         **dict(
             duty_name="Network Manager",
             duty_code="NM",
@@ -230,6 +224,8 @@ def create_application_defaults():
             is_notification_send=True,
         )
     )
+    created_list.append(created_duty)
+
     application_manager_duty = Duty.find_or_create(
         duty_name="Application Manager",
         duty_code="AM",
@@ -241,6 +237,7 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(application_manager_duty)
     application_super_user_duty = Duty.find_or_create(
         duty_name="Super User",
         duty_code="SUE",
@@ -252,7 +249,7 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
-
+    created_list.append(application_super_user_duty)
     application_manager_duties = Duties.find_or_create(
         department_id=it_dept.id,
         department_uu_id=str(it_dept.uu_id),
@@ -265,6 +262,7 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(application_manager_duties)
     super_user_duties = Duties.find_or_create(
         department_id=it_dept.id,
         department_uu_id=str(it_dept.uu_id),
@@ -277,6 +275,31 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(super_user_duties)
+    RelationshipDutyCompany.find_or_create(
+        duties_id=application_manager_duties.id,
+        owner_id=company_management.id,
+        member_id=company_management.id,
+        parent_id=None,
+        child_count=0,
+        is_confirmed=True,
+        active=True,
+        deleted=False,
+        is_notification_send=True,
+    )
+    created_list.append(application_manager_duties)
+    RelationshipDutyCompany.find_or_create(
+        duties_id=super_user_duties.id,
+        owner_id=company_management.id,
+        member_id=company_management.id,
+        parent_id=None,
+        child_count=0,
+        is_confirmed=True,
+        active=True,
+        deleted=False,
+        is_notification_send=True,
+    )
+    created_list.append(super_user_duties)
 
     app_manager = People.find_or_create(
         **{
@@ -293,12 +316,9 @@ def create_application_defaults():
             "tax_no": "1231231231",
             "created_by": created_by,
             "confirmed_by": confirmed_by,
-            **dict(
-                is_confirmed=True, active=True, deleted=False, is_notification_send=True
-            ),
         }
     )
-
+    created_list.append(app_manager)
     sup_manager = People.find_or_create(
         **{
             "firstname": "Berkay Super User",
@@ -314,12 +334,9 @@ def create_application_defaults():
             "tax_no": "1231231232",
             "created_by": created_by,
             "confirmed_by": confirmed_by,
-            **dict(
-                is_confirmed=True, active=True, deleted=False, is_notification_send=True
-            ),
         }
     )
-
+    created_list.append(sup_manager)
     application_manager_staff = Staff.find_or_create(
         staff_description="Application Manager",
         staff_name="Application Manager Employee",
@@ -331,6 +348,7 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(application_manager_staff)
     super_user_staff = Staff.find_or_create(
         staff_description="Super User",
         staff_name="Super User Employee",
@@ -342,6 +360,7 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(super_user_staff)
     app_manager_employee = Employees.find_or_create(
         staff_id=application_manager_staff.id,
         staff_uu_id=str(application_manager_staff.uu_id),
@@ -352,6 +371,8 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(app_manager_employee)
+
     super_user_employee = Employees.find_or_create(
         staff_id=super_user_staff.id,
         staff_uu_id=str(super_user_staff.uu_id),
@@ -362,6 +383,8 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(super_user_employee)
+
     app_manager_user = Users.find_or_create(
         person_id=app_manager.id,
         person_uu_id=str(app_manager.uu_id),
@@ -377,11 +400,12 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
-    if not app_manager_user.is_found:
+    created_list.append(app_manager_user)
     app_manager_user.reset_password_token()
-        MongoQueryIdentity(
+    mongo_engine = MongoQueryIdentity(
         company_uuid=company_management.uu_id
-        ).create_domain_via_user(
+    )
+    mongo_engine.create_domain_via_user(
         payload=DomainViaUser(
             user_uu_id=str(app_manager_user.uu_id),
             main_domain="evyos.com.tr",
@@ -404,15 +428,18 @@ def create_application_defaults():
         deleted=False,
         is_notification_send=True,
     )
+    created_list.append(sup_manager_employee)
 
-    if not sup_manager_employee.is_found:
     sup_manager_employee.reset_password_token()
-        MongoQueryIdentity(
+    mongo_engine.create_domain_via_user(
-            company_uuid=company_management.uu_id
-        ).create_domain_via_user(
         payload=DomainViaUser(
             user_uu_id=str(sup_manager_employee.uu_id),
             main_domain="evyos.com.tr",
             other_domains_list=["evyos.com.tr"],
         )
     )
+    People.save()
+    for created_list_item in created_list:
+        created_list_item.is_confirmed = True
+        created_list_item.save()
+    print("All Defaults Create is now completed")

service_app_init/initialize_app/initiator.py

@@ -236,6 +236,7 @@ def init_api_enums_build_types():
             key=str(insert_enum["type_code"]).upper(),
             description=insert_enum["type_name"],
         )
+    BuildTypes.save()
 
     # for insert_meeting_type in insert_meeting_types:
     #     ApiEnumDropdown.find_or_create(

service_app_init/initialize_app/model_initator.py

@@ -1,6 +1,4 @@
-import validations
+import api_validations.validations_request as validations
-
-# from database_sql_models.event.event import Models, ModelEntities
 
 
 def get_upper_only(text: str):

service_app_init/initialize_app/modules_and_services_init.py

@@ -1,14 +1,42 @@
-import typing
-
 from databases import (
     Modules,
     Duty,
     Services,
-    Service2Events,
     OccupantTypes,
 )
 
 
+
+def create_endpoints_from_api_functions(routers):
+    from application.create_file import create_app
+    from databases import EndpointRestriction
+    api_app = create_app(routers=routers)
+
+    for route in api_app.routes:
+        route_path, route_summary = (
+            str(getattr(route, "path")),
+            str(getattr(route, "name")) or "",
+        )
+
+        methods = [method.lower() for method in getattr(route, "methods")]
+        for route_method in methods:
+            restriction = EndpointRestriction.find_or_create(
+                **dict(
+                    endpoint_method=route_method,
+                    endpoint_name=route_path,
+                    endpoint_desc=route_summary.replace("_", " "),
+                    endpoint_function=route_summary,
+                )
+            )
+            restriction.endpoint_code = f"AR{str(restriction.id).zfill(3)}"
+            restriction.save()
+            restriction.is_confirmed = True
+            restriction.save()
+
+    EndpointRestriction.save()
+    return api_app
+
+
 def create_services_building(module_dict: dict):
     """
     4. Service [Bina]           Yönetim             - OPTIONAL
@@ -20,55 +48,78 @@ def create_services_building(module_dict: dict):
     10. Service [Bina]          Onarım              + OPTIONAL
     11 Service [Bina]           Gözlem              + OPTIONAL
     """
-    Services.find_or_create(
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Management",
         service_description="Building Management Service",
         service_code="SR-BLD-MNG",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Legal Affairs",
         service_description="Building Legal Affairs Service",
         service_code="SR-BLD-LGL",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Cleaning",
         service_description="Building Cleaning Service",
         service_code="SR-BLD-CLN",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Heating System",
         service_description="Building Heating System Service",
         service_code="SR-BLD-HTS",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Security System",
         service_description="Building Security System Service",
         service_code="SR-BLD-SEC",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Maintenance",
         service_description="Building Maintenance Service",
         service_code="SR-BLD-MNT",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Repair",
         service_description="Building Repair Service",
         service_code="SR-BLD-RPR",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Building Observation",
         service_description="Building Observation Service",
         service_code="SR-BLD-OBS",
     )
-
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
     return
 
 
@@ -80,36 +131,52 @@ def create_services_flat(module_dict: dict):
     14. Service [Daire]         Temizlik           + OPTIONAL
     11 Service [Daire]           Gözlem              + OPTIONAL
     """
-    Services.find_or_create(
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Flat Rent",
         service_description="Flat Rent Service",
         service_code="SR-FLT-RNT",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Flat Sale",
         service_description="Flat Sale Service",
         service_code="SR-FLT-SAL",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Flat Renovation",
         service_description="Flat Renovation Service",
         service_code="SR-FLT-RNV",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Flat Cleaning",
         service_description="Flat Cleaning Service",
         service_code="SR-FLT-CLN",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Flat Observation",
         service_description="Flat Observation Service",
         service_code="SR-FLT-OBS",
     )
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
     return
 
 
@@ -120,30 +187,41 @@ def create_services_authenticate(module_dict: dict):
         service_description="Authenticate Service",
         service_code="AUTH",
     )
+    authentication_service.save()
+    authentication_service.is_confirmed = True
+    authentication_service.save()
     return
 
 
 def create_services_meeting(module_dict: dict):
 
-    Services.find_or_create(
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Meeting Regular",
         service_description="Regular Meeting Service",
         service_code="MEET-REG",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Meeting Emergency",
         service_description="Emergency Meeting Service",
         service_code="MEET-EMR",
     )
-    Services.find_or_create(
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
+    created_service = Services.find_or_create(
         **module_dict,
         service_name="Meeting Demand",
         service_description="Demand Meeting Service",
         service_code="MEET-DMN",
     )
-
+    created_service.save()
+    created_service.is_confirmed = True
+    created_service.save()
     return
 
 
@@ -156,9 +234,11 @@ def create_modules_and_services_and_actions():
             "module_code": "EVYOS-ERP",
             "module_layer": 1,
             "is_default_module": False,
-            "is_confirmed": True,
         }
     )
+    erp_module.save()
+    erp_module.is_confirmed = True
+    erp_module.save()
 
     build_module = Modules.find_or_create(
         **{
@@ -167,9 +247,11 @@ def create_modules_and_services_and_actions():
             "module_code": "BLD-MNG",
             "module_layer": 1,
             "is_default_module": False,
-            "is_confirmed": True,
         }
     )
+    build_module.save()
+    build_module.is_confirmed = True
+    build_module.save()
 
     user_module = Modules.find_or_create(
         **{
@@ -178,51 +260,56 @@ def create_modules_and_services_and_actions():
             "module_code": "USR-PUB",
             "module_layer": 1,
             "is_default_module": True,
-            "is_confirmed": True,
         }
     )
+    user_module.save()
+    user_module.is_confirmed = True
+    user_module.save()
 
     erp_module_module_dict = dict(
         module_id=erp_module.id,
         module_uu_id=str(erp_module.uu_id),
-        is_confirmed=True,
     )
     build_module_module_dict = dict(
         module_id=build_module.id,
         module_uu_id=str(build_module.uu_id),
-        is_confirmed=True,
     )
     user_module_module_dict = dict(
         module_id=user_module.id,
         module_uu_id=str(user_module.uu_id),
-        is_confirmed=True,
     )
 
     duty_objects = Duty.filter_all(
         Duty.duty_code.notin_(["BULK", "OCCUPANT", "BM0001"])
     )
     for duty_object in duty_objects.data:
-        Services.find_or_create(
+        created_service = Services.find_or_create(
             **erp_module_module_dict,
             service_name=duty_object.duty_name,
             service_description=duty_object.duty_description,
             service_code=f"SRE-{duty_object.duty_code}",
         )
+        created_service.save()
+        created_service.is_confirmed=True
+        created_service.save()
 
     occupant_types = OccupantTypes.filter_all()
     for occupant_type in occupant_types.data:
-        Services.find_or_create(
+        created_service = Services.find_or_create(
             **build_module_module_dict,
             service_name=occupant_type.occupant_type,
             service_description=occupant_type.occupant_description,
             service_code=f"SRO-{occupant_type.occupant_code}",
         )
+        created_service.save()
+        created_service.is_confirmed=True
+        created_service.save()
 
     create_services_authenticate(module_dict=user_module_module_dict)
     create_services_meeting(module_dict=build_module_module_dict)
     create_services_building(module_dict=build_module_module_dict)
     create_services_flat(module_dict=build_module_module_dict)
-
+    Modules.save()
     return
     #
     # super_admin_module_created=None

service_app_init/requirements.txt

@@ -1,9 +1,14 @@
-arrow
 alembic
+arrow
+requests
 Deprecated
 fastapi
-python-dotenv
 pydantic
 sqlalchemy-mixins
+redis
 psycopg2-binary
 pymongo
+rsa
+redmail
+unidecode
+cryptography

service_app_init/runner.py

@@ -1,11 +1,32 @@
+
+
+confirmed_dict = {
+    "is_confirmed": True,
+    "active": True,
+    "is_notification_send": True,
+    "created_by": "System",
+    "confirmed_by": "System",
+}
+
+class TerminalColors:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKCYAN = '\033[96m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+
 def do_alembic():
     from sqlalchemy import text
     from alembic_generate import generate_alembic_with_session
 
     generate_alembic_with_session(text=text)
 
-
+def create_one_address(confirmed_dict):
-def create_application_defaults_func(create_address=False):
     from databases import (
         AddressCity,
         AddressStreet,
@@ -15,37 +36,6 @@ def create_application_defaults_func(create_address=False):
         AddressState,
         AddressCountry,
     )
-
-    from initialize_app import (
-        create_modules_and_services_and_actions,
-        create_endpoints_from_api_functions,
-        create_all_events_from_actions,
-        create_application_defaults,
-        init_api_enums_build_types,
-        add_events_all_services_and_occupant_types,
-        add_events_to_system_super_user,
-        create_occupant_types_defaults,
-    )
-
-    create_application_defaults()
-    create_occupant_types_defaults()
-    init_api_enums_build_types()
-
-    create_endpoints_from_api_functions()
-    create_modules_and_services_and_actions()
-    if create_all_events_from_actions():
-        add_events_all_services_and_occupant_types()
-        add_events_to_system_super_user()
-
-    if not create_address:
-        return
-    confirmed_dict = {
-        "is_confirmed": True,
-        "active": True,
-        "is_notification_send": True,
-        "created_by": "System",
-        "confirmed_by": "System",
-    }
     country = AddressCountry.find_or_create(
         country_name="TÜRKİYE", country_code="TR", **confirmed_dict
     )
@@ -102,9 +92,63 @@ def create_application_defaults_func(create_address=False):
     return
 
 
+def create_application_defaults_func(create_address=False):
+    from initialize_app import (
+        create_modules_and_services_and_actions,
+        create_endpoints_from_api_functions,
+        create_all_events_from_actions,
+        create_application_defaults,
+        init_api_enums_build_types,
+        add_events_all_services_and_occupant_types,
+        add_events_to_system_super_user,
+        create_occupant_types_defaults,
+    )
+    import routers
+    try:
+        create_endpoints_from_api_functions(routers=routers)
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_endpoints_from_api_functions Defaults Error", e)
+    try:
+        create_application_defaults()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_application_defaults Defaults Error", e)
+    try:
+        create_occupant_types_defaults()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_occupant_types_defaults Defaults Error", e)
+    try:
+        create_modules_and_services_and_actions()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_modules_and_services_and_actions Defaults Error", e)
+    try:
+        init_api_enums_build_types()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} init_api_enums_build_types Defaults Error", e)
+    try:
+        create_all_events_from_actions()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_all_events_from_actions Defaults Error", e)
+    try:
+        add_events_all_services_and_occupant_types()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} add_events_all_services_and_occupant_types Defaults Error", e)
+    try:
+        add_events_to_system_super_user()
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} add_events_to_system_super_user Defaults Error", e)
+    try:
+        if not create_address:
+            return
+        create_one_address(confirmed_dict=confirmed_dict)
+    except Exception as e:
+        print(f"{TerminalColors.WARNING} create_one_address Defaults Error", e)
+
+
 if __name__ == "__main__":
-    print("service_app_init is running")
+    print("Service App Initial Default Runner is running")
-    init_alembic_address = False
-    if init_alembic_address:
     do_alembic()
+    init_alembic_address = True
+    if init_alembic_address:
             create_application_defaults_func(create_address=False)
+    print("Service App Initial Default Runner is completed")
+