Python can_write_epci Beispiele

Beispiel #1

async def write_epci(
    epci: EpciIn_Pydantic,
    utilisateur: AdemeUtilisateur = Depends(get_user_from_header),
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header),
):
    """
    For an existing Epci corresponding `utilisateur droits` are needed.
    Otherwise `utilisateur droits` are created for the token bearer.
    """
    query = Epci.filter(uid=epci.uid)

    if await query.exists():
        if not can_write_epci(epci.uid, droits):
            raise HTTPException(status_code=401,
                                detail=f"droits not found for epci {epci.uid}")
        await query.update(latest=False)

    else:
        await UtilisateurDroits.create(
            epci_id=epci.uid,
            ademe_user_id=utilisateur.ademe_user_id,
            ecriture=True,
            latest=True,
        )

    epci_obj = await Epci.create(
        **epci.dict(exclude_unset=True),
        latest=True,
    )
    return await Epci_Pydantic.from_tortoise_orm(epci_obj)

Beispiel #2

Datei: indicateur_personnalise.py Projekt: betagouv/territoires-en-transitions

async def post_epci_indicateur_value(
    epci_id: str,
    indicateur_personnalise: IndicateurPersonnaliseIn_Pydantic,
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header),
):
    if epci_id != indicateur_personnalise.epci_id:
        raise HTTPException(status_code=400, detail="epci_id mismatch")

    if not can_write_epci(epci_id, droits):
        raise HTTPException(status_code=401,
                            detail=f"droits not found for epci {epci_id}")

    query = IndicateurPersonnalise.filter(
        epci_id=epci_id,
        uid=indicateur_personnalise.uid,
    )

    if await query.exists():
        await query.update(latest=False)

    indicateur_personnalise_obj = await IndicateurPersonnalise.create(
        **indicateur_personnalise.dict(exclude_unset=True),
        latest=True,
        deleted=False,
    )
    return await IndicateurPersonnalise_Pydantic.from_tortoise_orm(
        indicateur_personnalise_obj)

Beispiel #3

Datei: action_meta.py Projekt: betagouv/territoires-en-transitions

async def write_epci_action_meta(
    epci_id: str,
    action_meta: ActionMetaIn_Pydantic,
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header
    ),
):
    if epci_id != action_meta.epci_id:
        raise HTTPException(status_code=400, detail="epci_id mismatch")

    if not can_write_epci(epci_id, droits):
        raise HTTPException(
            status_code=401, detail=f"droits not found for epci {epci_id}"
        )

    query = ActionMeta.filter(epci_id=epci_id, action_id=action_meta.action_id)

    if await query.exists():
        await query.update(latest=False)

    action_meta_obj = await ActionMeta.create(
        **action_meta.dict(exclude_unset=True),
        latest=True,
    )
    return await ActionMeta_Pydantic.from_tortoise_orm(action_meta_obj)

Beispiel #4

Datei: indicateur_referentiel_commentaire.py Projekt: betagouv/territoires-en-transitions

async def write_epci_indicateur_referentiel_commentaire(
    epci_id: str,
    indicateur_referentiel_commentaire: IndicateurReferentielCommentaireIn_Pydantic,
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header
    ),
):
    if epci_id != indicateur_referentiel_commentaire.epci_id:
        raise HTTPException(status_code=400, detail="epci_id mismatch")

    if not can_write_epci(epci_id, droits):
        raise HTTPException(
            status_code=401, detail=f"droits not found for epci {epci_id}"
        )

    query = IndicateurReferentielCommentaire.filter(
        epci_id=epci_id, indicateur_id=indicateur_referentiel_commentaire.indicateur_id
    )

    if await query.exists():
        await query.update(latest=False)

    indicateur_referentiel_commentaire_obj = (
        await IndicateurReferentielCommentaire.create(
            **indicateur_referentiel_commentaire.dict(exclude_unset=True),
            latest=True,
        )
    )
    return await IndicateurReferentielCommentaire_Pydantic.from_tortoise_orm(
        indicateur_referentiel_commentaire_obj
    )

Beispiel #5

Datei: fiche_action_categorie.py Projekt: betagouv/territoires-en-transitions

async def write_epci_fiche_action_categorie(
    epci_id: str,
    fiche_action_categorie: FicheActionCategorieIn_Pydantic,
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header),
):
    if epci_id != fiche_action_categorie.epci_id:
        raise HTTPException(status_code=400, detail="epci_id mismatch")

    if not can_write_epci(epci_id, droits):
        raise HTTPException(status_code=401,
                            detail=f"droits not found for epci {epci_id}")

    query = FicheActionCategorie.filter(epci_id=epci_id,
                                        uid=fiche_action_categorie.uid)

    if await query.exists():
        await query.update(latest=False)

    fiche_action_categorie_obj = await FicheActionCategorie.create(
        **fiche_action_categorie.dict(exclude_unset=True),
        latest=True,
        deleted=False,
    )
    return await FicheActionCategorie_Pydantic.from_tortoise_orm(
        fiche_action_categorie_obj)

Beispiel #6

Datei: on_publish_check_epci.py Projekt: betagouv/territoires-en-transitions

def on_publish_check_epci(
    epci_id_in_path: str,
    epci_id_in_field: str,
    droits: List[UtilisateurDroits_Pydantic],
):
    if epci_id_in_path != epci_id_in_field:
        raise HTTPException(status_code=400, detail="epci_id mismatch")
    epci_id = epci_id_in_path
    if not can_write_epci(epci_id, droits):
        raise HTTPException(status_code=401,
                            detail=f"droits not found for epci {epci_id}")

Beispiel #7

async def delete_fiche_action(
    epci_id: str,
    uid: str,
    droits: List[UtilisateurDroits_Pydantic] = Depends(
        get_utilisateur_droits_from_header),
):
    if not can_write_epci(epci_id, droits):
        raise HTTPException(status_code=401,
                            detail=f"droits not found for epci {epci_id}")

    query = FicheAction.filter(epci_id=epci_id,
                               uid=uid,
                               latest=True,
                               deleted=False)
    if await query.exists():
        await query.update(deleted=True)
    else:
        raise HTTPException(status_code=404,
                            detail=f"fiche_action /{epci_id}/{uid} not found")
    return Status(message=f"Deleted fiche_action /{epci_id}/{uid}")