ositah 24.4.dev1__py3-none-any.whl → 24.7.dev1__py3-none-any.whl

ositah/utils/hito_db.py

@@ -1,51 +0,0 @@
-"""
-Module defining a few helper functions to access the DB through SQLAlchemy
-"""
-
-import re
-from uuid import uuid4
-
-from flask import g
-from sqlalchemy import event
-from sqlalchemy.engine import Engine
-from sqlalchemy.orm import scoped_session, sessionmaker
-
-from ositah.app import app
-from ositah.utils.utils import GlobalParams
-
-
-def new_uuid():
-    """
-    Wrapper over uuid4() to return the UUID as a string. Allow using a callable in the column
-    default attribute (else it is interpreted as constant and the UUID is the same for every row).
-
-    :return: UUID string
-    """
-    return str(uuid4())
-
-
-@event.listens_for(Engine, "connect")
-def set_sqlite_pragma(dbapi_connection, connection_record):
-    if re.match("sqlite:", app.server.config["SQLALCHEMY_DATABASE_URI"]):
-        cursor = dbapi_connection.cursor()
-        cursor.execute("PRAGMA foreign_keys=ON")
-        cursor.close()
-
-
-def get_db(init_session: bool = True) -> None:
-    """
-    Return the DB handler if already initialized, else create it and initialize a DB session
-    in the application context.
-
-    :param init_session: if True initialize a session if necessary
-    :return: DB handler
-    """
-    global_params = GlobalParams()
-
-    with app.server.app_context():
-        if "db" not in g:
-            g.db = global_params.hito_db
-        if init_session and not g.db.session.bind:
-            g.db.session = scoped_session(sessionmaker(g.db.engine))
-
-        return g.db

ositah/utils/hito_db_model.py

@@ -1,245 +0,0 @@
-"""
-Module defining the DB SQLAlchemy model.
-This is done by using the class provided by Flask-sqlalchemy that requires the DB connection
-to be initialized before. Thus this module must not be imported before it is done.
-"""
-
-from hito_tools.utils import sql_longtext_to_list
-
-from ositah.utils.hito_db import new_uuid
-from ositah.utils.utils import GlobalParams
-
-global_params = GlobalParams()
-db = global_params.hito_db
-
-team_mgrs = db.Table(
-    "team_agent",
-    db.Column("team_id", db.String, db.ForeignKey("team.id")),
-    db.Column("agent_id", db.String, db.ForeignKey("agent.id")),
-)
-
-children_team_mgrs = db.Table(
-    "agent_team_parent_responsable",
-    db.Column("team_id", db.String, db.ForeignKey("team.id")),
-    db.Column("agent_id", db.String, db.ForeignKey("agent.id")),
-)
-
-activity_teams = db.Table(
-    "activite_team",
-    db.Column("activite_id", db.String, db.ForeignKey("activite.id")),
-    db.Column("team_id", db.String, db.ForeignKey("team.id")),
-)
-
-project_teams = db.Table(
-    "projet_team",
-    db.Column("projet_id", db.String, db.ForeignKey("projet.id")),
-    db.Column("team_id", db.String, db.ForeignKey("team.id")),
-)
-
-
-class Agent(db.Model):
-    id = db.Column(db.String, primary_key=True)
-    nom = db.Column(db.String)
-    prenom = db.Column(db.String)
-    email = db.Column(db.String)
-    email_auth = db.Column(db.String)
-    roles = db.Column(db.Text)
-    statut = db.Column(db.String)
-    team_id = db.Column(db.String)
-
-    # Teams an agent is directly managing
-    teams = db.relationship("Team", secondary=team_mgrs, backref=db.backref("managers"))
-
-    # Children teams of the teams an agent is managing
-    children_teams = db.relationship(
-        "Team", secondary=children_team_mgrs, backref=db.backref("children_managers")
-    )
-
-    def __repr__(self):
-        if self.email_auth is None or len(self.email_auth) == 0:
-            connexion_email = self.email
-        else:
-            connexion_email = self.email_auth
-        return (
-            f"<Agent(nom={self.nom}, email={self.email}, roles={sql_longtext_to_list(self.roles)}"
-            f" (email connexion={connexion_email}))>"
-        )
-
-
-class Carriere(db.Model):
-    id = db.Column(db.String, primary_key=True)
-    date_debut = db.Column(db.DateTime)
-    date_fin = db.Column(db.DateTime)
-    type = db.Column(db.String)
-    agent_id = db.Column(db.String(36), db.ForeignKey("agent.id"), nullable=False)
-
-    def __repr__(self):
-        date = ""
-        if self.date_debut:
-            date += f" date_debut={self.date_debut}"
-        if self.date_fin:
-            date += f" date_debut={self.date_fin}"
-        return f"<Carriere(id={self.id}, type={self.type}{date})>"
-
-
-class Team(db.Model):
-    id = db.Column(db.String, primary_key=True)
-    nom = db.Column(db.String)
-    description = db.Column(db.String)
-    parent_team_id = db.Column(db.String)
-
-    def __repr__(self):
-        if not self.description or len(self.description) == 0:
-            description = self.nom
-        else:
-            description = self.description
-        return f"<Team(nom={self.nom}, description={description})>"
-
-
-class Referentiel(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    libelle = db.Column(db.String)
-    ordre = db.Column(db.Integer)
-    object_class = db.Column("class", db.String)
-
-    def __repr__(self):
-        return f"Referentiel<id={self.id}, libelle={self.libelle}, class={self.object_class}>"
-
-
-class Activite(db.Model):
-    id = db.Column(db.String, primary_key=True, default=new_uuid)
-    libelle = db.Column(db.String)
-    description = db.Column(db.String)
-    ordre = db.Column(db.Integer)
-
-    activite_nsip_referentiel_id = db.Column(db.String, db.ForeignKey("referentiel.id"))
-    projet_nsip_referentiel_id = db.Column(db.String, db.ForeignKey("referentiel.id"))
-
-    referentiel_nsip_project = db.relationship(
-        "Referentiel",
-        backref=db.backref("activite_project", lazy=True),
-        foreign_keys=[projet_nsip_referentiel_id],
-    )
-    referentiel_nsip_activity = db.relationship(
-        "Referentiel",
-        backref=db.backref("activite_activity", lazy=True),
-        foreign_keys=[activite_nsip_referentiel_id],
-    )
-
-    # Teams associated with an activity
-    teams = db.relationship(
-        "Team",
-        secondary=activity_teams,
-        lazy="subquery",
-        backref=db.backref("activity_teams", lazy=True),
-    )
-
-    def __repr__(self):
-        return f"<Activite(libelle={self.libelle}, id={id})>"
-
-
-class Projet(db.Model):
-    id = db.Column(db.String, primary_key=True, default=new_uuid)
-    libelle = db.Column(db.String)
-    description = db.Column(db.String)
-    ordre = db.Column(db.Integer)
-
-    activite_nsip_referentiel_id = db.Column(db.String, db.ForeignKey("referentiel.id"))
-    projet_nsip_referentiel_id = db.Column(db.String, db.ForeignKey("referentiel.id"))
-
-    referentiel_nsip_project = db.relationship(
-        "Referentiel",
-        backref=db.backref("projet_project", lazy=True),
-        foreign_keys=[projet_nsip_referentiel_id],
-    )
-    referentiel_nsip_activity = db.relationship(
-        "Referentiel",
-        backref=db.backref("projet_activity", lazy=True),
-        foreign_keys=[activite_nsip_referentiel_id],
-    )
-
-    # Teams associated with a project
-    teams = db.relationship(
-        "Team",
-        secondary=project_teams,
-        lazy="subquery",
-        backref=db.backref("project_teams", lazy=True),
-    )
-
-    def __repr__(self):
-        return f"<Projet(libelle={self.libelle}, id={id})>"
-
-
-class ActiviteDetail(db.Model):
-    id = db.Column(db.Integer, primary_key=True)
-    activite_id = db.Column(db.String, db.ForeignKey("activite.id"))
-    projet_id = db.Column(db.String, db.ForeignKey("projet.id"))
-    agent_id = db.Column(db.String, db.ForeignKey("agent.id"))
-    team_id = db.Column(db.String, db.ForeignKey("team.id"))
-    type = db.Column(db.Integer)
-    date = db.Column(db.DateTime)
-    pourcent = db.Column(db.Float)
-    nbHeures = db.Column(db.Float)
-
-    project = db.relationship("Projet", backref=db.backref("activity_detail", lazy=True))
-    agent = db.relationship(
-        "Agent",
-        backref=db.backref("activity_detail", lazy=True),
-        foreign_keys=[agent_id],
-    )
-    team = db.relationship(
-        "Team", backref=db.backref("activity_detail", lazy=True), foreign_keys=[team_id]
-    )
-
-    def __repr__(self):
-        return (
-            f"<ActiviteDetail(id={self.id}, date={self.date}, pourcent={self.pourcent},"
-            f" nbHeures={self.nbHeures})>"
-        )
-
-
-class OSITAHSession(db.Model):
-    id = db.Column(db.String(36), primary_key=True)
-    email = db.Column(db.String(255), nullable=False)
-    last_use = db.Column(db.DateTime, nullable=False)
-
-
-class OSITAHValidation(db.Model):
-    id = db.Column(db.String(36), primary_key=True, default=new_uuid)
-    validated = db.Column(db.Boolean, nullable=False)
-    timestamp = db.Column(db.DateTime, nullable=False)
-    initial_timestamp = db.Column(db.DateTime, nullable=True)
-    agent_id = db.Column(db.String(36), db.ForeignKey("agent.id"), nullable=False)
-    period_id = db.Column(
-        db.String(36), db.ForeignKey("ositah_validation_period.id"), nullable=False
-    )
-
-    agent = db.relationship("Agent", backref=db.backref("validation", lazy=True))
-    period = db.relationship(
-        "OSITAHValidationPeriod", backref=db.backref("validation_data", lazy=True)
-    )
-
-
-class OSITAHValidationPeriod(db.Model):
-    id = db.Column(db.String(36), primary_key=True, default=new_uuid)
-    name = db.Column(db.String(255), unique=True, nullable=False)
-    start_date = db.Column(db.DateTime, nullable=False)
-    end_date = db.Column(db.DateTime, nullable=False)
-    validation_date = db.Column(db.DateTime, nullable=False)
-
-
-class OSITAHProjectDeclaration(db.Model):
-    id = db.Column(db.String(36), primary_key=True, default=new_uuid)
-    projet = db.Column(db.String(255), nullable=False)
-    masterprojet = db.Column(db.String(255), nullable=False)
-    category = db.Column(db.String(255), nullable=False)
-    hours = db.Column(db.Float, nullable=False)
-    # quotite is the fraction of FTE declared by the agent (1=full time)
-    quotite = db.Column(db.Float, nullable=False)
-    validation_id = db.Column(db.String(36), db.ForeignKey("ositah_validation.id"), nullable=False)
-    # Allow foreign key to Hito projet table to be null so that a Hito project can be delete
-    # without deleting the declaration
-    hito_project_id = db.Column(db.String(36), db.ForeignKey("projet.id"), nullable=True)
-
-    validation = db.relationship("OSITAHValidation", backref=db.backref("project", lazy=True))
-    project = db.relationship("Projet", backref=db.backref("validation_project", lazy=True))

ositah/utils/menus.py

@@ -1,339 +0,0 @@
-# Module containing helper functions to build/manage the menus and graphic objects
-
-from datetime import datetime
-
-import dash_bootstrap_components as dbc
-from dash import dcc, html
-from dash.dependencies import MATCH, Input, Output, State
-
-from ositah.app import app
-from ositah.utils.cache import clear_cached_data
-from ositah.utils.exceptions import SessionDataMissing
-from ositah.utils.period import get_declaration_periods, get_default_period_date
-from ositah.utils.utils import GlobalParams, no_session_id_jumbotron
-
-DATA_SELECTED_SOURCE_ID = "project-declaration-source"
-DATA_SELECTION_SOURCE_ID = "project-declaration-source-button"
-
-TEAM_SELECTED_VALUE_ID = "team-selected"
-TEAM_SELECTION_MENU_ID = "team-selection-dropdown"
-TEAM_SELECTION_DATE_ID = "team-selection-date"
-
-VALIDATION_PERIOD_MENU_ID = "validation-period-dropdown"
-VALIDATION_PERIOD_SELECTED_ID = "validation-period-selected"
-
-# 'type' part of composite IDs
-TABLE_TYPE_TABLE = "ositah-table"
-TABLE_TYPE_DUMMY_STORE = "ositah-table-dummy-store"
-
-LOAD_PROGRESS_BAR_ID = "validation-progress-bar"
-LOAD_PROGRESS_BAR_INTERVAL_DURATION = 500  # Milliseconds
-LOAD_PROGRESS_BAR_MAX_DURATION = 15  # Seconds
-
-NEW_PAGE_INDICATOR_ID = "page-initial-load"
-
-
-def team_list_dropdown(menu_id=TEAM_SELECTION_MENU_ID):
-    """
-    Build a dropdown menu from the teams associated with the current user session.
-
-    :param menu_id: menu ID for the created dropdown menu
-    :return: dcc.Dropdown object or a jumbotron in case of errors
-    """
-
-    global_params = GlobalParams()
-    try:
-        session_data = global_params.session_data
-        if session_data.agent_teams and len(session_data.agent_teams) > 1:
-            default_team = ""
-        else:
-            default_team = session_data.agent_teams[0]
-
-    except SessionDataMissing:
-        return no_session_id_jumbotron()
-
-    periods = session_data.declaration_periods
-    if periods is None:
-        periods = get_declaration_periods()
-        session_data.declaration_periods = periods
-    default_period = get_default_period_date(
-        periods, global_params.declaration_options["default_date"]
-    )
-
-    return dbc.Row(
-        [
-            dbc.Col(
-                [
-                    dbc.Label(html.B("Equipe")),
-                    dcc.Dropdown(
-                        id=menu_id,
-                        options=[
-                            {"label": team, "value": team} for team in session_data.agent_teams
-                        ],
-                        loading_state={"is_loading": True},
-                        value=default_team,
-                        placeholder="Sélectionner une équipe",
-                    ),
-                ],
-                width=6,
-                class_name="team_list_dropdown",
-            ),
-            dbc.Col(
-                [
-                    dbc.Label(html.B("Période")),
-                    dcc.Dropdown(
-                        id=VALIDATION_PERIOD_MENU_ID,
-                        options=[
-                            {
-                                "label": period.label,
-                                "value": period.start_date,
-                            }
-                            for period in periods
-                        ],
-                        value=default_period,
-                        placeholder="Sélectionner une période",
-                    ),
-                ],
-                width={"size": 4, "offset": 1},
-                class_name="team_list_dropdown",
-            ),
-        ]
-    )
-
-
-def build_accordion(button_number, button_content, hidden_text, tooltip=None, class_list=""):
-    """
-    Function to build an accordion associated with the component passed in button_contents.
-
-    :param button_number: the button number, must be unique for each button
-    :param button_content: what will be put inside the button
-    :param hidden_text: text to be displayed when the accordion is open
-    :param tooltip: text to be displayed as an optional tooltip
-    :param class_list: optional class list to add to the dbc.Card
-    :return: the accordion element
-
-    """
-
-    return html.Div(
-        [
-            dbc.Accordion(
-                dbc.AccordionItem(
-                    hidden_text,
-                    title=button_content,
-                    class_name=class_list,
-                ),
-                id={"type": "accordion_toggle", "id": button_number},
-                start_collapsed=True,
-            ),
-            dbc.Tooltip(
-                tooltip,
-                target={"type": "accordion_toggle", "id": button_number},
-                placement="left",
-                key=f"acccordion_tooltip_{button_number}",
-            ),
-        ]
-    )
-
-
-def create_progress_bar(
-    team: str = None,
-    duration: int = LOAD_PROGRESS_BAR_MAX_DURATION,
-    interval: float = LOAD_PROGRESS_BAR_INTERVAL_DURATION,
-):
-    """
-    Create a Div with a progress bar
-
-    :param team: currently selected team
-    :param duration: progress bar duration (seconds)
-    :param interval: interval duration (millisecondes
-    :return: Div
-    """
-
-    max_intervals = int(duration * 1000 / interval)
-
-    return html.Div(
-        [
-            (
-                html.Div(f"Chargement des données de l'équipe {team} en cours...")
-                if team
-                else html.Div()
-            ),
-            dcc.Interval(
-                id="progress-interval",
-                max_intervals=max_intervals,
-                n_intervals=0,
-                interval=LOAD_PROGRESS_BAR_INTERVAL_DURATION,
-            ),
-            dbc.Progress(id="progress", striped=True),
-            dcc.Store(id="progress-bar-max-intervals", data=max_intervals),
-        ],
-        id=LOAD_PROGRESS_BAR_ID,
-    )
-
-
-@app.callback(
-    [Output("progress", "value"), Output("progress", "label")],
-    Input("progress-interval", "n_intervals"),
-    State("progress-bar-max-intervals", "data"),
-    prevent_initial_call=True,
-)
-def update_progress_bar(n, max_intervals):
-    """
-    Update the progress bar.
-
-    :param n: number of intervals since the beginning
-    :param max_intervals: maximum number of intervals (duration)
-    :return:
-    """
-
-    progress = int(round(n * 100 / max_intervals))
-    # only add text after 5% progress to ensure text isn't squashed too much
-    return progress, f"{progress} %" if progress >= 5 else ""
-
-
-@app.callback(
-    Output({"type": "accordion_collapse", "id": MATCH}, "is_open"),
-    Input({"type": "accordion_toggle", "id": MATCH}, "n_clicks"),
-    State({"type": "accordion_collapse", "id": MATCH}, "is_open"),
-    prevent_initial_call=True,
-)
-def toggle_agent_accordion(n_clicks, is_open) -> bool:
-    """
-    Callback function for the agent accordion.
-
-    :param value: number of times the link was clicked
-    :param is_open: whether the accordion is open or closed
-    :return: List of n Output
-    """
-
-    if n_clicks:
-        return not is_open
-
-
-@app.callback(
-    Output(TEAM_SELECTION_MENU_ID, "value"),
-    Output(TEAM_SELECTED_VALUE_ID, "data"),
-    Output(TEAM_SELECTION_DATE_ID, "data"),
-    Output(VALIDATION_PERIOD_MENU_ID, "value"),
-    Output(VALIDATION_PERIOD_SELECTED_ID, "data"),
-    Output(TEAM_SELECTION_MENU_ID, "loading_state"),
-    Input(TEAM_SELECTION_MENU_ID, "value"),
-    Input(VALIDATION_PERIOD_MENU_ID, "value"),
-    State(TEAM_SELECTED_VALUE_ID, "data"),
-    State(DATA_SELECTED_SOURCE_ID, "children"),
-    State(TEAM_SELECTION_DATE_ID, "data"),
-    State(VALIDATION_PERIOD_SELECTED_ID, "data"),
-    State(TEAM_SELECTION_MENU_ID, "loading_state"),
-)
-def save_team_and_period(
-    selected_team,
-    selected_period,
-    previous_team,
-    selected_source,
-    team_selection_date,
-    previous_period,
-    loading_state,
-):
-    """
-    Function to save the selected team and period in a dcc.Store. This will trigger other callbacks.
-    Also clear the data cache. The value of the team selection dropdown is written back: it
-    allows to update the initial value if one was saved into the dcc.Store.
-
-    :param selected_team: team dropdown menu value
-    :param selected_period: period dropdoan menu value
-    :param previous_team: previously selected team
-    :param selected_source: currently selected data source
-    :param team_selection_date: date of the last team selection
-    :param previous_period: previously selected period
-    :param loading_state: loading state of the team selection menu
-    :return: expected Output values
-    """
-
-    # Handle the initial display of the selection menu: if it was already displayed in another
-    # page and a value was previously selected (saved in TEAM_SELECTED_VALUE_ID), use it as the
-    # initial value (set it to this value through the callback). Do the same for the validation
-    # period
-
-    global_params = GlobalParams()
-    try:
-        session_data = global_params.session_data
-    except SessionDataMissing:
-        return no_session_id_jumbotron(), "", ""
-
-    if "is_loading" in loading_state and loading_state["is_loading"]:
-        team = previous_team
-        # If previous_period is empty, means that it should be initialised with the pulldown
-        # menu default value (in selected_period the first time the callback is executed)
-        if previous_period == "":
-            period = selected_period
-        else:
-            period = previous_period
-    else:
-        team = selected_team
-        period = selected_period
-
-    # Cache must be changed if the team has been changed or if the selected source doesn't match
-    # the cached one
-    if (
-        team != previous_team
-        or period != previous_period
-        or session_data.project_declarations_source is None
-        or selected_source != session_data.project_declarations_source
-    ):
-        clear_cached_data()
-        selection_date = f"{datetime.now()}"
-    else:
-        selection_date = team_selection_date
-
-    return team, team, selection_date, period, period, {"is_laoding": False}
-
-
-# Client-side callback used to mark a table as sortable. To be marked sortable, a table must have
-# an ID matching the ID type attribute TABLE_TYPE_TABLE and create a dcc.Store associated with
-# an ID type attribute TABLE_TYPE_DUMMY_STORE
-app.clientside_callback(
-    """
-    function make_table_sortable(dummy, table_id) {
-        if (!(typeof table_id === 'string' || table_id instanceof String)) {
-            table_id = JSON.stringify(table_id, Object.keys(table_id).sort());
-        };
-        /*alert('Mark sortable table with ID='+table_id);*/
-        const tableObject = document.getElementById(table_id);
-        sorttable.makeSortable(tableObject);
-        return 0;
-    }
-    """,
-    Output({"type": TABLE_TYPE_DUMMY_STORE, "id": MATCH}, "data"),
-    Input({"type": TABLE_TYPE_TABLE, "id": MATCH}, "children"),
-    State({"type": TABLE_TYPE_TABLE, "id": MATCH}, "id"),
-    prevent_initial_call=True,
-)
-
-
-# Emulate former Jumbotron
-def ositah_jumbotron(title: str, main_text: str, details: str = None, title_class: str = None):
-    """
-    Emulate Jumbotron component available in Bootstrap v4
-
-    :param title: Jumbotron title
-    :param main_text: main text
-    :param details: optional additional text
-    :return: html.div()
-    """
-
-    return html.Div(
-        dbc.Container(
-            [
-                html.H1(title, className=f"display-3 {title_class if ( title_class ) else ''}"),
-                html.P(
-                    main_text,
-                    className="lead",
-                ),
-                html.Hr(className="my-2"),
-                html.P(details),
-            ],
-            fluid=True,
-            className="py-3",
-        ),
-        className="p-3 bg-light rounded-3",
-    )