evyos-center-server/prod-wag-backend-automate-services-2
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

3 services are updated

Browse Source
This commit is contained in:
Berkay
2025-05-13 18:29:02 +03:00
parent cd62d96158
commit 6dfa17c5e6
54 changed files with 1374 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
api_services/api_builds/initial_service/Dockerfile Normal file
View File

@@ -0,0 +1,26 @@
FROM python:3.12-slim
WORKDIR /
# Install system dependencies and Poetry
RUN apt-get update && apt-get install -y --no-install-recommends gcc && rm -rf /var/lib/apt/lists/* && pip install --no-cache-dir poetry
# Copy Poetry configuration
COPY /pyproject.toml ./pyproject.toml
# Configure Poetry and install dependencies with optimizations
RUN poetry config virtualenvs.create false && poetry install --no-interaction --no-ansi --no-root --only main && pip cache purge && rm -rf ~/.cache/pypoetry
# Copy application code
COPY /api_services/api_controllers /api_controllers
COPY /api_services/schemas /schemas
COPY /api_services/api_modules /api_modules
COPY /api_services/api_builds/initial-service /initial-service
COPY /api_services/api_builds/initial-service /
# Set Python path to include app directory
ENV PYTHONPATH=/ PYTHONUNBUFFERED=1 PYTHONDONTWRITEBYTECODE=1
# Run the application using the configured uvicorn server
CMD ["poetry", "run", "python", "initial-service/app.py"]

119
api_services/api_builds/initial_service/alembic.ini Normal file
View File

@@ -0,0 +1,119 @@
# A generic, single database configuration.
[alembic]
# path to migration scripts
# Use forward slashes (/) also on windows to provide an os agnostic path
script_location = alembic
# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
# Uncomment the line below if you want the files to be prepended with date and time
# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
# for all available tokens
# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
# sys.path path, will be prepended to sys.path if present.
# defaults to the current working directory.
prepend_sys_path = .
# timezone to use when rendering the date within the migration file
# as well as the filename.
# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
# Any required deps can installed by adding `alembic[tz]` to the pip requirements
# string value is passed to ZoneInfo()
# leave blank for localtime
# timezone =
# max length of characters to apply to the "slug" field
# truncate_slug_length = 40
# set to 'true' to run the environment during
# the 'revision' command, regardless of autogenerate
# revision_environment = false
# set to 'true' to allow .pyc and .pyo files without
# a source .py file to be detected as revisions in the
# versions/ directory
# sourceless = false
# version location specification; This defaults
# to alembic/versions. When using multiple version
# directories, initial revisions must be specified with --version-path.
# The path separator used here should be the separator specified by "version_path_separator" below.
# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
# version path separator; As mentioned above, this is the character used to split
# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
# Valid values for version_path_separator are:
#
# version_path_separator = :
# version_path_separator = ;
# version_path_separator = space
# version_path_separator = newline
#
# Use os.pathsep. Default configuration used for new projects.
version_path_separator = os
# set to 'true' to search source files recursively
# in each "version_locations" directory
# new in Alembic version 1.10
# recursive_version_locations = false
# the output encoding used when revision files
# are written from script.py.mako
# output_encoding = utf-8
sqlalchemy.url = postgresql+psycopg2://postgres:password@10.10.2.14:5432/postgres
[post_write_hooks]
# post_write_hooks defines scripts or Python functions that are run
# on newly generated revision scripts. See the documentation for further
# detail and examples
# format using "black" - use the console_scripts runner, against the "black" entrypoint
# hooks = black
# black.type = console_scripts
# black.entrypoint = black
# black.options = -l 79 REVISION_SCRIPT_FILENAME
# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
# hooks = ruff
# ruff.type = exec
# ruff.executable = %(here)s/.venv/bin/ruff
# ruff.options = check --fix REVISION_SCRIPT_FILENAME
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARNING
handlers = console
qualname =
[logger_sqlalchemy]
level = WARNING
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S

1
api_services/api_builds/initial_service/alembic/README Normal file
View File

@@ -0,0 +1 @@
Generic single-database configuration.

89
api_services/api_builds/initial_service/alembic/env.py Normal file
View File

@@ -0,0 +1,89 @@
import os
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from sqlalchemy import pool
from sqlalchemy import create_engine
from alembic import context
from schemas import *
from api_controllers.postgres.engine import Base
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Override sqlalchemy.url with environment variables if they exist
db_host = os.getenv("POSTGRES_HOST", None)
db_port = os.getenv("POSTGRES_PORT", None)
db_user = os.getenv("POSTGRES_USER", None)
db_password = os.getenv("POSTGRES_PASSWORD", None)
db_name = os.getenv("POSTGRES_DB", None)
# Build the connection URL from environment variables
db_url = f"postgresql+psycopg2://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}"
# Override the sqlalchemy.url in the alembic.ini file
config.set_main_option("sqlalchemy.url", db_url)
# Interpret the config file for Python logging.
# This line sets up loggers basically.
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
# my_important_option = config.get_main_option("my_important_option")
# ... etc.
def run_migrations_offline() -> None:
"""Run migrations in 'offline' mode.
This configures the context with just a URL
and not an Engine, though an Engine is acceptable
here as well. By skipping the Engine creation
we don't even need a DBAPI to be available.
Calls to context.execute() here emit the given string to the
script output.
"""
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
"""Run migrations in 'online' mode.
In this scenario we need to create an Engine
and associate a connection with the context.
"""
connectable = engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
with connectable.connect() as connection:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()

28
api_services/api_builds/initial_service/alembic/script.py.mako Normal file
View File

@@ -0,0 +1,28 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
"""Upgrade schema."""
${upgrades if upgrades else "pass"}
def downgrade() -> None:
"""Downgrade schema."""
${downgrades if downgrades else "pass"}

43
api_services/api_builds/initial_service/app.py Normal file
View File

@@ -0,0 +1,43 @@
import os
from api_controllers.postgres.engine import get_db
from init_app_defaults import create_application_defaults
from init_enums import init_api_enums_build_types
from init_alembic import generate_alembic
from init_occupant_types import create_occupant_types_defaults
from init_services import create_modules_and_services_and_actions
from init_address import create_one_address
from init_occ_defaults import create_occupant_defaults
set_alembic = bool(int(os.getenv("SET_ALEMBIC"), 0))
if __name__ == "__main__":
print(f"Set alembic: {set_alembic}")
with get_db() as db_session:
if set_alembic:
generate_alembic(session=db_session)
try:
create_one_address(db_session=db_session)
except Exception as e:
print(f"Error creating address: {e}")
try:
init_api_enums_build_types(db_session=db_session)
except Exception as e:
print(f"Error creating enums: {e}")
try:
create_application_defaults(db_session=db_session)
except Exception as e:
print(f"Error creating application defaults: {e}")
try:
create_occupant_types_defaults(db_session=db_session)
except Exception as e:
print(f"Error creating occupant types defaults: {e}")
try:
create_modules_and_services_and_actions(db_session=db_session)
except Exception as e:
print(f"Error creating modules and services and actions: {e}")
try:
create_occupant_defaults(db_session=db_session)
except Exception as e:
print(f"Error creating occupant defaults: {e}")

144
api_services/api_builds/initial_service/init_address.py Normal file
View File

@@ -0,0 +1,144 @@
from schemas import (
Addresses,
AddressCity,
AddressStreet,
AddressLocality,
AddressDistrict,
AddressNeighborhood,
AddressState,
AddressCountry,
)
def create_one_address(db_session):
address_list = []
AddressCountry.set_session(db_session)
country = AddressCountry.query.filter_by(country_name="TÜRKİYE", country_code="TR").first()
if not country:
country = AddressCountry.create(
country_name="TÜRKİYE", country_code="TR", is_confirmed=True
)
country.save()
address_list.append(country)
else:
print(f"Country already exists {country.to_dict()}")
AddressState.set_session(db_session)
state = AddressState.query.filter_by(state_name="TÜRKİYE", state_code="TR").first()
if not state:
state = AddressState.create(
state_name="TÜRKİYE",
state_code="TR",
phone_code="90",
country_id=country.id,
country_uu_id=str(country.uu_id),
is_confirmed=True,
)
state.save()
address_list.append(state)
else:
print(f"State already exists {state.to_dict()}")
AddressCity.set_session(db_session)
city = AddressCity.query.filter_by(city_name="ANKARA", city_code="6").first()
if not city:
city = AddressCity.create(
city_name="ANKARA",
city_code="6",
licence_plate="06",
state_id=state.id,
state_uu_id=str(state.uu_id),
is_confirmed=True,
)
city.save()
address_list.append(city)
else:
print(f"City already exists {city.to_dict()}")
AddressDistrict.set_session(db_session)
district = AddressDistrict.query.filter_by(district_name="ÇANKAYA", district_code="1231").first()
if not district:
district = AddressDistrict.create(
district_name="ÇANKAYA",
district_code="1231",
city_id=city.id,
city_uu_id=str(city.uu_id),
is_confirmed=True,
)
district.save()
address_list.append(district)
else:
print(f"District already exists {district.to_dict()}")
AddressLocality.set_session(db_session)
locality = AddressLocality.query.filter_by(locality_name="MERKEZ", locality_code="2431").first()
if not locality:
locality = AddressLocality.create(
locality_name="MERKEZ",
locality_code="2431",
type_code="3",
type_description=None,
district_id=district.id,
district_uu_id=str(district.uu_id),
is_confirmed=True,
)
locality.save()
address_list.append(locality)
else:
print(f"Locality already exists {locality.to_dict()}")
AddressNeighborhood.set_session(db_session)
neighborhood = AddressNeighborhood.query.filter_by(neighborhood_name="AYRANCI MAHALLESİ", neighborhood_code="1522").first()
if not neighborhood:
neighborhood = AddressNeighborhood.create(
neighborhood_name="AYRANCI MAHALLESİ",
neighborhood_code="1522",
type_code="1",
type_description="MAHALLESİ",
locality_id=locality.id,
locality_uu_id=str(locality.uu_id),
is_confirmed=True,
)
neighborhood.save()
address_list.append(neighborhood)
else:
print(f"Neighborhood already exists {neighborhood.to_dict()}")
AddressStreet.set_session(db_session)
street = AddressStreet.query.filter_by(street_name="REŞAT NURİ CADDESİ", street_code="52270").first()
if not street:
street = AddressStreet.create(
street_name="REŞAT NURİ CADDESİ",
type_description="CADDESİ",
type_code="3",
street_code="52270",
neighborhood_id=neighborhood.id,
neighborhood_uu_id=str(neighborhood.uu_id),
is_confirmed=True,
)
street.save()
address_list.append(street)
else:
print(f"Street already exists {street.to_dict()}")
Addresses.set_session(db_session)
address = Addresses.query.filter_by(street_id=street.id, street_uu_id=str(street.uu_id)).first()
if not address:
address = Addresses.create(
street_id=street.id,
street_uu_id=str(street.uu_id),
build_number="Ex1",
door_number="1",
floor_number="1",
comment_address="Example Address",
letter_address="Example Address",
short_letter_address="Example Address",
latitude=0,
longitude=0,
is_confirmed=True,
)
address.save()
address_list.append(address)
else:
print(f"Address already exists {address.to_dict()}")

23
api_services/api_builds/initial_service/init_alembic.py Normal file
View File

@@ -0,0 +1,23 @@
import os
from sqlalchemy import text
def generate_alembic(session):
try:
result = session.execute(
text(
"SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = "
"'alembic_version') AS table_existence;"
)
)
if result.first()[0]:
session.execute(text("delete from alembic_version;"))
session.commit()
except Exception as e:
print(e)
finally:
run_command = "python -m alembic stamp head;"
run_command += (
"python -m alembic revision --autogenerate;python -m alembic upgrade head;"
)
os.system(run_command)

660
api_services/api_builds/initial_service/init_app_defaults.py Normal file
View File

@@ -0,0 +1,660 @@
import arrow
from api_modules.token.password_module import PasswordModule
from api_controllers.mongo.database import mongo_handler
from schemas import (
Companies,
Departments,
Duty,
Duties,
Employees,
People,
Users,
Staff,
RelationshipDutyCompany,
)
def create_application_defaults(db_session):
created_list, created_by, confirmed_by = [], "System", "System"
active_row = dict(is_confirmed=True, active=True, deleted=False, is_notification_send=True)
Companies.set_session(db_session)
Departments.set_session(db_session)
Duties.set_session(db_session)
Duty.set_session(db_session)
Staff.set_session(db_session)
People.set_session(db_session)
Users.set_session(db_session)
Employees.set_session(db_session)
RelationshipDutyCompany.set_session(db_session)
company_management = Companies.query.filter_by(company_tag="Evyos",).first()
if not company_management:
company_management = Companies.find_or_create(
**{
"formal_name": "Evyos LTD",
"public_name": "Evyos Verimlilik Sistemleri",
"company_type": "LTD",
"commercial_type": "Commercial",
"tax_no": "123132123132",
"company_tag": "Evyos",
"default_lang_type": "TR",
"default_money_type": "TL",
"is_commercial": True,
"is_confirmed": True,
}
)
created_list.append(company_management)
else:
print(f"Company Management Found {company_management.to_dict()}")
company_id, company_uu_id = company_management.id, str(company_management.uu_id)
execution = Departments.query.filter_by(department_code="EO001", company_id=company_id).first()
if not execution:
execution = Departments.create(
department_name="Execution Office",
department_code="EO001",
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(execution)
else:
print(f"Execution Found {execution.to_dict()}")
gen_man = Departments.query.filter_by(department_code="GM001", company_id=company_id).first()
if not gen_man:
gen_man = Departments.create(
department_name="General Manager Example",
department_code="GM001",
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(gen_man)
else:
print(f"General Manager Found {gen_man.to_dict()}")
it_dept = Departments.query.filter_by(department_code="ITD001", company_id=company_id).first()
if not it_dept:
it_dept = Departments.create(
department_name="IT Department",
department_code="ITD001",
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(it_dept)
else:
print(f"IT Department Found {it_dept.to_dict()}")
gen_duty = Duty.query.filter_by(duty_code="GM0001").first()
if not gen_duty:
gen_duty = Duty.create(
duty_name="General Manager",
duty_code="GM0001",
duty_description="General Manager",
**active_row,
)
created_list.append(gen_duty)
else:
print(f"General Manager Found {gen_duty.to_dict()}")
bm_duty = Duty.query.filter_by(duty_code="BM0001").first()
if not bm_duty:
bm_duty = Duty.create(
duty_name="Business Manager",
duty_code="BM0001",
duty_description="Business Manager",
**active_row,
)
created_list.append(bm_duty)
else:
print(f"Business Manager Found {bm_duty.to_dict()}")
it_duty = Duty.query.filter_by(duty_code="IT0001").first()
if not it_duty:
it_duty = Duty.create(
duty_name="IT Manager",
duty_code="IT0001",
duty_description="IT Manager",
**active_row,
)
created_list.append(it_duty)
else:
print(f"IT Manager Found {it_duty.to_dict()}")
bulk_duty = Duty.query.filter_by(duty_code="BULK").first()
if not bulk_duty:
bulk_duty = Duty.create(
duty_name="BULK",
duty_code="BULK",
duty_description="BULK RECORDS OF THE COMPANY",
**active_row,
)
created_list.append(bulk_duty)
else:
print(f"Bulk Duty Found {bulk_duty.to_dict()}")
occu_duty = Duty.query.filter_by(duty_code="OCCUPANT").first()
if not occu_duty:
occu_duty = Duty.create(
duty_name="OCCUPANT",
duty_code="OCCUPANT",
duty_description="OCCUPANT RECORDS OF THE COMPANY",
**active_row,
)
created_list.append(occu_duty)
else:
print(f"Occupant Duty Found {occu_duty.to_dict()}")
duties_gen_man = Duties.query.filter_by(company_id=company_id, duties_id=gen_duty.id, department_id=gen_man.id).first()
if not duties_gen_man:
duties_gen_man = Duties.create(
company_id=company_id,
company_uu_id=str(company_uu_id),
duties_id=gen_duty.id,
duties_uu_id=str(gen_duty.uu_id),
department_id=gen_man.id,
department_uu_id=str(gen_man.uu_id),
**active_row,
)
created_list.append(duties_gen_man)
else:
print(f"Duties General Manager Found {duties_gen_man.to_dict()}")
duties_created_bm = Duties.query.filter_by(company_id=company_id, duties_id=bm_duty.id, department_id=execution.id).first()
if not duties_created_bm:
duties_created_bm = Duties.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,
)
created_list.append(duties_created_bm)
else:
print(f"Duties Business Manager Found {duties_created_bm.to_dict()}")
duties_created_it = Duties.query.filter_by(company_id=company_id, duties_id=bulk_duty.id, department_id=execution.id).first()
if not duties_created_it:
duties_created_it = Duties.create(
company_id=company_id,
company_uu_id=str(company_uu_id),
duties_id=bulk_duty.id,
duties_uu_id=str(bulk_duty.uu_id),
department_id=execution.id,
department_uu_id=str(execution.uu_id),
**active_row,
)
created_list.append(duties_created_it)
else:
print(f"Duties Bulk Found {duties_created_it.to_dict()}")
duties_created_occupant = Duties.query.filter_by(company_id=company_id, duties_id=occu_duty.id, department_id=execution.id).first()
if not duties_created_occupant:
duties_created_occupant = Duties.create(
company_id=company_id,
company_uu_id=str(company_uu_id),
duties_id=occu_duty.id,
duties_uu_id=str(occu_duty.uu_id),
department_id=execution.id,
department_uu_id=str(execution.uu_id),
**active_row,
)
created_list.append(duties_created_occupant)
else:
print(f"Duties Occupant Found {duties_created_occupant.to_dict()}")
bulk_duty = Duty.query.filter_by(duty_code="BULK").first()
if not bulk_duty:
bulk_duty = Duty.create(
duty_name="BULK",
duty_code="BULK",
duty_description="BULK RECORDS OF THE COMPANY",
**active_row,
)
created_list.append(bulk_duty)
else:
print(f"Bulk Duty Found {bulk_duty.to_dict()}")
it_dept = Departments.query.filter_by(department_code="ITD001", company_id=company_id).first()
if not it_dept:
it_dept = Departments.create(
department_name="IT Department",
department_code="ITD001",
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(it_dept)
else:
print(f"IT Department Found {it_dept.to_dict()}")
created_duty = Duty.query.filter_by(duty_code="DM").first()
if not created_duty:
created_duty = Duty.create(
duty_name="Database Manager",
duty_code="DM",
duty_description="Database Manager",
created_by=created_by,
confirmed_by=confirmed_by,
is_confirmed=True,
active=True,
deleted=False,
is_notification_send=True,
)
created_list.append(created_duty)
created_duty = Duty.query.filter_by(duty_code="NM").first()
if not created_duty:
created_duty = Duty.create(
duty_name="Network Manager",
duty_code="NM",
duty_description="Network Manager",
created_by=created_by,
confirmed_by=confirmed_by,
is_confirmed=True,
active=True,
deleted=False,
is_notification_send=True,
)
created_list.append(created_duty)
application_manager_duty = Duty.query.filter_by(duty_code="AM").first()
if not application_manager_duty:
application_manager_duty = Duty.create(
duty_name="Application Manager",
duty_code="AM",
duty_description="Application Manager",
created_by=created_by,
confirmed_by=confirmed_by,
is_confirmed=True,
active=True,
deleted=False,
is_notification_send=True,
)
created_list.append(application_manager_duty)
application_super_user_duty = Duty.query.filter_by(duty_code="SUE").first()
if not application_super_user_duty:
application_super_user_duty = Duty.create(
duty_name="Super User",
duty_code="SUE",
duty_description="Super User",
created_by=created_by,
confirmed_by=confirmed_by,
**active_row,
)
created_list.append(application_super_user_duty)
application_manager_duties = Duties.query.filter_by(
department_id=it_dept.id,
duties_id=application_manager_duty.id,
company_id=company_id,
).first()
if not application_manager_duties:
application_manager_duties = Duties.create(
department_id=it_dept.id,
department_uu_id=str(it_dept.uu_id),
duties_id=application_manager_duty.id,
duties_uu_id=str(application_manager_duty.uu_id),
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(application_manager_duties)
else:
print(f"Application Manager Duties Found {application_manager_duties.to_dict()}")
super_user_duties = Duties.query.filter_by(
department_id=it_dept.id,
duties_id=application_super_user_duty.id,
company_id=company_id,
).first()
if not super_user_duties:
super_user_duties = Duties.create(
department_id=it_dept.id,
department_uu_id=str(it_dept.uu_id),
duties_id=application_super_user_duty.id,
duties_uu_id=str(application_manager_duty.uu_id),
company_id=company_id,
company_uu_id=str(company_uu_id),
**active_row,
)
created_list.append(super_user_duties)
else:
print(f"Super User Duties Found {super_user_duties.to_dict()}")
relation_super_user_duties = RelationshipDutyCompany.query.filter_by(
duties_id=super_user_duties.id,
owner_id=company_id,
member_id=company_id,
).first()
if not relation_super_user_duties:
relation_super_user_duties = RelationshipDutyCompany.create(
duties_id=super_user_duties.id,
owner_id=company_id,
member_id=company_id,
parent_id=None,
child_count=0,
**active_row,
)
created_list.append(super_user_duties)
relation_application_manager_duties = RelationshipDutyCompany.query.filter_by(
duties_id=application_manager_duties.id,
owner_id=company_id,
member_id=company_id,
).first()
if not relation_application_manager_duties:
relation_application_manager_duties = RelationshipDutyCompany.create(
duties_id=application_manager_duties.id,
owner_id=company_id,
member_id=company_id,
parent_id=None,
child_count=0,
**active_row,
)
created_list.append(relation_application_manager_duties)
app_manager = People.query.filter_by(
person_tag="BAM-System",
).first()
if not app_manager:
app_manager = People.create(
**{
"person_tag": "BAM-System",
"firstname": "Berkay Application Manager",
"surname": "Karatay",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312312",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231231",
**active_row,
},
)
created_list.append(app_manager)
else:
print(f"Application Manager Found {app_manager.to_dict()}")
sup_manager = People.query.filter_by(person_tag="BSU-System").first()
if not sup_manager:
sup_manager = People.create(
**{
"person_tag": "BSU-System",
"firstname": "Berkay Super User",
"surname": "Karatay",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312313",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231232",
**active_row,
},
)
created_list.append(sup_manager)
else:
print(f"Super User Found {sup_manager.to_dict()}")
gen_manager_people = People.query.filter_by(person_tag="BM-System").first()
if not gen_manager_people:
gen_manager_people = People.create(
**{
"person_tag": "BM-System",
"firstname": "Example General Manager",
"surname": "Example",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312314",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231233",
**active_row,
},
)
created_list.append(gen_manager_people)
else:
print(f"General Manager Found {gen_manager_people.to_dict()}")
application_manager_staff = Staff.query.filter_by(staff_code="AME", duties_id=application_manager_duties.id).first()
if not application_manager_staff:
application_manager_staff = Staff.create(
**{
"staff_code": "AME",
"staff_name": "Application Manager Employee",
"staff_description": "Application Manager Employee",
"duties_id": application_manager_duties.id,
"duties_uu_id": str(application_manager_duty.uu_id),
**active_row,
},
)
created_list.append(application_manager_staff)
else:
print(f"Application Manager Found {application_manager_staff.to_dict()}")
super_user_staff = Staff.query.filter_by(staff_code="SUE", duties_id=super_user_duties.id).first()
if not super_user_staff:
super_user_staff = Staff.create(
**{
"staff_code": "SUE",
"staff_name": "Super User Employee",
"staff_description": "Super User Employee",
"duties_id": super_user_duties.id,
"duties_uu_id": str(super_user_duties.uu_id),
**active_row,
},
)
created_list.append(super_user_staff)
else:
print(f"Super User Found {super_user_staff.to_dict()}")
gen_manager_staff = Staff.query.filter_by(staff_code="GME", duties_id=duties_gen_man.id).first()
if not gen_manager_staff:
gen_manager_staff = Staff.create(
**{
"staff_code": "GME",
"staff_name": "General Manager Employee",
"staff_description": "General Manager Employee",
"duties_id": duties_gen_man.id,
"duties_uu_id": str(duties_gen_man.uu_id),
**active_row,
},
)
created_list.append(gen_manager_staff)
else:
print(f"General Manager Found {gen_manager_staff.to_dict()}")
application_manager_staff = Staff.query.filter_by(staff_code="AME", duties_id=application_manager_duty.id).first()
if not application_manager_staff:
application_manager_staff = Staff.create(
**{
"staff_code": "AME",
"staff_name": "Application Manager Employee",
"staff_description": "Application Manager Employee",
"duties_id": application_manager_duty.id,
"duties_uu_id": str(application_manager_duty.uu_id),
**active_row,
},
)
created_list.append(application_manager_staff)
gen_man_staff = Staff.query.filter_by(staff_code="GME", duties_id=duties_gen_man.id).first()
if not gen_man_staff:
gen_man_staff = Staff.create(
**{
"staff_code": "GME",
"staff_name": "General Manager Employee",
"staff_description": "General Manager Employee",
"duties_id": duties_gen_man.id,
"duties_uu_id": str(gen_duty.uu_id),
**active_row,
},
)
created_list.append(gen_man_staff)
gen_man_employee = Employees.query.filter_by(staff_id=gen_man_staff.id, people_id=gen_manager_people.id).first()
if not gen_man_employee:
gen_man_employee = Employees.create(
staff_id=gen_man_staff.id,
staff_uu_id=str(gen_man_staff.uu_id),
people_id=gen_manager_people.id,
people_uu_id=str(gen_manager_people.uu_id),
**active_row,
)
created_list.append(gen_man_employee)
app_manager_employee = Employees.query.filter_by(staff_id=application_manager_staff.id, people_id=app_manager.id).first()
if not app_manager_employee:
app_manager_employee = Employees.create(
staff_id=application_manager_staff.id,
staff_uu_id=str(application_manager_staff.uu_id),
people_id=app_manager.id,
people_uu_id=str(app_manager.uu_id),
**active_row,
)
created_list.append(app_manager_employee)
super_user_employee = Employees.query.filter_by(staff_id=super_user_staff.id, people_id=sup_manager.id).first()
if not super_user_employee:
super_user_employee = Employees.create(
staff_id=super_user_staff.id,
staff_uu_id=str(super_user_staff.uu_id),
people_id=sup_manager.id,
people_uu_id=str(sup_manager.uu_id),
**active_row,
)
created_list.append(super_user_employee)
gen_manager_user = Users.query.filter_by(person_id=gen_manager_people.id, user_tag=gen_manager_people.person_tag).first()
if not gen_manager_user:
gen_manager_user = Users.create(
person_id=gen_manager_people.id,
person_uu_id=str(gen_manager_people.uu_id),
user_tag=gen_manager_people.person_tag,
email="example.general@evyos.com.tr",
phone_number="+901111111111",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(gen_manager_user)
gen_manager_user.password_expiry_begins = str(arrow.now())
gen_manager_user.password_token = PasswordModule.generate_refresher_token()
main_domain, collection_name = (
"evyos.com.tr",
f"{str(company_management.uu_id)}*Domain",
)
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one(
{"user_uu_id": str(gen_manager_user.uu_id)}
)
if not existing_record:
mongo_engine.insert_one(
document={
"user_uu_id": str(gen_manager_user.uu_id),
"other_domains_list": [main_domain],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
)
else:
mongo_engine.update_one(
{"user_uu_id": str(gen_manager_user.uu_id)},
{
"$set": {
"other_domains_list": [main_domain],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
},
)
app_manager_user = Users.query.filter_by(person_id=app_manager.id, user_tag=app_manager.person_tag).first()
if not app_manager_user:
app_manager_user = Users.create(
person_id=app_manager.id,
user_tag=app_manager.person_tag,
email="karatay.berkay.man@evyos.com.tr",
phone_number="+901111111111",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(app_manager_user)
app_manager_user.password_expiry_begins = str(arrow.now())
app_manager_user.password_token = PasswordModule.generate_refresher_token()
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one(
{"user_uu_id": str(app_manager_user.uu_id)}
)
if not existing_record:
mongo_engine.insert_one(
document={
"user_uu_id": str(app_manager_user.uu_id),
"other_domains_list": [main_domain],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
)
else:
mongo_engine.update_one(
{"user_uu_id": str(app_manager_user.uu_id)},
{
"$set": {
"other_domains_list": [main_domain],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
},
)
sup_manager_user = Users.query.filter_by(person_id=sup_manager.id, user_tag=sup_manager.person_tag).first()
if not sup_manager_user:
sup_manager_user = Users.create(
person_id=sup_manager.id,
user_tag=sup_manager.person_tag,
email="karatay.berkay.sup@evyos.com.tr",
phone_number="+901111111112",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
created_by=created_by,
confirmed_by=confirmed_by,
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(sup_manager_user)
sup_manager_user.password_expiry_begins = str(arrow.now())
sup_manager_user.password_token = PasswordModule.generate_refresher_token()
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one(
{"user_uu_id": str(sup_manager_employee.uu_id)}
)
if not existing_record:
print("insert sup existing record", existing_record)
mongo_engine.insert_one(
document={
"user_uu_id": str(sup_manager_employee.uu_id),
"other_domains_list": [main_domain, "management.com.tr"],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
)
else:
print("update sup existing record", existing_record)
# Optionally update the existing record if needed
mongo_engine.update_one(
{"user_uu_id": str(sup_manager_employee.uu_id)},
{
"$set": {
"other_domains_list": [main_domain, "management.com.tr"],
"main_domain": main_domain,
"modified_at": arrow.now().timestamp(),
}
},
)
db_session.commit()
print("All Defaults Create is now completed")

266
api_services/api_builds/initial_service/init_enums.py Normal file
View File

@@ -0,0 +1,266 @@
from pydantic import BaseModel
from schemas import BuildTypes, ApiEnumDropdown
class InsertBuildTypes(BaseModel):
function_code: str
type_code: str
lang: str
type_name: str
def init_api_enums_build_types(db_session):
BuildTypes.set_session(db_session)
ApiEnumDropdown.set_session(db_session)
insert_types = [
{
"function_code": "EVYOS",
"type_code": "APT_KZN",
"type_name": "Apartman Kazan Dairesi",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_GRJ",
"type_name": "Apartman Garaj",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_DP",
"type_name": "Apartman Depo",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "DAIRE",
"type_name": "Apartman Dairesi",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT",
"type_name": "Apartman Binası",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_YNT",
"type_name": "Apartman Yönetimi",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_PRK",
"type_name": "Apartman Açık Park Alanı",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_YSL",
"type_name": "Apartman Yeşil Alan",
"lang": "TR",
},
{
"function_code": "EVYOS",
"type_code": "APT_YOL",
"type_name": "Apartman Ara Yol",
"lang": "TR",
},
]
for insert_type in insert_types:
build_types = InsertBuildTypes(
function_code="EVYOS",
lang=insert_type["lang"],
type_code=str(insert_type["type_code"]).upper(),
type_name=insert_type["type_name"],
)
created_build_type = BuildTypes.query.filter_by(
function_code=build_types.function_code,
type_code=build_types.type_code,
).first()
if not created_build_type:
created_build_type = BuildTypes.find_or_create(
**build_types.model_dump(), is_confirmed=True, db=db_session
)
created_build_type.save()
insert_enums = [
{"enum_class": "BuildDuesTypes", "type_code": "BDT-D", "type_name": "Debit"},
{
"enum_class": "BuildDuesTypes",
"type_code": "BDT-A",
"type_name": "Add Debit",
},
{
"enum_class": "BuildDuesTypes",
"type_code": "BDT-R",
"type_name": "Renovation",
},
{
"enum_class": "BuildDuesTypes",
"type_code": "BDT-L",
"type_name": "Lawyer expence",
},
{
"enum_class": "BuildDuesTypes",
"type_code": "BDT-S",
"type_name": "Service fee",
},
{
"enum_class": "BuildDuesTypes",
"type_code": "BDT-I",
"type_name": "Information",
},
{
"enum_class": "AccountingReceiptTypes",
"type_code": "ART-A",
"type_name": "Kasa Tahsil Fişi",
},
{
"enum_class": "AccountingReceiptTypes",
"type_code": "ART-E",
"type_name": "Kasa Tediye Fişi",
},
{
"enum_class": "AccountingReceiptTypes",
"type_code": "ART-M",
"type_name": "Mahsup Fişi",
},
{
"enum_class": "AccountingReceiptTypes",
"type_code": "ART-O",
"type_name": "Açılış Fişi",
},
{
"enum_class": "AccountingReceiptTypes",
"type_code": "ART-C",
"type_name": "Kapanış Fişi",
},
{"enum_class": "IbanBudgetType", "type_code": "IBT-I", "type_name": "Iban"},
{"enum_class": "IbanBudgetType", "type_code": "IBT-B", "type_name": "Budget"},
{
"enum_class": "IbanBudgetType",
"type_code": "IBT-TR",
"type_name": "Transaction records",
},
{"enum_class": "ProjectTypes", "type_code": "R", "type_name": "Tadilat"},
{
"enum_class": "ProjectTypes",
"type_code": "PT-C",
"type_name": "Mahkeme süreçleri",
},
{
"enum_class": "ProjectTypes",
"type_code": "PT-Z",
"type_name": "Sıfır Bakiye",
},
{
"enum_class": "EdmBudgetType",
"type_code": "PT-B",
"type_name": "Banka records",
},
{
"enum_class": "EdmBudgetType",
"type_code": "PT-S",
"type_name": "Sistem kaydı",
},
{
"enum_class": "EdmBudgetType",
"type_code": "EBT-C",
"type_name": "Build, Flat or Site records",
},
{"enum_class": "ExpireType", "type_code": "1", "type_name": "daily"},
{"enum_class": "ExpireType", "type_code": "7", "type_name": "weekly"},
{"enum_class": "ExpireType", "type_code": "30", "type_name": "monthly"},
{"enum_class": "ExpireType", "type_code": "90", "type_name": "quarter"},
{"enum_class": "ExpireType", "type_code": "180", "type_name": "six_month"},
{"enum_class": "ExpireType", "type_code": "365", "type_name": "yearly"},
{"enum_class": "PhoneType", "type_code": "M", "type_name": "cep tel"},
{"enum_class": "PhoneType", "type_code": "L", "type_name": "sabit telefon"},
{"enum_class": "PhoneType", "type_code": "F", "type_name": "fax"},
{"enum_class": "PhoneType", "type_code": "C", "type_name": "santral"},
{
"enum_class": "PhoneType",
"type_code": "G",
"type_name": "ülke genelindeki hatlar 444",
},
{"enum_class": "PerComType", "type_code": "1", "type_name": "Person"},
{"enum_class": "PerComType", "type_code": "2", "type_name": "Company"},
{"enum_class": "Directions", "type_code": "NN", "type_name": "North"},
{"enum_class": "Directions", "type_code": "EE", "type_name": "East"},
{"enum_class": "Directions", "type_code": "SS", "type_name": "South"},
{"enum_class": "Directions", "type_code": "WW", "type_name": "West"},
{"enum_class": "Directions", "type_code": "NE", "type_name": "North East"},
{"enum_class": "Directions", "type_code": "NW", "type_name": "North West"},
{"enum_class": "Directions", "type_code": "SE", "type_name": "South East"},
{"enum_class": "Directions", "type_code": "SW", "type_name": "South West"},
{
"enum_class": "MeetingTypes",
"type_code": "MT-RBM",
"type_name": "Regular Building Meeting",
},
{
"enum_class": "MeetingTypes",
"type_code": "MT-DBM",
"type_name": "Disaster Building Meeting",
},
{
"enum_class": "MeetingTypes",
"type_code": "MT-EBM",
"type_name": "Emergency Building Meeting",
},
{
"enum_class": "DebitTypes",
"type_code": "DT-D",
"type_name": "Debit Sender",
},
{
"enum_class": "DebitTypes",
"type_code": "DT-R",
"type_name": "Credit Receiver",
},
{
"enum_class": "DebitTypes",
"type_code": "DT-Z",
"type_name": "Zero Balance",
},
{
"enum_class": "TimePeriod",
"type_code": "TP-W",
"type_name": "Weekly",
},
{
"enum_class": "TimePeriod",
"type_code": "TP-M",
"type_name": "Monthly",
},
{
"enum_class": "TimePeriod",
"type_code": "TP-Q",
"type_name": "Quarterly",
},
{
"enum_class": "TimePeriod",
"type_code": "TP-Y",
"type_name": "Yearly",
},
]
for insert_enum in insert_enums:
created_api_enum = ApiEnumDropdown.query.filter_by(
enum_class=insert_enum["enum_class"],
key=str(insert_enum["type_code"]).upper(),
).first()
if not created_api_enum:
created_api_enum = ApiEnumDropdown.create(
enum_class=insert_enum["enum_class"],
value=insert_enum["type_name"],
key=str(insert_enum["type_code"]).upper(),
description=insert_enum["type_name"],
is_confirmed=True,
)
created_api_enum.save()

299
api_services/api_builds/initial_service/init_occ_defaults.py Normal file
View File

@@ -0,0 +1,299 @@
import arrow
from api_modules.token.password_module import PasswordModule
from api_controllers.mongo.database import mongo_handler
from schemas import (
Addresses,
BuildLivingSpace,
Users,
People,
Build,
BuildParts,
BuildTypes,
ApiEnumDropdown,
Companies,
OccupantTypes,
)
def create_occupant_defaults(db_session):
created_list = []
Addresses.set_session(db_session)
BuildLivingSpace.set_session(db_session)
Users.set_session(db_session)
People.set_session(db_session)
Build.set_session(db_session)
BuildParts.set_session(db_session)
BuildTypes.set_session(db_session)
ApiEnumDropdown.set_session(db_session)
Companies.set_session(db_session)
OccupantTypes.set_session(db_session)
company_management = Companies.query.filter_by(formal_name = "Evyos LTD",).first()
if not company_management:
raise Exception("Company not found")
company_id, company_uu_id = company_management.id, str(company_management.uu_id)
active_row = dict(is_confirmed=True, active=True, deleted=False, is_notification_send=True)
build_type = BuildTypes.query.filter_by(type_code = "APT").first()
address = Addresses.query.filter_by(letter_address = "Example Address").first()
created_build = Build.query.filter_by(build_name = "Build Example").first()
if not created_build:
created_build = Build.create(
build_name="Build Example",
build_code="B001",
build_no="B001",
build_date="01.07.1980",
address_id=address.id,
address_uu_id=str(address.uu_id),
build_types_id=build_type.id,
build_types_uu_id=str(build_type.uu_id),
**active_row
)
created_list.append(created_build)
build_type_created = BuildTypes.query.filter_by(type_code = "APT").first()
build_type_flat = BuildTypes.query.filter_by(type_code = "DAIRE").first()
enum_dropdown = ApiEnumDropdown.query.filter_by(key = "NE", enum_class = "Directions").first()
occupant_type_prs = OccupantTypes.query.filter_by(occupant_code = "MT-PRS").first()
occupant_type_owner = OccupantTypes.query.filter_by(occupant_code = "FL-OWN").first()
occupant_type_tenant = OccupantTypes.query.filter_by(occupant_code = "FL-TEN").first()
created_managment_room = BuildParts.query.filter_by(part_code = "MR001").first()
if not created_managment_room:
created_managment_room = BuildParts.create(
address_gov_code="123123123123",
build_id=created_build.id,
build_uu_id=str(created_build.uu_id),
part_code="MR001",
part_net_size=100,
part_no=0,
part_level=0,
part_type_id=build_type_created.id,
part_type_uu_id=str(build_type_created.uu_id),
part_direction_id=enum_dropdown.id,
part_direction_uu_id=str(enum_dropdown.uu_id),
human_livable=True,
due_part_key="Example",
**active_row,
)
created_list.append(created_managment_room)
created_flat = BuildParts.query.filter_by(part_code = "MF001").first()
if not created_flat:
created_flat = BuildParts.create(
address_gov_code="123123123124",
build_id=created_build.id,
build_uu_id=str(created_build.uu_id),
part_code="MF001",
part_net_size=100,
part_no=1,
part_level=1,
part_type_id=build_type_flat.id,
part_type_uu_id=str(build_type_flat.uu_id),
part_direction_id=enum_dropdown.id,
part_direction_uu_id=str(enum_dropdown.uu_id),
human_livable=True,
due_part_key="Example",
**active_row,
)
created_list.append(created_flat)
build_manager_people = People.query.filter_by(person_tag = "Build Manager Example").first()
if not build_manager_people:
build_manager_people = People.create(
**{
"person_tag": "Build Manager Example",
"firstname": "Example Build Manager",
"surname": "Example",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312315",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231234",
}
)
created_list.append(build_manager_people)
owner_people = People.query.filter_by(person_tag = "Owner Example").first()
if not owner_people:
owner_people = People.create(
**{
"person_tag": "Owner Example",
"firstname": "Example Owner",
"surname": "Example",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312316",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231234",
}
)
created_list.append(owner_people)
tenant_people = People.query.filter_by(person_tag = "Tenant Example").first()
if not tenant_people:
tenant_people = People.create(
**{
"person_tag": "Tenant Example",
"firstname": "Example Tenant",
"surname": "Example",
"sex_code": "M",
"middle_name": "",
"father_name": "Father",
"mother_name": "Mother",
"country_code": "TR",
"national_identity_id": "12312312317",
"birth_place": "Ankara",
"birth_date": "01.07.1990",
"tax_no": "1231231234",
}
)
created_list.append(tenant_people)
main_domain, collection_name = "evyos.com.tr", f"{str(company_management.uu_id)}*Domain"
user_build_manager = Users.query.filter_by(user_tag = "Build Manager Example").first()
if not user_build_manager:
user_build_manager = Users.create(
person_id=build_manager_people.id,
person_uu_id=str(build_manager_people.uu_id),
user_tag=build_manager_people.person_tag,
email="example.build.manager@gmail.com",
phone_number="+901111111111",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(user_build_manager)
user_build_manager.password_expiry_begins = str(arrow.now())
user_build_manager.password_token = PasswordModule.generate_refresher_token()
user_owner = Users.query.filter_by(user_tag = "Owner Example").first()
if not user_owner:
user_owner = Users.create(
person_id=owner_people.id,
person_uu_id=str(owner_people.uu_id),
user_tag=owner_people.person_tag,
email="example.owner@gmail.com",
phone_number="+901111111111",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(user_owner)
user_owner.password_expiry_begins = str(arrow.now())
user_owner.password_token = PasswordModule.generate_refresher_token()
user_tenant = Users.query.filter_by(user_tag = "Tenant Example").first()
if not user_tenant:
user_tenant = Users.create(
person_id=tenant_people.id,
person_uu_id=str(tenant_people.uu_id),
user_tag=tenant_people.person_tag,
email="example.tenant@gmail.com",
phone_number="+901111111111",
avatar="https://s.tmimgcdn.com/scr/800x500/276800/building-home-nature-logo-vector-template-3_276851-original.jpg",
related_company=str(company_management.uu_id),
**active_row,
)
created_list.append(user_tenant)
user_tenant.password_expiry_begins = str(arrow.now())
user_tenant.password_token = PasswordModule.generate_refresher_token()
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one({"user_uu_id": str(user_build_manager.uu_id)})
if not existing_record:
mongo_engine.insert_one(
document={"user_uu_id": str(user_build_manager.uu_id), "other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}
)
else:
mongo_engine.update_one(
{"user_uu_id": str(user_build_manager.uu_id)},
{"$set": {"other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}}
)
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one({"user_uu_id": str(user_owner.uu_id)})
if not existing_record:
mongo_engine.insert_one(
document={"user_uu_id": str(user_owner.uu_id), "other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}
)
else:
mongo_engine.update_one(
{"user_uu_id": str(user_owner.uu_id)},
{"$set": {"other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}}
)
with mongo_handler.collection(collection_name) as mongo_engine:
existing_record = mongo_engine.find_one({"user_uu_id": str(user_tenant.uu_id)})
if not existing_record:
mongo_engine.insert_one(
document={"user_uu_id": str(user_tenant.uu_id), "other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}
)
else:
mongo_engine.update_one(
{"user_uu_id": str(user_tenant.uu_id)},
{"$set": {"other_domains_list": [main_domain], "main_domain": main_domain, "modified_at": arrow.now().timestamp()}})
created_build_living_space_prs = BuildLivingSpace.query.filter_by(
build_id=created_build.id, build_parts_id=created_managment_room.id, person_id=build_manager_people.id
).first()
if not created_build_living_space_prs:
created_build_living_space_prs = BuildLivingSpace.create(
build_id=created_build.id,
build_uu_id=str(created_build.uu_id),
build_parts_id=created_managment_room.id,
build_parts_uu_id=str(created_managment_room.uu_id),
person_id=build_manager_people.id,
person_uu_id=str(build_manager_people.uu_id),
occupant_type_id=occupant_type_prs.id,
occupant_type_uu_id=str(occupant_type_prs.uu_id),
**active_row,
)
created_list.append(created_build_living_space_prs)
created_build_living_space_owner = BuildLivingSpace.query.filter_by(
build_id=created_build.id, build_parts_id=created_flat.id, person_id=owner_people.id
).first()
if not created_build_living_space_owner:
created_build_living_space_owner = BuildLivingSpace.create(
build_id=created_build.id,
build_uu_id=str(created_build.uu_id),
build_parts_id=created_flat.id,
build_parts_uu_id=str(created_flat.uu_id),
person_id=owner_people.id,
person_uu_id=str(owner_people.uu_id),
occupant_type_id=occupant_type_owner.id,
occupant_type_uu_id=str(occupant_type_owner.uu_id),
**active_row,
)
created_list.append(created_build_living_space_owner)
created_build_living_space_tenant = BuildLivingSpace.query.filter_by(
build_id=created_build.id, build_parts_id=created_flat.id, person_id=tenant_people.id
).first()
if not created_build_living_space_tenant:
created_build_living_space_tenant = BuildLivingSpace.create(
build_id=created_build.id,
build_uu_id=str(created_build.uu_id),
build_parts_id=created_flat.id,
build_parts_uu_id=str(created_flat.uu_id),
person_id=tenant_people.id,
person_uu_id=str(tenant_people.uu_id),
occupant_type_id=occupant_type_tenant.id,
occupant_type_uu_id=str(occupant_type_tenant.uu_id),
**active_row,
)
created_list.append(created_build_living_space_tenant)
db_session.commit()
print("Occupant Defaults Create is now completed")

225
api_services/api_builds/initial_service/init_occupant_types.py Normal file
View File

@@ -0,0 +1,225 @@
from schemas import OccupantTypes
def create_occupant_types_defaults(db_session):
"""
occupant_category = mapped_column(String, server_default="")
occupant_category_type = mapped_column(String, server_default="")
occupant_is_unique = mapped_column(Boolean, server_default="0")
"""
OccupantTypes.set_session(db_session)
list_occupant_types = [
{
"occupant_type": "Toplantı Başkanı",
"occupant_description": "Toplantı Başkanı",
"occupant_code": "MT-PRS",
"occupant_category": "Toplantı",
"occupant_category_type": "MT",
"occupant_is_unique": True,
},
{
"occupant_type": "Toplantı Katip",
"occupant_description": "Toplantıda tutanak tutan kişi",
"occupant_code": "MT-WRT",
"occupant_category": "Toplantı",
"occupant_category_type": "MT",
"occupant_is_unique": True,
},
{
"occupant_type": "Toplantı Katılımcısı",
"occupant_description": "Toplantıda sadece katılan kişi",
"occupant_code": "MT-ATT",
"occupant_category": "Toplantı",
"occupant_category_type": "MT",
"occupant_is_unique": False,
},
{
"occupant_type": "Toplantı Danışman",
"occupant_description": "Toplantıda danışmanlık yapan kişi",
"occupant_code": "MT-ADV",
"occupant_category": "Toplantı",
"occupant_category_type": "MT",
"occupant_is_unique": False,
},
{
"occupant_type": "Toplantı Seçilmiş Başkanı",
"occupant_description": "Toplantı Seçilmiş Başkanı",
"occupant_code": "MT-VPR",
"occupant_category": "Toplantı",
"occupant_category_type": "MT",
"occupant_is_unique": True,
},
{
"occupant_type": "Daire Sahibi",
"occupant_description": "Daire Sahibi",
"occupant_code": "FL-OWN",
"occupant_category": "Daire",
"occupant_category_type": "FL",
"occupant_is_unique": True,
},
{
"occupant_type": "Daire Kiracısı",
"occupant_description": "Daire Kiracısı",
"occupant_code": "FL-TEN",
"occupant_category": "Daire",
"occupant_category_type": "FL",
"occupant_is_unique": True,
},
{
"occupant_type": "Daire Sakini",
"occupant_description": "Daire Sakini",
"occupant_code": "FL-RES",
"occupant_category": "Daire",
"occupant_category_type": "FL",
"occupant_is_unique": False,
},
{
"occupant_type": "Daire Sakini Vekili",
"occupant_description": "Daire Sakini Vekili",
"occupant_code": "FL-REP",
"occupant_category": "Daire",
"occupant_category_type": "FL",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Avukatı",
"occupant_description": "Bina Avukatı",
"occupant_code": "BU-ATT",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Avukatı Yardımcısı",
"occupant_description": "Bina Avukatı Yardımcısı",
"occupant_code": "BU-ATA",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Denetmen Yardımcısı",
"occupant_description": "Bina Denetmen Yardımcısı",
"occupant_code": "BU-SPA",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Denetmeni",
"occupant_description": "Bina Denetmeni",
"occupant_code": "BU-SPV",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Yönetici Yardımcısı",
"occupant_description": "Bina Yönetici Yardımcısı",
"occupant_code": "BU-MNA",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Yöneticisi",
"occupant_description": "Bina Yöneticisi",
"occupant_code": "BU-MNG",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": True,
},
{
"occupant_type": "Bina Muhasabecisi",
"occupant_description": "Bina Muhasabecisi",
"occupant_code": "BU-ACC",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Proje Lideri",
"occupant_description": "Proje Lideri",
"occupant_code": "PRJ-LDR",
"occupant_category": "Proje",
"occupant_category_type": "PRJ",
"occupant_is_unique": False,
},
{
"occupant_type": "Proje Sorumlusu",
"occupant_description": "Proje Sorumlusu",
"occupant_code": "PRJ-RES",
"occupant_category": "Proje",
"occupant_category_type": "PRJ",
"occupant_is_unique": False,
},
{
"occupant_type": "Proje Ekibi",
"occupant_description": "Proje Ekibi",
"occupant_code": "PRJ-EMP",
"occupant_category": "Proje",
"occupant_category_type": "PRJ",
"occupant_is_unique": False,
},
{
"occupant_type": "Proje Finans Sorumlusu",
"occupant_description": "Proje Finans Sorumlusu",
"occupant_code": "PRJ-FIN",
"occupant_category": "Proje",
"occupant_category_type": "PRJ",
"occupant_is_unique": False,
},
{
"occupant_type": "Proje Teknik Sorumlusu",
"occupant_description": "Proje Teknik Sorumlusu",
"occupant_code": "PRJ-TEC",
"occupant_category": "Proje",
"occupant_category_type": "PRJ",
"occupant_is_unique": False,
},
{
"occupant_type": "Daire Mülkiyet Vekili",
"occupant_description": "Daire Mülkiyet Vekili",
"occupant_code": "FL-DEP", # deputy
"occupant_category": "Daire",
"occupant_category_type": "FL",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Teknik Sorumlusu",
"occupant_description": "Bina Teknik Sorumlusu",
"occupant_code": "BU-TEC",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Teknik Elemanı",
"occupant_description": "Bina Teknik Elemanı",
"occupant_code": "BU-EMP",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
{
"occupant_type": "Bina Teknik Freelancer",
"occupant_description": "Bina Teknik Freelancer",
"occupant_code": "BU-FLC",
"occupant_category": "Bina",
"occupant_category_type": "BU",
"occupant_is_unique": False,
},
]
for list_occupant_type in list_occupant_types:
try:
created_type = OccupantTypes.query.filter_by(
occupant_code=list_occupant_type["occupant_code"],
occupant_category=list_occupant_type["occupant_category_type"],
).first()
if not created_type:
created_type = OccupantTypes.create(**list_occupant_type, is_confirmed=True)
created_type.save()
except Exception as e:
print(f"Error: {e}")

78
api_services/api_builds/initial_service/init_services.py Normal file
View File

@@ -0,0 +1,78 @@
from schemas import (
Duty,
OccupantTypes,
Modules,
Services,
)
def create_modules_and_services_and_actions(db_session):
Duty.set_session(db_session)
Services.set_session(db_session)
Modules.set_session(db_session)
OccupantTypes.set_session(db_session)
erp_module = Modules.query.filter_by(module_code = "EVYOS-ERP").first()
if not erp_module:
erp_module = Modules.create(
**{
"module_name": "EVYOS ERP", "module_description": "EVYOS Enterprise Resource Planning", "module_code": "EVYOS-ERP",
"module_layer": 1, "is_default_module": False, "is_confirmed": True,
}
)
erp_module.save()
build_module = Modules.query.filter_by(module_code = "BLD-MNG").first()
if not build_module:
build_module = Modules.create(
**{
"module_name": "Bina Yönetim Modülü", "module_description": "Building Management Module", "module_code": "BLD-MNG",
"module_layer": 1, "is_default_module": False, "is_confirmed": True,
}
)
build_module.save()
user_module = Modules.query.filter_by(module_code = "USR-PUB").first()
if not user_module:
user_module = Modules.create(
**{
"module_name": "Kullancı Modülü", "module_description": "Kullanıcı Genel Modülü", "module_code": "USR-PUB", "module_layer": 1,
"is_default_module": True, "is_confirmed": True
}
)
user_module.save()
erp_module_module_dict = dict(module_id=erp_module.id, module_uu_id=str(erp_module.uu_id))
build_module_module_dict = dict(module_id=build_module.id, module_uu_id=str(build_module.uu_id))
duty_objects = Duty.query.filter(Duty.module_id == erp_module.id).all()
if not duty_objects:
raise Exception("Duty objects not found")
for duty_object in duty_objects:
created_service = Services.query.filter(Services.service_code == f"SRE-{duty_object.duty_code}").first()
if not created_service:
created_service = Services.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}",
related_responsibility=duty_object.duty_code,
is_confirmed=True,
)
created_service.save()
occupant_types = OccupantTypes.query.filter(OccupantTypes.module_id == build_module.id).all()
if not occupant_types:
raise Exception("Occupant types not found")
for occupant_type in occupant_types:
created_service = Services.query.filter(Services.service_code == f"SRO-{occupant_type.occupant_code}").first()
if not created_service:
created_service = Services.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}",
related_responsibility=occupant_type.occupant_code,
is_confirmed=True,
)
created_service.save()