import math from datetime import datetime, timedelta from decimal import Decimal from typing import List from fastapi import HTTPException, status from databases.sql_models.core_mixin import CrudCollection from databases import ( Build, BuildLivingSpace, BuildIbans, People, Companies, OccupantTypes, Services, ) from api_library.date_time_actions.date_functions import system_arrow, client_arrow from sqlalchemy import ( String, ForeignKey, Index, SmallInteger, Boolean, TIMESTAMP, Text, Numeric, Integer, Identity, ) from sqlalchemy.orm import mapped_column, Mapped, relationship from api_validations.validations_request import ( InsertDecisionBook, InsertBuildDecisionBookItems, InsertBuildDecisionBookItemDebits, InsertBuildDecisionBookProjects, ) class BuildDecisionBook(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session The start dates of the decision log periods are determined from the 'decision_period_date' field in the decision log table within the building information. decision_period_date = Her yıl yapılan karar toplantısı + 365 gün her yıl tekrar eden decision_book_pdf_path: Karar defteri pdf dosyasının yolu resp_company_fix_wage: Karar defterinin oluşmasını sağlayan dışardaki danışmanlık ücreti is_out_sourced: Karar defterinin dışardan alınan hizmetle oluşturulup oluşturulmadığı contact_agreement_path: Karar defterinin oluşmasını sağlayan dışardaki danışmanlık anlaşması dosyasının yolu contact_agreement_date: Karar defterinin oluşmasını sağlayan dışardaki danışmanlık anlaşma tarihi meeting_date: Karar defterinin oluşmasını sağlayan toplantı tarihi decision_type: Karar defterinin tipi (Bina Yönetim Toplantısı (BYT), Yıllık Acil Toplantı (YAT) """ __tablename__ = "build_decision_book" __exclude__fields__ = [] decision_book_pdf_path: Mapped[str] = mapped_column(String) resp_company_fix_wage: Mapped[float] = mapped_column( Numeric(10, 2), server_default="0" ) # is_out_sourced: Mapped[bool] = mapped_column(Boolean, server_default="0") meeting_date: Mapped[TIMESTAMP] = mapped_column( TIMESTAMP, server_default="1900-01-01" ) decision_type: Mapped[str] = mapped_column(String(3), server_default="RBM") meeting_is_completed: Mapped[bool] = mapped_column(Boolean, server_default="0") meeting_completed_date: Mapped[TIMESTAMP] = mapped_column( TIMESTAMP, nullable=True, comment="Meeting Completed Date" ) build_id: Mapped[Identity] = mapped_column(ForeignKey("build.id"), nullable=False) build_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Build UUID" ) resp_company_id: Mapped[Identity] = mapped_column(ForeignKey("companies.id")) resp_company_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Company UUID" ) contact_id: Mapped[Identity] = mapped_column( ForeignKey("contracts.id"), nullable=True, comment="Contract id" ) contact_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Contract UUID" ) buildings: Mapped["Build"] = relationship( "Build", back_populates="decision_books", foreign_keys=build_id, ) decision_book_items: Mapped[List["BuildDecisionBookItems"]] = relationship( "BuildDecisionBookItems", back_populates="decision_books", foreign_keys="BuildDecisionBookItems.build_decision_book_id", ) __table_args__ = ( Index("build_decision_book_ndx_011", meeting_date, build_id), Index("build_decision_book_ndx_011", build_id, "expiry_starts", "expiry_ends"), { "comment": "Decision Book objects that are related to decision taken at building meetings" }, ) @classmethod def retrieve_active_rbm(cls): related_build = Build.find_one(id=cls.build_id) related_date = system_arrow.get(related_build.build_date) date_processed = related_date.replace( year=system_arrow.now().date().year, month=related_date.month, day=1 ) if system_arrow.now().date() <= date_processed: book = cls.filter_active( cls.expiry_ends <= date_processed, cls.decision_type == "RBM", cls.build_id == related_build.id, ) if not book: return return book.data[0] else: return @classmethod def select_action(cls, duty_id, token=None): related_companies = Companies.select_action(duty_id=duty_id) related_companies_ids = list( related_.id for related_ in related_companies.all() ) related_building = Build.filter_all(Build.company_id.in_(related_companies_ids)) related_building_ids = list(related_.id for related_ in related_building.data) return cls.filter_all(cls.build_id.in_(related_building_ids)).query @classmethod def create_action(cls, data: InsertDecisionBook, token=None): data_dict = data.model_dump() if building := Build.find_one(uu_id=data.build_uu_id): data_dict["build_id"] = building.id if response_company := Companies.find_one( uu_id=data_dict["resp_company_uu_id"] ): data_dict["resp_company_id"] = response_company.id if not building: raise HTTPException( status_code=status.HTTP_406_NOT_ACCEPTABLE, detail="Building must be given to create decision book.", ) expiry_starts = system_arrow.get(str(data_dict.get("expiry_starts"))).format( "%Y-%m-%d" ) data_dict["expiry_starts"] = str(expiry_starts) expiry_ends = system_arrow.get(str(data_dict.get("expiry_ends"))).format( "%Y-%m-%d" ) data_dict["expiry_ends"] = str( expiry_ends.replace(month=expiry_ends.month + 1, day=1) - timedelta(days=1) ) if decision_book := BuildDecisionBook.filter_all( BuildDecisionBook.build_id == building.id, BuildDecisionBook.expiry_ends > data_dict["expiry_starts"], BuildDecisionBook.decision_type == data_dict.get("decision_type"), ).count: # Decision book is already exist: cls.raise_http_exception( status_code=status.HTTP_409_CONFLICT, error_case="RECORDEXITS", message="Decision Book is already exist.", data=decision_book.get_dict(), ) data_dict["expiry_starts"] = str(expiry_starts.replace(day=1)) data_dict["expiry_ends"] = str( expiry_ends.replace(month=expiry_ends.month + 1, day=1) - timedelta(days=1) ) del data_dict["build_uu_id"], data_dict["resp_company_uu_id"] return cls.find_or_create(**data_dict) @property def semester(self): start_format = "".join( [str(self.expiry_starts.year), "-", str(self.expiry_starts.month)] ) end_format = "".join( [str(self.expiry_ends.year), "-", str(self.expiry_ends.month)] ) return "".join([start_format, " ", end_format]) def check_book_is_valid(self, bank_date: str): if all( [True if letter in str(bank_date) else False for letter in ["-", " ", ":"]] ): bank_date = datetime.strptime(str(bank_date), "%Y-%m-%d %H:%M:%S") date_valid = ( system_arrow.get(self.expiry_starts) < system_arrow.get(bank_date) < system_arrow.get(self.expiry_ends) ) return date_valid and self.active and not self.deleted @classmethod def retrieve_valid_book(cls, bank_date, iban): if all( [True if letter in str(bank_date) else False for letter in ["-", " ", ":"]] ): bank_date = datetime.strptime(str(bank_date), "%Y-%m-%d %H:%M:%S") build_iban = BuildIbans.find_one(iban=iban) decision_book: cls = cls.filter( cls.build_id == build_iban.build_id, cls.expiry_starts < bank_date, cls.expiry_ends > bank_date, cls.active == True, cls.deleted == False, ) decision_book.check_book_is_valid(bank_date.__str__()) return decision_book return class BuildDecisionBookInvitations(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session """ __tablename__ = "build_decision_book_invitations" __exclude__fields__ = [] build_id: Mapped[int] = mapped_column(Integer, nullable=False) build_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Build UUID" ) decision_book_id: Mapped[Identity] = mapped_column( ForeignKey("build_decision_book.id"), nullable=False ) decision_book_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Decision Book UUID" ) invitation_type: Mapped[str] = mapped_column( String, nullable=False, comment="Invite Type" ) invitation_attempt: Mapped[int] = mapped_column(SmallInteger, server_default="1") living_part_count: Mapped[int] = mapped_column(SmallInteger, server_default="1") living_part_percentage: Mapped[float] = mapped_column( Numeric(10, 2), server_default="0.51" ) message = mapped_column(Text, nullable=True, comment="Invitation Message") planned_date = mapped_column( TIMESTAMP, nullable=False, comment="Planned Meeting Date" ) planned_date_expires = mapped_column( TIMESTAMP, nullable=False, comment="Planned Meeting Date Expires" ) __table_args__ = ( Index( "_build_decision_book_invitations_ndx_01", invitation_type, planned_date, invitation_attempt, unique=True, ), {"comment": "People that are invited to building meetings."}, ) @classmethod def check_invites_are_ready_for_meeting(cls, selected_decision_book, token_dict): first_book_invitation = BuildDecisionBookInvitations.find_one( build_id=token_dict.selected_occupant.build_id, decision_book_id=selected_decision_book.id, invitation_attempt=1, active=True, is_confirmed=True, ) if not first_book_invitation: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"First Meeting Invitation is not found for Decision Book UUID : {selected_decision_book.uu_id}", ) need_attend_count = int(first_book_invitation.living_part_count) * Decimal( first_book_invitation.living_part_percentage ) valid_invite_count = ( BuildDecisionBookPerson.filter_active( BuildDecisionBookPerson.invite_id == first_book_invitation.id, BuildDecisionBookPerson.build_decision_book_id == selected_decision_book.id, BuildDecisionBookPerson.is_attending == True, filter_records=False, ) .query.distinct(BuildDecisionBookPerson.person_id) .count() ) second_book_invitation = BuildDecisionBookInvitations.find_one( build_id=token_dict.selected_occupant.build_id, decision_book_id=selected_decision_book.id, invitation_attempt=2, active=True, is_confirmed=True, ) if not valid_invite_count >= need_attend_count and not second_book_invitation: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f"In order meeting to be held, {math.ceil(need_attend_count)} people must attend " f"to the meeting. Only {valid_invite_count} people are attending to the meeting.", ) return first_book_invitation or second_book_invitation class BuildDecisionBookPerson(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session Karar Defteri toplantılarına katılan kişiler veya yetkililer dues_percent_discount: Katılımcının aidat indirim oranı Aidatdan yüzde indirim alır dues_fix_discount: Katılımcının aidat sabit miktarı Aidatdan sabit bir miktar indirim alır dues_discount_approval_date: Bu kişinin indiriminin onayladığı tarih management_typecode: Kişinin toplantı görevi """ __tablename__ = "build_decision_book_person" __exclude__fields__ = [] __enum_list__ = [("management_typecode", "BuildManagementType", "bm")] dues_percent_discount = mapped_column(SmallInteger, server_default="0") dues_fix_discount: Mapped[float] = mapped_column(Numeric(10, 2), server_default="0") dues_discount_approval_date = mapped_column( TIMESTAMP, server_default="1900-01-01 00:00:00" ) send_date = mapped_column(TIMESTAMP, nullable=False, comment="Confirmation Date") is_attending = mapped_column( Boolean, server_default="0", comment="Occupant is Attending to invitation" ) confirmed_date = mapped_column( TIMESTAMP, nullable=True, comment="Confirmation Date" ) token: Mapped[str] = mapped_column( String, server_default="", comment="Invitation Token" ) vicarious_person_id = mapped_column( ForeignKey("people.id"), nullable=True, comment="Vicarious Person ID" ) vicarious_person_uu_id = mapped_column( String, nullable=True, comment="Vicarious Person UUID" ) invite_id = mapped_column( ForeignKey("build_decision_book_invitations.id"), nullable=False ) invite_uu_id: Mapped[str] = mapped_column( String, nullable=False, comment="Invite UUID" ) build_decision_book_id = mapped_column( ForeignKey("build_decision_book.id"), nullable=False ) build_decision_book_uu_id = mapped_column( String, nullable=False, comment="Decision Book UUID" ) build_living_space_id = mapped_column( ForeignKey("build_living_space.id"), nullable=False ) build_living_space_uu_id = mapped_column( String, nullable=True, comment="Living Space UUID" ) person_id: Mapped[Identity] = mapped_column(ForeignKey("people.id"), nullable=False) # person_uu_id: Mapped[str] = mapped_column(String, nullable=False, comment="Person UUID") __table_args__ = ( Index( "_build_decision_book_person_ndx_01", build_decision_book_id, invite_id, build_living_space_id, unique=True, ), {"comment": "People that are attended to building meetings."}, ) def retrieve_all_occupant_types(self): all_decision_book_people = self.filter_active( BuildDecisionBookPersonOccupants.invite_id == self.invite_id, filter_records=False, ) BuildDecisionBookPersonOccupants.pre_query = all_decision_book_people.query return BuildDecisionBookPersonOccupants.filter_active(filter_records=False) def add_occupant_type(self, occupant_type, build_living_space_id: int = None): from api_events.events.events.events_bind_services import ( ServiceBindOccupantEventMethods, ) book_dict = dict( build_decision_book_person_id=self.id, build_decision_book_person_uu_id=str(self.uu_id), invite_id=self.invite_id, invite_uu_id=str(self.invite_uu_id), occupant_type_id=occupant_type.id, occupant_type_uu_id=str(occupant_type.uu_id), is_confirmed=True, ) if person_occupants := BuildDecisionBookPersonOccupants.find_or_create( **book_dict ): decision_book = BuildDecisionBook.find_one( id=self.build_decision_book_id, active=True, is_confirmed=True ) person_occupants.update( expiry_starts=decision_book.expiry_starts, expiry_ends=decision_book.expiry_ends, ) if not person_occupants.is_found and build_living_space_id: related_service = Services.find_one( related_responsibility=str(occupant_type.occupant_code), active=True, is_confirmed=True, ) if not related_service: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Service is not found for {occupant_type.occupant_code}", ) decision_build = Build.find_one( id=decision_book.build_id, active=True, is_confirmed=True ) management_room = decision_build.management_room if not management_room: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Management Room is not found in {decision_build.build_name}", ) living_space = BuildLivingSpace.find_one( id=build_living_space_id, active=True, is_confirmed=True ) related_living_space = BuildLivingSpace.find_or_create( build_parts_id=management_room.id, build_parts_uu_id=str(management_room.uu_id), occupant_type=occupant_type.id, occupant_type_uu_id=str(occupant_type.uu_id), person_id=living_space.person_id, person_uu_id=str(living_space.person_uu_id), expiry_starts=system_arrow.get( decision_book.meeting_date ).__str__(), expiry_ends=system_arrow.get(decision_book.meeting_date) .shift(hours=23) .__str__(), is_confirmed=True, active=True, ) ServiceBindOccupantEventMethods.bind_services_occupant_system( build_living_space_id=related_living_space.id, service_id=related_service.id, expires_at=str( system_arrow.get(decision_book.meeting_date).shift(days=15) ), ) return person_occupants return def get_occupant_types(self): if occupants := BuildDecisionBookPersonOccupants.filter_active( BuildDecisionBookPersonOccupants.build_decision_book_person_id == self.id, filter_records=False, ): return occupants.data return def check_occupant_type(self, occupant_type): book_person_occupant_type = BuildDecisionBookPersonOccupants.find_one( build_decision_book_person_id=self.id, occupant_type_id=occupant_type.id, active=True, is_confirmed=True, ) if not book_person_occupant_type: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Occupant Type : {occupant_type.occupant_code} is not found in " f"Decision Book Person UUID {self.uu_id}", ) class BuildDecisionBookPersonOccupants(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session """ __tablename__ = "build_decision_book_person_occupants" __exclude__fields__ = [] build_decision_book_person_id = mapped_column( ForeignKey("build_decision_book_person.id"), nullable=False ) build_decision_book_person_uu_id = mapped_column( String, nullable=True, comment="Decision Book Person UUID" ) invite_id = mapped_column( ForeignKey("build_decision_book_invitations.id"), nullable=True ) invite_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Invite UUID" ) occupant_type_id: Mapped[Identity] = mapped_column( ForeignKey("occupant_types.id"), nullable=False ) occupant_type_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Occupant UUID" ) __table_args__ = ( Index( "_build_decision_book_person_occupants_ndx_01", build_decision_book_person_id, occupant_type_id, unique=True, ), {"comment": "Occupant Types of People that are attended to building meetings."}, ) class BuildDecisionBookItems(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session item_commentary = metine itiraz şerh maddesi için item_order = maddelerin sıralanma numarası item_objection = maddelerin itiraz şerhi Text şeklinde """ __tablename__ = "build_decision_book_items" __exclude__fields__ = [] item_order = mapped_column( SmallInteger, nullable=False, comment="Order Number of Item" ) item_comment = mapped_column(Text, nullable=False, comment="Comment Content") item_objection = mapped_column(Text) info_is_completed = mapped_column( Boolean, server_default="0", comment="Info process is Completed" ) is_payment_created = mapped_column( Boolean, server_default="0", comment="Are payment Records Created" ) info_type_id: Mapped[Identity] = mapped_column( ForeignKey("api_enum_dropdown.id"), nullable=True ) info_type_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Info Type UUID" ) build_decision_book_id = mapped_column( ForeignKey("build_decision_book.id"), nullable=False ) build_decision_book_uu_id = mapped_column( String, nullable=True, comment="Decision Book UUID" ) decision_books: Mapped["BuildDecisionBook"] = relationship( "BuildDecisionBook", back_populates="decision_book_items", foreign_keys=[build_decision_book_id], ) decision_book_project: Mapped["BuildDecisionBookProjects"] = relationship( "BuildDecisionBookProjects", back_populates="build_decision_book_item", foreign_keys="BuildDecisionBookProjects.build_decision_book_item_id", ) @classmethod def select_action(cls, duty_id, token=None): related_companies = Companies.select_action(duty_id=duty_id) related_companies_ids = list( related_.id for related_ in related_companies.all() ) related_building = Build.query.filter( Build.company_id.in_(related_companies_ids) ) related_building_ids = list(related_.id for related_ in related_building.all()) related_decision_books = BuildDecisionBook.query.filter( BuildDecisionBook.build_id.in_(related_building_ids) ) related_decision_books_ids = list( related_.id for related_ in related_decision_books.all() ) return cls.query.filter( cls.build_decision_book_id.in_(related_decision_books_ids) ) @classmethod def create_action(cls, data: InsertBuildDecisionBookItems, token): data_dict = data.dump() BuildDecisionBook.pre_query = BuildDecisionBook.select_action( duty_id=token.duty_list["duty_id"] ) cls.pre_query = cls.select_action(duty_id=token.duty_list["duty_id"]) if decision_book := BuildDecisionBook.find_one( uu_id=data.build_decision_book_uu_id ): found_dict = dict( item_order=data.item_order, build_decision_book_id=decision_book.id ) if decision_book_is_already := cls.find_one(**found_dict): decision_book_is_already.is_found = True return decision_book_is_already.get_dict() data_dict["build_decision_book_id"] = decision_book.id data_dict["is_confirmed"] = True del data_dict["build_decision_book_uu_id"] return BuildDecisionBookItems.find_or_create(**data_dict) @classmethod def check_meeting_is_valid_to_start_add_attendance(cls, decision_book, token_dict): active_invite = ( BuildDecisionBookInvitations.check_invites_are_ready_for_meeting( selected_decision_book=decision_book, token_dict=token_dict, ) ) occupant_type_required_list = ("MT-PRS", "MT-WRT", "BU-MNG", "BU-SPV") occupant_type_list = OccupantTypes.filter_active( OccupantTypes.occupant_code.in_(occupant_type_required_list) ) # active_invite = invitations[1] if invitations[1] else invitations[0] invitation = BuildDecisionBookInvitations.find_one(id=active_invite.id) people_book_attend_count = None if invitation.invitation_attempt == 1: people_book_attend_is_attending = BuildDecisionBookPerson.filter_active( BuildDecisionBookPerson.invite_id == invitation.id, BuildDecisionBookPerson.is_attending == True, ) people_book_attend = BuildDecisionBookPersonOccupants.filter_active( BuildDecisionBookPersonOccupants.build_decision_book_person_id.in_( [person.id for person in people_book_attend_is_attending.data] ), BuildDecisionBookPersonOccupants.occupant_type_id.in_( [occupant_type.id for occupant_type in occupant_type_list.data] ), ) people_book_attend_count = people_book_attend.count if not people_book_attend_count == len(occupant_type_required_list) - 1: error_detail = " - ".join(occupant_type_required_list) raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f"{error_detail} occupant types must be attend to meeting. " f"Check attendants and try again", ) comment = ( lambda id_, occ_type, full_name: f"{full_name} is nomindated for {occ_type} at Meeting Invite Code : {id_}" ) book_items_dict = dict( build_decision_book_id=decision_book.id, build_decision_book_uu_id=str(decision_book.uu_id), is_confirmed=True, active=True, is_payment_created=True, ) occupant_type_pre = OccupantTypes.find_one( occupant_code="MT-PRS", occupant_category_type="MT" ) occupant_type_wrt = OccupantTypes.find_one( occupant_code="MT-WRT", occupant_category_type="MT" ) occupant_type_mng = OccupantTypes.find_one( occupant_code="BU-MNG", occupant_category_type="BU" ) person_occupants_pre = BuildDecisionBookPersonOccupants.find_one( invite_id=invitation.id, occupant_type_id=occupant_type_pre.id, ) person_invite_pret = BuildDecisionBookPerson.find_one( id=person_occupants_pre.build_decision_book_person_id ) person = People.find_one( id=person_invite_pret.person_id, active=True, is_confirmed=True ) BuildDecisionBookItems.find_or_create( **book_items_dict, item_order=1, item_comment=comment( id_=person_invite_pret.invite_uu_id, occ_type=occupant_type_pre.occupant_type, full_name=person.full_name, ), ) person_occupants_wrt = BuildDecisionBookPersonOccupants.find_one( invite_id=invitation.id, occupant_type_id=occupant_type_wrt.id, ) person_invite_wrt = BuildDecisionBookPerson.find_one( id=person_occupants_wrt.build_decision_book_person_id ) person = People.find_one( id=person_invite_pret.person_id, active=True, is_confirmed=True ) BuildDecisionBookItems.find_or_create( **book_items_dict, item_order=2, item_comment=comment( id_=person_invite_wrt.invite_uu_id, occ_type=occupant_type_wrt.occupant_type, full_name=person.full_name, ), ) person_occupants_mng = BuildDecisionBookPersonOccupants.find_one( invite_id=invitation.id, occupant_type_id=occupant_type_mng.id, ) person_invite_mng = BuildDecisionBookPerson.find_one( id=person_occupants_mng.build_decision_book_person_id ) person = People.find_one( id=person_invite_pret.person_id, active=True, is_confirmed=True ) BuildDecisionBookItems.find_or_create( **book_items_dict, item_order=3, item_comment=comment( id_=person_invite_mng.invite_uu_id, occ_type=occupant_type_mng.occupant_type, full_name=person.full_name, ), ) return people_book_attend_count __table_args__ = ( Index("_build_decision_book_item_ndx_01", build_decision_book_id), Index( "_build_decision_book_item_ndx_02", build_decision_book_id, item_order, unique=True, ), { "comment": "Decision Book Items that are related to decision taken at building meetings" }, ) class BuildDecisionBookItemsUnapproved(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session unapproved personnel """ __tablename__ = "build_decision_book_items_unapproved" __exclude__fields__ = [] item_objection = mapped_column(Text, nullable=False, comment="Objection Content") item_order = mapped_column(SmallInteger, nullable=False, comment="Order Number") decision_book_item_id = mapped_column( ForeignKey("build_decision_book_items.id"), nullable=False ) decision_book_item_uu_id = mapped_column( String, nullable=True, comment="Decision Book Item" ) person_id: Mapped[Identity] = mapped_column(ForeignKey("people.id"), nullable=False) person_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Person UUID" ) build_decision_book_item = mapped_column( ForeignKey("build_decision_book_items.id"), nullable=False ) build_decision_book_item_uu_id = mapped_column( String, nullable=True, comment="Decision Book Item UUID" ) __table_args__ = ( Index("_build_decision_book_item_unapproved_ndx_01", build_decision_book_item), { "comment": "People that are unapproved partially or completely in decision book items" }, ) class BuildDecisionBookPayments(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session period_time = to_char(NEW.process_date, 'YYYY-MM'); """ __tablename__ = "build_decision_book_payments" __exclude__fields__ = [] __enum_list__ = [("receive_debit", "DebitTypes", "D")] payment_plan_time_periods = mapped_column( String(10), nullable=False, comment="Payment Plan Time Periods" ) process_date = mapped_column(TIMESTAMP, nullable=False, comment="Payment Due Date") payment_amount = mapped_column( Numeric(16, 2), nullable=False, comment="Payment Amount" ) currency: Mapped[str] = mapped_column(String(8), server_default="TRY") payment_types_id: Mapped[Identity] = mapped_column( ForeignKey("api_enum_dropdown.id"), nullable=True ) payment_types_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Dues Type UUID" ) period_time: Mapped[str] = mapped_column(String(12)) process_date_y: Mapped[int] = mapped_column(SmallInteger) process_date_m: Mapped[int] = mapped_column(SmallInteger) build_decision_book_item_id = mapped_column( ForeignKey("build_decision_book_items.id"), nullable=False, comment="Build Decision Book Item ID", ) build_decision_book_item_uu_id = mapped_column( String, nullable=True, comment="Decision Book Item UUID" ) decision_book_project_id = mapped_column( ForeignKey("build_decision_book_projects.id"), nullable=True, comment="Decision Book Project ID", ) decision_book_project_uu_id = mapped_column( String, nullable=True, comment="Decision Book Project UUID" ) build_parts_id: Mapped[Identity] = mapped_column( ForeignKey("build_parts.id"), nullable=False ) build_parts_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Build Part UUID" ) budget_records_id: Mapped[Identity] = mapped_column( ForeignKey("account_records.id") ) budget_records_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Budget UUID" ) accounting_id: Mapped[Identity] = mapped_column(ForeignKey("account_detail.id")) accounting_uu_id: Mapped[str] = mapped_column( String, nullable=True, comment="Accounting UUID" ) # receive_debit_id: Mapped[Identity] = mapped_column(ForeignKey("api_enum_dropdown.id"), nullable=True) # receive_debit_uu_id: Mapped[str] = mapped_column(String, nullable=True, comment="Debit UUID") # accounting: Mapped["AccountDetail"] = relationship( # "AccountDetail", # back_populates="decision_book_payment_detail", # foreign_keys=[accounting_id], # ) # # decision_book_master: Mapped["BuildDecisionBookPaymentsMaster"] = relationship( # "BuildDecisionBookPaymentsMaster", # back_populates="decision_book_payment_detail", # foreign_keys=[build_decision_book_payments_master_id], # ) # budget_records: Mapped["CompanyBudgetRecords"] = relationship( # "CompanyBudgetRecords", # back_populates="decision_book_payment_detail", # foreign_keys=[budget_records_id], # ) __table_args__ = ( Index( "build_decision_book_payments_detail_ndx_00", build_decision_book_item_id, build_parts_id, payment_plan_time_periods, process_date, unique=True, ), Index( "build_decision_book_payments_detail_ndx_01", budget_records_id, process_date, ), {"comment": "Payment Details of Decision Book Payments"}, ) class BuildDecisionBookLegal(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session lawsuits_type C:Court Mehkeme M: mediator arabulucu """ __tablename__ = "build_decision_book_legal" __exclude__fields__ = [] period_start_date = mapped_column( TIMESTAMP, nullable=False, comment="Start Date of Legal Period" ) lawsuits_decision_number = mapped_column( String, nullable=False, comment="Lawsuits Decision Number" ) lawsuits_decision_date = mapped_column( TIMESTAMP, nullable=False, comment="Lawsuits Decision Date" ) period_stop_date = mapped_column(TIMESTAMP, server_default="2099-12-31 23:59:59") decision_book_pdf_path: Mapped[str] = mapped_column(String(128)) resp_company_total_wage: Mapped[float] = mapped_column( Numeric(10, 2), server_default="0" ) contact_agreement_path = mapped_column(String(128)) contact_agreement_date = mapped_column( TIMESTAMP, server_default="1900-01-01 00:00:00" ) meeting_date = mapped_column(TIMESTAMP, server_default="1900-01-01 00:00:00") lawsuits_type = mapped_column(String(1), server_default="C") lawsuits_name = mapped_column(String(128)) lawsuits_note = mapped_column(String(512)) lawyer_cost: Mapped[float] = mapped_column(Numeric(20, 2)) mediator_lawyer_cost: Mapped[float] = mapped_column(Numeric(20, 2)) other_cost: Mapped[float] = mapped_column(Numeric(20, 2)) legal_cost: Mapped[float] = mapped_column(Numeric(20, 2)) approved_cost: Mapped[float] = mapped_column(Numeric(20, 2)) total_price: Mapped[float] = mapped_column(Numeric(20, 2)) build_db_item_id = mapped_column( ForeignKey("build_decision_book_items.id"), nullable=False ) build_db_item_uu_id = mapped_column( String, nullable=True, comment="Decision Book Item UUID" ) resp_attorney_id: Mapped[Identity] = mapped_column( ForeignKey("people.id"), nullable=False ) resp_attorney_uu_id = mapped_column(String, nullable=True, comment="Attorney UUID") resp_attorney_company_id: Mapped[Identity] = mapped_column( ForeignKey("companies.id") ) resp_attorney_company_uu_id = mapped_column( String, nullable=True, comment="Company UUID" ) mediator_lawyer_person_id: Mapped[Identity] = mapped_column(ForeignKey("people.id")) mediator_lawyer_person_uu_id = mapped_column( String, nullable=True, comment="Mediator Lawyer UUID" ) __table_args__ = ( Index("_build_decision_book_legal_ndx_00", meeting_date), { "comment": "Legal items related to decision book items recoreded at building meetings" }, ) class BuildDecisionBookProjects(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session project_type = C:Court Mehkeme M: mediator arabulucu """ __tablename__ = "build_decision_book_projects" __exclude__fields__ = [] project_no = mapped_column( String(12), nullable=True, comment="Project Number of Decision Book" ) project_name = mapped_column(String, nullable=False, comment="Project Name") project_start_date = mapped_column( TIMESTAMP, nullable=False, comment="Project Start Date" ) project_stop_date = mapped_column(TIMESTAMP, server_default="2099-12-31 23:59:59") project_type = mapped_column(String, server_default="C") project_note = mapped_column(Text) decision_book_pdf_path = mapped_column(String) resp_company_fix_wage: Mapped[float] = mapped_column( Numeric(10, 2), server_default="0" ) is_out_sourced: Mapped[bool] = mapped_column(Boolean, server_default="0") contact_id = mapped_column( ForeignKey("contracts.id"), nullable=True, comment="Contract id" ) contact_uu_id = mapped_column(String, nullable=True, comment="Contract UUID") meeting_date = mapped_column( TIMESTAMP, server_default="1900-01-01 00:00:00", index=True ) currency = mapped_column(String(8), server_default="TRY") bid_price: Mapped[float] = mapped_column(Numeric(16, 4), server_default="0") approved_price: Mapped[float] = mapped_column(Numeric(16, 4), server_default="0") final_price: Mapped[float] = mapped_column(Numeric(16, 4), server_default="0") build_decision_book_id = mapped_column( ForeignKey("build_decision_book.id"), nullable=False ) build_decision_book_uu_id = mapped_column( String, nullable=True, comment="Decision Book UUID" ) build_decision_book_item_id = mapped_column( ForeignKey("build_decision_book_items.id"), nullable=False ) build_decision_book_item_uu_id = mapped_column( String, nullable=True, comment="Decision Book Item UUID" ) project_response_living_space_id = mapped_column( ForeignKey("build_living_space.id"), nullable=True, comment="Project Response Person ID", ) project_response_living_space_uu_id = mapped_column( String, nullable=True, comment="Project Response Person UUID" ) resp_company_id: Mapped[Identity] = mapped_column( ForeignKey("companies.id"), nullable=True ) resp_company_uu_id = mapped_column(String, nullable=True, comment="Company UUID") build_decision_book_item: Mapped["BuildDecisionBookItems"] = relationship( "BuildDecisionBookItems", back_populates="decision_book_project", foreign_keys=[build_decision_book_item_id], ) @classmethod def select_action(cls, duty_id, token=None): related_companies = Companies.select_action(duty_id=duty_id) related_companies_ids = list( related_.id for related_ in related_companies.all() ) related_building = Build.filter_all(Build.company_id.in_(related_companies_ids)) related_building_ids = list(related_.id for related_ in related_building.data) related_decision_books = BuildDecisionBook.query.filter( BuildDecisionBook.build_id.in_(related_building_ids) ) related_decision_books_ids = list( related_.id for related_ in related_decision_books.all() ) related_decision_books_items = BuildDecisionBookItems.query.filter( BuildDecisionBookItems.build_decision_book_id.in_( related_decision_books_ids ) ) related_decision_books_items_ids = list( related_.id for related_ in related_decision_books_items.all() ) return cls.query.filter( cls.build_decision_book_item_id.in_(related_decision_books_items_ids) ) @classmethod def create_action(cls, data: InsertBuildDecisionBookProjects, token=None): data_dict = data.dump() BuildDecisionBookItems.pre_query = BuildDecisionBookItems.select_action( duty_id=token.duty_list["duty_id"] ) People.pre_query = People.select_action(duty_id=token.duty_list["duty_id"]) decision_book_project_item = BuildDecisionBookItems.find_one_or_abort( uu_id=data_dict.get("build_decision_book_item_uu_id") ) project_response_person = People.find_one_or_abort( uu_id=data_dict.get("project_response_person_uu_id") ) data_dict["build_decision_book_item_id"] = decision_book_project_item.id data_dict["project_response_person_id"] = project_response_person.id if data.resp_company_uu_id: resp_company = Companies.find_one(uu_id=data.resp_company_uu_id) data_dict["resp_company_id"] = resp_company.id del ( data_dict["build_decision_book_item_uu_id"], data_dict["project_response_person_uu_id"], ) del data_dict["resp_company_uu_id"] data_dict["is_confirmed"] = True return cls.find_or_create(**data_dict) __table_args__ = ( Index( "_build_decision_book_project_ndx_00", project_no, project_start_date, unique=True, ), { "comment": "Project related to decision taken at building meetings on book items" }, ) @property def get_project_year(self): return self.decision_book_items.decision_books.period_start_date.year @property def get_project_no(self): return f"{self.get_project_year}-{str(self.id)[-4:].zfill(4)}" class BuildDecisionBookProjectPerson(CrudCollection): """ Builds class based on declarative_base and BaseMixin via session """ __tablename__ = "build_decision_book_project_person" __exclude__fields__ = [] __enum_list__ = [("management_typecode", "ProjectTeamTypes", "PTT-EMP")] dues_percent_discount = mapped_column(SmallInteger, server_default="0") job_fix_wage: Mapped[float] = mapped_column(Numeric(10, 2), server_default="0") bid_price: Mapped[float] = mapped_column(Numeric(10, 2), server_default="0") decision_price: Mapped[float] = mapped_column(Numeric(10, 2), server_default="0") build_decision_book_project_id = mapped_column( ForeignKey("build_decision_book_projects.id"), nullable=False ) build_decision_book_project_uu_id = mapped_column( String, nullable=True, comment="Decision Book Project UUID" ) living_space_id: Mapped[Identity] = mapped_column( ForeignKey("build_living_space.id"), nullable=False ) living_space_uu_id = mapped_column( String, nullable=True, comment="Living Space UUID" ) project_team_type_id = mapped_column( ForeignKey("api_enum_dropdown.id"), nullable=True ) project_team_type_uu_id = mapped_column( String, nullable=True, comment="Management Type UUID" ) __table_args__ = ( {"comment": "People that are attended to building project meetings."}, ) # # class BuildDecisionBookPaymentsMaster(CrudCollection): # """ # Builds class based on declarative_base and BaseMixin via session # """ # # __tablename__ = "build_decision_book_payments_master" # __exclude__fields__ = [] # __enum_list__ = [("dues_types", "BuildDuesTypes", "D")] # # payment_plan_time_periods = mapped_column( # String(8), nullable=False, comment="Payment Plan Time Periods" # ) # default_payment_amount = mapped_column( # Numeric(20, 2), nullable=False, comment="Default Payment Amount" # ) # # dues_types_id: Mapped[Identity] = mapped_column(ForeignKey("api_enum_dropdown.id"), nullable=True) # dues_types_uu_id = mapped_column(String, nullable=True, comment="Dues Type UUID") # build_decision_book_item_debits_id = mapped_column( # ForeignKey("build_decision_book_item_debits.id"), nullable=False # ) # build_decision_book_item_debits_uu_id = mapped_column( # String, nullable=True, comment="Decision Book Item Debit UUID" # ) # build_parts_id: Mapped[Identity] = mapped_column(ForeignKey("build_parts.id"), nullable=False) # build_parts_uu_id = mapped_column(String, nullable=True, comment="Build Part UUID") # # # decision_books_item_debits: Mapped["BuildDecisionBookItemDebits"] = relationship( # # "BuildDecisionBookItemDebits", # # back_populates="decision_book_payment_masters", # # foreign_keys=[build_decision_book_item_debits_id], # # ) # # parts: Mapped["BuildParts"] = relationship( # # "BuildParts", # # back_populates="decision_book_payment_master", # # foreign_keys=[build_parts_id], # # ) # # decision_book_payment_detail: Mapped[List["BuildDecisionBookPaymentsDetail"]] = ( # # relationship( # # "BuildDecisionBookPaymentsDetail", # # back_populates="decision_book_master", # # foreign_keys="BuildDecisionBookPaymentsDetail.build_decision_book_payments_master_id", # # ) # # ) # # __table_args__ = ( # Index( # "_build_decision_book_payments_master_ndx_00", # build_decision_book_item_debits_id, # build_parts_id, # dues_types_id, # unique=True, # ), # { # "comment": "Master Payment Items related to decision taken at building meetings" # }, # ) # # # @classmethod # # def pay_dues_of_build_part( # # cls, # # budget_records_id, # # build_decision_book_id, # # build_parts_id, # # start_date, # # paid_value, # # is_all=False, # # is_limited=False, # # ): # # # # book_payment_master = cls.find_one( # # build_decision_book_id=build_decision_book_id, # # build_parts_id=build_parts_id, # # dues_types=BuildDuesTypes.D.name, # # ) # # paid_amount = 0 # # if book_payment_master: # # month_start_date = ( # # find_first_day_of_month(start_date) # # if not is_all # # else datetime(1900, 1, 1) # # ) # # last_date = ( # # find_last_day_of_month(start_date) if not is_limited else start_date # # ) # # payment_dues, count = BuildDecisionBookPaymentsDetail.filter( # # and_( # # BuildDecisionBookPaymentsDetail.build_decision_book_payments_master_id # # == book_payment_master.id, # # BuildDecisionBookPaymentsDetail.process_date >= month_start_date, # # BuildDecisionBookPaymentsDetail.process_date <= last_date, # # ) # # ) # # period_amount = {} # # for payment_due in payment_dues: # # if payment_due.period_time not in period_amount: # # period_amount[payment_due.period_time] = 0 # # period_amount[payment_due.period_time] += float( # # payment_due.payment_amount # # ) # # paid_amount += payment_due.payment_amount # # print( # # "period_amount", # # period_amount, # # "paid_amount", # # paid_amount, # # "paid_value", # # paid_value, # # ) # # if paid_amount > 0: # # return float(paid_value) # # period_amounts = sorted( # # period_amount.items(), key=lambda x: x[0], reverse=False # # ) # # for period_amount in period_amounts: # # if period_amount[1] >= 0: # # continue # # if not paid_value > 0: # # break # # if budget_record := CompanyBudgetRecords.find_one(id=budget_records_id): # # debit_to_pay = abs(float(period_amount[1])) # # debit_to_pay = ( # # paid_value if debit_to_pay > paid_value else debit_to_pay # # ) # # budget_record.remainder_balance = float(debit_to_pay) + float( # # budget_record.remainder_balance # # ) # # budget_record.save() # # BuildDecisionBookPaymentsDetail.find_or_create( # # build_decision_book_payments_master_id=book_payment_master.id, # # budget_records_id=budget_records_id, # # process_date=str(start_date), # # receive_debit=DebitTypes.R.name, # # period_time=str(period_amount[0]), # # process_date_y=str(period_amount[0]).split("-")[0], # # process_date_m=str(period_amount[0]).split("-")[1], # # payment_amount=abs(debit_to_pay), # # ) # # paid_value = float(paid_value) - float(debit_to_pay) # # return float(paid_value) # # # # class BuildDecisionBookItemDebits(CrudCollection): # """ # Builds class based on declarative_base and BaseMixin via session # dues_values = due_key, due_value # """ # # __tablename__ = "build_decision_book_item_debits" # __exclude__fields__ = [] # __enum_list__ = [("dues_types", "BuildDuesTypes", "D")] # # dues_types_id: Mapped[Identity] = mapped_column(ForeignKey("api_enum_dropdown.id"), nullable=True) # dues_types_uu_id = mapped_column(String, nullable=True, comment="Dues Type UUID") # # dues_values = mapped_column( # # MutableDict.as_mutable(JSONB()), # # nullable=False, # # comment="Due Part Key Description of inner parts", # # ) # flat_type = mapped_column( # String, nullable=True, comment="Flat Type of Building Part" # ) # flat_payment = mapped_column( # Numeric(20, 2), nullable=True, comment="Flat Payment Amount" # ) # decision_taken: Mapped[bool] = mapped_column(Boolean, server_default="0") # # build_decision_book_item_id = mapped_column( # ForeignKey("build_decision_book_items.id"), nullable=False # ) # build_decision_book_item_uu_id = mapped_column( # String, nullable=True, comment="Decision Book Item UUID" # ) # # @classmethod # def select_action(cls, duty_id, token=None): # from database_sql_models import Companies # # related_companies = Companies.select_action(duty_id=duty_id) # related_companies_ids = list( # related_.id for related_ in related_companies.all() # ) # related_building = Build.query.filter( # Build.company_id.in_(related_companies_ids) # ) # related_building_ids = list(related_.id for related_ in related_building.all()) # related_decision_books = BuildDecisionBook.query.filter( # BuildDecisionBook.build_id.in_(related_building_ids) # ) # related_decision_books_ids = list( # related_.id for related_ in related_decision_books.all() # ) # related_decision_books_items = BuildDecisionBookItems.query.filter( # BuildDecisionBookItems.build_decision_book_id.in_( # related_decision_books_ids # ) # ) # related_decision_books_items_ids = list( # related_.id for related_ in related_decision_books_items.all() # ) # return cls.query.filter( # cls.build_decision_book_item_id.in_(related_decision_books_items_ids) # ) # # @classmethod # def create_action(cls, data: InsertBuildDecisionBookItemDebits, token): # from database_sql_models import ApiEnumDropdown # from application.shared_functions import find_last_day_of_month # # data_dict = data.dump() # BuildDecisionBookItems.pre_query = BuildDecisionBookItems.select_action( # duty_id=token.duty_list["duty_id"] # ) # cls.pre_query = cls.select_action(duty_id=token.duty_list["duty_id"]) # if decision_book_item := BuildDecisionBookItems.find_one_or_abort( # uu_id=data.build_decision_book_item_uu_id # ): # data_dict["build_decision_book_item_id"] = decision_book_item.id # dues_values, payment_master_list = data_dict["dues_values"], [] # data_dict["is_confirmed"] = True # del data_dict["build_decision_book_item_uu_id"] # item_debits = cls.find_or_create(**data_dict) # debit_dropdown = ApiEnumDropdown.find_one( # enum_class="DebitTypes", value="Debit" # ) # for dues_key, dues_value in dues_values.items(): # building_parts = decision_book_item.decision_books.buildings.parts # decision_book = decision_book_item.decision_books # for building_part in building_parts: # detail_list = [] # if str(building_part.due_part_key) == str(dues_key): # book_master = BuildDecisionBookPaymentsMaster.create( # build_decision_book_item_debits_id=item_debits.id, # build_parts_id=building_part.id, # dues_types=debit_dropdown.uu_id, # payment_plan_time_periods="M", # default_payment_amount=dues_value, # is_confirmed=True, # ) # if book_master: # start_date = decision_book.expiry_starts # while start_date <= decision_book.expiry_ends: # start_date = find_last_day_of_month(start_date) # data_detail = BuildDecisionBookPaymentsDetail.find_or_create( # build_decision_book_payments_master_id=book_master.id, # budget_records_id=None, # process_date=start_date, # receive_debit=debit_dropdown.uu_id, # period_time=start_date.strftime("%Y-%m"), # process_date_y=start_date.year, # process_date_m=start_date.month, # accounting_id=None, # payment_amount=float(dues_value) * -1, # is_confirmed=True, # ) # start_date = start_date + timedelta(days=2) # detail_list.append(data_detail.get_dict()) # payment_master_list.append( # {**book_master.get_dict(), "detail_list": detail_list} # ) # return_dict = { # **item_debits.get_dict(), # "debit_lists": payment_master_list, # } # return return_dict # # __table_args__ = ( # { # "comment": "Debits of Decision Book Items that are related to decision taken at building meetings" # }, # ) # # class BuildDecisionBookBudget(CrudCollection): # """ # Builds class based on declarative_base and BaseMixin via session # """ # # __tablename__ = "build_decision_book_budget" # # item_order = mapped_column(SmallInteger, nullable=False, comment="Order Number") # budget_type = mapped_column(String, nullable=False, comment="Budget Type") # plan_value: Mapped[float] = mapped_column(Numeric(10, 2), nullable=False, comment="Plan Value") # # line_comment = mapped_column(String(32), server_default="") # process_date_y: Mapped[int] = mapped_column(SmallInteger) # process_date_m: Mapped[int] = mapped_column(SmallInteger) # process_date_w: Mapped[int] = mapped_column(SmallInteger) # period_time = mapped_column(String(12), server_default="") # # build_decision_book_id: Mapped[Identity] = mapped_column(ForeignKey("build_decision_book.id")) # accounting_id = mapped_column(ForeignKey("account_detail.id")) # # __table_args__ = ( # Index("_build_decision_book_budget_ndx_01", accounting_id), # {"comment": "Budget Items related to decision taken at building meetings"}, # ) # # # class BuildDecisionBookBudgetItem(CrudCollection): # """ # Builds class based on declarative_base and BaseMixin via session # """ # # __tablename__ = "build_decision_book_budget_item" # __exclude__fields__ = [] # # paid_date = mapped_column(TIMESTAMP, nullable=False, comment="Payment Due Date") # period_time = mapped_column(String(12), server_default="") # paid_value: Mapped[float] = mapped_column(Numeric(10, 2), server_default="0") # # build_decision_book_budget_id = mapped_column( # ForeignKey("build_decision_book_budget.id"), nullable=False # ) # # __table_args__ = ( # Index( # "_build_decision_book_budget_item_ndx_01", # build_decision_book_budget_id, # paid_date, # ), # ) # # buildings: Mapped["Build"] = relationship( # "Build", back_populates="decision_books", foreign_keys=[build_id] # ) # companies: Mapped[List["Company"]] = relationship( # "Company", back_populates="decision_books", foreign_keys=[resp_company_id] # ) # budget_records: Mapped[List["CompanyBudgetRecords"]] = relationship( # "CompanyBudgetRecords", # back_populates="decision_books", # foreign_keys="CompanyBudgetRecords.build_decision_book_id", # ) # decision_book_items: Mapped[List["BuildDecisionBookItems"]] = relationship( # "BuildDecisionBookItems", # back_populates="decision_books", # foreign_keys="BuildDecisionBookItems.build_decision_book_id", # ) # # decision_book_management: Mapped["BuildDecisionBookManagement"] = relationship( # "BuildDecisionBookManagement", # back_populates="decision_book", # foreign_keys="BuildDecisionBookManagement.build_decision_book_id", # ) # # decision_book_people: Mapped[List["BuildDecisionBookPerson"]] = relationship( # "BuildDecisionBookPerson", # back_populates="decision_books", # foreign_keys="BuildDecisionBookPerson.build_decision_book_id", # ) # # # decision_book_projects: Mapped[List["DecisionBookProjects"]] = relationship( # # "DecisionBookProjects", # # back_populates="decision_books", # # foreign_keys="DecisionBookProjects.build_decision_book_id", # # ) # # decision_book_project_people: Mapped[List["BuildDecisionBookProjectPerson"]] = ( # # relationship( # # "BuildDecisionBookProjectPerson", # # back_populates="decision_books", # # foreign_keys="BuildDecisionBookProjectPerson.build_decision_book_id", # # ) # # ) # decision_book_legal_people: Mapped["BuildDecisionBookProjectsLegal"] = relationship( # "BuildDecisionBookProjectsLegal", # back_populates="decision_books", # foreign_keys="BuildDecisionBookProjectsLegal.build_decision_book_id", # ) # # decision_book_budget: Mapped["BuildDecisionBookBudget"] = relationship( # "BuildDecisionBookBudget", # back_populates="decision_book", # foreign_keys="BuildDecisionBookBudget.build_decision_book_id", # ) # decision_book_items: Mapped[List["BuildDecisionBookItems"]] = relationship( # "BuildDecisionBookItems", # back_populates="decision_book_item_debits", # foreign_keys=[build_decision_book_item_id], # ) # decision_book_payment_masters: Mapped[List["BuildDecisionBookPaymentsMaster"]] = relationship( # "BuildDecisionBookPaymentsMaster", # back_populates="decision_books_item_debits", # foreign_keys="BuildDecisionBookPaymentsMaster.build_decision_book_item_debits_id", # ) # # decision_books: Mapped["BuildDecisionBook"] = relationship( # "BuildDecisionBook", # back_populates="decision_book_items", # foreign_keys=[build_decision_book_id], # ) # decision_book_item_debits: Mapped[List["BuildDecisionBookItemDebits"]] = ( # relationship( # "BuildDecisionBookItemDebits", # back_populates="decision_book_items", # foreign_keys="BuildDecisionBookItemDebits.build_decision_book_item_id", # ) # ) # decision_book_projects: Mapped["DecisionBookProjects"] = relationship( # "DecisionBookProjects", # back_populates="decision_book_items", # foreign_keys="DecisionBookProjects.build_decision_book_item_id", # ) # decision_book_legal: Mapped["BuildDecisionBookLegal"] = relationship( # "BuildDecisionBookLegal", # back_populates="decision_books_items", # foreign_keys="BuildDecisionBookLegal.build_db_item_id", # ) # # build_decision_book_item_unapproved: Mapped[ # List["BuildDecisionBookItemsUnapproved"] # ] = relationship( # "BuildDecisionBookItemsUnapproved", # back_populates="decision_book_items", # foreign_keys="BuildDecisionBookItemsUnapproved.build_decision_book_item", # ) # decision_books_items: Mapped["BuildDecisionBookItems"] = relationship( # "BuildDecisionBookItems", # back_populates="decision_book_legal", # foreign_keys=[build_db_item_id], # ) # attorney_companies: Mapped["Companies"] = relationship( # "Company", # back_populates="decision_book_legal", # foreign_keys=[resp_attorney_company], # ) # attorney_persons: Mapped["People"] = relationship( # "People", # back_populates="attorney_decision_book_legal", # foreign_keys=[resp_attorney_id], # ) # lawyer_persons: Mapped["People"] = relationship( # "People", # back_populates="lawyer_decision_book_legal", # foreign_keys=[mediator_lawyer_person_id], # ) # decision_books: Mapped["BuildDecisionBook"] = relationship( # "BuildDecisionBook", # back_populates="decision_book_people", # foreign_keys=[build_decision_book_id], # ) # people: Mapped["People"] = relationship( # "People", back_populates="decision_book_people", foreign_keys=[person_id] # ) # decision_book_budget: Mapped["BuildDecisionBookBudget"] = relationship( # "BuildDecisionBookBudget", # back_populates="decision_book_budget_item", # foreign_keys=[build_decision_book_budget_id], # ) # accounting: Mapped["AccountDetail"] = relationship( # "AccountDetail", # back_populates="decision_book_budget", # foreign_keys=[accounting_id], # ) # decision_book: Mapped["BuildDecisionBook"] = relationship( # "BuildDecisionBook", # back_populates="decision_book_budget", # foreign_keys=[build_decision_book_id], # ) # decision_book_budget_item: Mapped["BuildDecisionBookBudgetItem"] = relationship( # "BuildDecisionBookBudgetItem", # back_populates="decision_book_budget", # foreign_keys="BuildDecisionBookBudgetItem.build_decision_book_budget_id", # ) # decision_book_items: Mapped["BuildDecisionBookItems"] = relationship( # "BuildDecisionBookItems", # back_populates="build_decision_book_item_unapproved", # foreign_keys=[build_decision_book_item], # ) # # peoples: Mapped["People"] = relationship( # "People", # back_populates="build_decision_book_item_unapproved", # foreign_keys=[person_id], # ) # # class BuildDecisionBookInvitationsPerson(CrudCollection): # """ # Builds class based on declarative_base and BaseMixin via session # """ # # __tablename__ = "build_decision_book_invitations_person" # __exclude__fields__ = [] # # invite_id = mapped_column(ForeignKey("build_decision_book_invitations.id"), nullable=False) # invite_uu_id = mapped_column(String, nullable=True, comment="Invite UUID") # person_id = mapped_column(ForeignKey("people.id"), nullable=False) # person_uu_id = mapped_column(String, nullable=False, comment="Person UUID") # # send_date = mapped_column(TIMESTAMP, nullable=False, comment="Confirmation Date") # is_confirmed: Mapped[bool] = mapped_column(Boolean, server_default="0", comment="Message is Confirmed") # confirmed_date = mapped_column(TIMESTAMP, nullable=True, comment="Confirmation Date") # token = mapped_column(String, server_default="", comment="Invitation Token") # # __table_args__ = ( # Index( # "decision_book_invitations_person_ndx_01", # invite_id, # person_id, # unique=True, # ), # {"comment": "People that are invited to building meetings."}, # )