def affaire_numero_delete_view(request):
"""
delete numeros_affaires
"""
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
affnum_id = None
affaire_id = None
numero_id = None
record = None
if "id" in request.params:
affnum_id = request.params["id"]
record = request.dbsession.query(AffaireNumero).filter(AffaireNumero.id == affnum_id).first()
elif "affaire_id" in request.params and "numero_id" in request.params:
affaire_id = request.params["affaire_id"]
numero_id = request.params["numero_id"]
record = request.dbsession.query(AffaireNumero).filter(and_(
AffaireNumero.affaire_id == affaire_id,
AffaireNumero.numero_id == numero_id
)).first()
else:
raise CustomError(CustomError.INCOMPLETE_REQUEST)
request.dbsession.delete(record)
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(AffaireNumero.__tablename__, affnum_id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(Constant.SUCCESS_DELETE.format(AffaireNumero.__tablename__))
def affaire_numero_delete_view(request):
"""
delete numeros_affaires
"""
if not Utils.has_permission(
request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
affnum_id = None
affaire_id = None
numero_id = None
record = None
if "id" in request.params:
affnum_id = request.params["id"]
record = request.dbsession.query(AffaireNumero).filter(
AffaireNumero.id == affnum_id).first()
elif "affaire_id" in request.params and "numero_id" in request.params:
affaire_id = int(request.params["affaire_id"])
numero_id = int(request.params["numero_id"])
record = request.dbsession.query(AffaireNumero).filter(
and_(AffaireNumero.affaire_id == affaire_id,
AffaireNumero.numero_id == numero_id)).first()
else:
raise CustomError(CustomError.INCOMPLETE_REQUEST)
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
AffaireNumero.__tablename__, affnum_id))
# Get affaire_type_id and config values
affaire_type_id = request.dbsession.query(Affaire).filter(
Affaire.id == affaire_id).first().type_id
affaire_type_cadastration_id = int(
request.registry.settings['affaire_type_cadastration_id'])
# supprimer la facture du numéro si c'est une affaire de cadastration
if affaire_type_id == affaire_type_cadastration_id:
factNum = request.dbsession.query(Facture).filter(
and_(Facture.affaire_id == affaire_id,
Facture.numeros.op("@>")("{" + str(numero_id) + "}"))).all()
for fact in factNum:
request.dbsession.delete(fact)
request.dbsession.delete(record)
return Utils.get_data_save_response(
Constant.SUCCESS_DELETE.format(AffaireNumero.__tablename__))
def emolument_facture_update_view(request):
"""
Update emolument_facture
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
emolument_facture_id = request.params[
'id'] if 'id' in request.params else None
# Get the facture
record = request.dbsession.query(EmolumentFacture).filter(
EmolumentFacture.id == emolument_facture_id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
EmolumentFacture.__tablename__, emolument_facture_id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(EmolumentFacture.__tablename__))
def factures_update_view(request):
"""
Update facture
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
# id_facture
id_facture = None
if 'id' in request.params:
id_facture = request.params['id']
# Get the facture
facture_record = request.dbsession.query(Facture).filter(
Facture.id == id_facture).first()
params = {}
for key in request.params:
if key == "numeros":
params[key] = json.loads(request.params[key])
else:
params[key] = request.params[key]
if not facture_record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(Facture.__tablename__, id_facture))
facture_record = Utils.set_model_record(facture_record, params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Facture.__tablename__))
def controles_mutations_update_view(request):
"""
Update controle_mutation
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['affaire_edition']):
raise exc.HTTPForbidden()
# Get controle mutation id
id = request.params['id'] if 'id' in request.params else None
# Get controle mutation record
record = request.dbsession.query(ControleMutation).filter(
ControleMutation.id == id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
ControleMutation.__tablename__, id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(ControleMutation.__tablename__))
def numeros_new_view(request, params=None):
"""
Add new numeros
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
if not params:
params = request.params
params['no_access'] = "_".join(str(params['cadastre_id']),
str(params['numero']))
# tester si le numéro à réserver est plus grand que le max +1 déjà existant dans la base. Si oui, répondre par une erreur
num_max = request.dbsession.query(func.max(Numero.numero)).filter(
Numero.cadastre_id == params['cadastre_id']).scalar()
if int(params['numero']) > num_max + 1:
raise CustomError(
CustomError.NUMBER_REGISTRATION_FAILED.format(
params['numero'], params['cadastre_id'], num_max))
# nouveau numero
record = Numero()
record = Utils.set_model_record(record, params)
request.dbsession.add(record)
request.dbsession.flush()
Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Numero.__tablename__))
return record.id
def notes_maj_update_view(request):
"""
Update notes_maj
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['fonction_admin']):
raise exc.HTTPForbidden()
# Get operateur_id
notes_maj_id = request.params['id'] if 'id' in request.params else None
model = request.dbsession.query(NotesMAJ).filter(
NotesMAJ.id == notes_maj_id).first()
# If result is empty
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
NotesMAJ.__tablename__, notes_maj_id))
# Read params operateur
model = Utils.set_model_record(model, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(NotesMAJ.__tablename__))
def operateur_notes_maj_update_view(request):
"""
Update last seen notes_maj in operateur
"""
# Check authorization
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
# Get operateur_id
operateur_id = request.params[
'operateur_id'] if 'operateur_id' in request.params else None
last_notes_maj_id = request.params[
'last_notes_maj_id'] if 'last_notes_maj_id' in request.params else None
model = request.dbsession.query(Operateur).filter(
Operateur.id == operateur_id).first()
# If result is empty
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
Operateur.__tablename__, operateur_id))
# Read params operateur
model.last_notemaj_id = last_notes_maj_id
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Operateur.__tablename__))
def client_moral_personnes_delete_view(request):
"""
Delete client_moral_personnes
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['client_edition']):
raise exc.HTTPForbidden()
# Get client_id
client_moral_personne_id = request.params[
'id'] if 'id' in request.params else None
model = request.dbsession.query(ClientMoralPersonne).filter(
ClientMoralPersonne.id == client_moral_personne_id).first()
# If result is empty
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
ClientMoralPersonne.__tablename__, client_moral_personne_id))
request.dbsession.delete(model)
return Utils.get_data_save_response(
Constant.SUCCESS_DELETE.format(Client.__tablename__))
def clients_moral_personne_update_view(request):
"""
Update contact in entreprise
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['client_edition']):
raise exc.HTTPForbidden()
client_moral_personne_id = request.params[
"id"] if "id" in request.params else None
model = request.dbsession.query(ClientMoralPersonne).filter(
ClientMoralPersonne.id == client_moral_personne_id).first()
# If result is empty
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
ClientMoralPersonne.__tablename__, client_moral_personne_id))
# Read params client
model = Utils.set_model_record(model, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(ClientMoralPersonne.__tablename__))
def clients_delete_view(request):
"""
Delete client
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['client_edition']):
raise exc.HTTPForbidden()
# Get client_id
id_client = request.params['id'] if 'id' in request.params else None
model = request.dbsession.query(Client).filter(
Client.id == id_client).first()
# If result is empty
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
Client.__tablename__, id_client))
model.sortie = datetime.utcnow()
return Utils.get_data_save_response(
Constant.SUCCESS_DELETE.format(Client.__tablename__))
def numeros_update_view(request):
"""
Update numeros
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
# Get numero id
id = request.params['id'] if 'id' in request.params else None
# Get numero record
record = request.dbsession.query(Numero).filter(
Numero.id == id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(Numero.__tablename__, id))
last_record_etat_id = record.etat_id
record = Utils.set_model_record(record, request.params)
if 'etat_id' in request.params:
if request.params['etat_id'] != last_record_etat_id:
params = Utils._params(
numero_id=record.id, numero_etat_id=request.params['etat_id'])
numeros_etat_histo_new_view(request, params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Numero.__tablename__))
def numeros_relations_delete_view(request):
"""
Delete numeros_relations
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
model = None
numero_relation_id = None
if "numero_relation_id" in request.params:
numero_relation_id = request.params["numero_relation_id"]
model = request.dbsession.query(NumeroRelation).filter(NumeroRelation.id == numero_relation_id).first()
elif "numero_base_id" in request.params and "affaire_id" in request.params:
numero_base_id = int(request.params["numero_base_id"])
affaire_id = int(request.params["affaire_id"])
numero_relation_id = "numero_base_id=" + request.params["numero_base_id"] + " & affaire_id=" + request.params["affaire_id"]
model = request.dbsession.query(NumeroRelation).filter(and_(
NumeroRelation.numero_id_base == numero_base_id,
NumeroRelation.affaire_id == affaire_id
)).first()
else:
raise CustomError.INCOMPLETE_REQUEST
if not model:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(NumeroRelation.__tablename__, numero_relation_id))
request.dbsession.delete(model)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(NumeroRelation.__tablename__))
def balance_view(request):
"""
Return balance ef affaire from table GEOS
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
mutation_name = request.params["mutation_name"] if "mutation_name" in request.params else None
if not mutation_name:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(GeosBalance.__tablename__, mutation_name))
query = request.dbsession.query(GeosBalance).filter(GeosBalance.mutation == mutation_name).all()
return Utils.serialize_many(query)
def affaire_numero_update_view(request):
"""
Update numeros_affaires
"""
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
affnum_id = request.params["id"] if "id" in request.params else None
record = request.dbsession.query(AffaireNumero).filter(AffaireNumero.id == affnum_id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(AffaireNumero.__tablename__, affnum_id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(AffaireNumero.__tablename__))
def factures_delete_view(request):
"""
Delete facture
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
id = request.params['id'] if 'id' in request.params else None
facture = request.dbsession.query(Facture).filter(Facture.id == id).first()
if not facture:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(Facture.__tablename__, id))
request.dbsession.delete(facture)
return Utils.get_data_save_response(Constant.SUCCESS_DELETE.format(Facture.__tablename__))
def etapes_delete_view(request):
"""
DELETE etapes affaire
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_etape_edition']):
raise exc.HTTPForbidden()
affaire_etape_id = request.matchdict['id']
record = request.dbsession.query(AffaireEtape).filter(
AffaireEtape.id == affaire_etape_id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(AffaireEtape.__tablename__, affaire_etape_id))
request.dbsession.delete(record)
return Utils.get_data_save_response(Constant.SUCCESS_DELETE.format(AffaireEtape.__tablename__))
def affaires_update_view(request):
"""
Update affaire
"""
# id_affaire
id_affaire = request.params['id_affaire'] if 'id_affaire' in request.params else None
# Get the affaire
record = request.dbsession.query(Affaire).filter(
Affaire.id == id_affaire).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(Affaire.__tablename__, id_affaire))
# Get role depending on affaire type
affaire_type = request.params['type_id'] if 'type_id' in request.params else record.type_id
# Permission (fonction) par défaut
permission = request.registry.settings['affaire_edition']
# Affaire de cadastration
if affaire_type == request.registry.settings['affaire_type_cadastration_id']:
permission = request.registry.settings['affaire_cadastration_edition']
# Affaire de PPE
elif affaire_type == request.registry.settings['affaire_type_ppe_id']:
permission = request.registry.settings['affaire_ppe_edition']
# Affaire de révision d'abornement
elif affaire_type == request.registry.settings['affaire_type_revision_abornement_id']:
permission = request.registry.settings['affaire_revision_abornement_edition']
# Affaire de rétablissement de PFP3
elif affaire_type == request.registry.settings['affaire_type_retablissement_pfp3_id']:
permission = request.registry.settings['affaire_retablissement_pfp3_edition']
# Check authorization
if not Utils.has_permission(request, permission):
raise exc.HTTPForbidden()
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Affaire.__tablename__))
def services_update_view(request):
"""
UPDATE service
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['fonction_admin']):
raise exc.HTTPForbidden()
service_id = request.params['id'] if 'id' in request.params else None
record = request.dbsession.query(Service).filter(
Service.id == service_id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
Service.__tablename__, service_id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Service.__tablename__))
def suivi_mandats_delete_view(request):
"""
Delete suivi_mandats
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_suivi_edition']):
raise exc.HTTPForbidden()
# Get controle mutation id
id = request.params['id'] if 'id' in request.params else None
# Get controle mutation record
record = request.dbsession.query(SuiviMandat).filter(
SuiviMandat.id == id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(SuiviMandat.__tablename__, id))
request.dbsession.delete(record)
return Utils.get_data_save_response(Constant.SUCCESS_DELETE.format(SuiviMandat.__tablename__))
def preavis_update_view(request):
"""
UPDATE preavis affaire
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_preavis_edition']):
raise exc.HTTPForbidden()
preavis_id = request.params['id'] if 'id' in request.params else None
record = request.dbsession.query(Preavis).filter(
Preavis.id == preavis_id).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(
Preavis.__tablename__, preavis_id))
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Preavis.__tablename__))
def affaires_update_view(request):
"""
Update affaire
"""
params = dict(request.params)
# id_affaire
id_affaire = params['id_affaire'] if 'id_affaire' in params else None
# Get the affaire
record = request.dbsession.query(Affaire).filter(
Affaire.id == id_affaire).first()
if not record:
raise CustomError(
CustomError.RECORD_WITH_ID_NOT_FOUND.format(Affaire.__tablename__, id_affaire))
# Get role depending on affaire type
affaire_type = params['type_id'] if 'type_id' in params else record.type_id
# Permission (fonction) par défaut
permission = request.registry.settings['affaire_edition']
# Check authorization
if not Utils.has_permission(request, permission):
# Affaire de cadastration
if affaire_type == request.registry.settings['affaire_type_cadastration_id']:
permission = request.registry.settings['affaire_cadastration_edition']
# Affaire de PPE
elif affaire_type == request.registry.settings['affaire_type_ppe_id']:
permission = request.registry.settings['affaire_ppe_edition']
# Affaire de révision d'abornement
elif affaire_type == request.registry.settings['affaire_type_revision_abornement_id']:
permission = request.registry.settings['affaire_revision_abornement_edition']
# Affaire de rétablissement de PFP3
elif affaire_type == request.registry.settings['affaire_type_retablissement_pfp3_id']:
permission = request.registry.settings['affaire_retablissement_pfp3_edition']
# Affaire pcop
elif affaire_type == request.registry.settings['affaire_type_part_copropriete_id']:
permission = request.registry.settings['affaire_pcop_edition']
# Affaire mpd
elif affaire_type == request.registry.settings['affaire_type_mpd_id']:
permission = request.registry.settings['affaire_mpd_edition']
# Affaire autre
elif affaire_type == request.registry.settings['affaire_type_autre_id']:
permission = request.registry.settings['affaire_autre_edition']
else:
raise exc.HTTPForbidden()
# check if path exists or not
if "chemin" in params:
affaires_directory_baseName = request.registry.settings["affaires_directory_full_path"]
chemin_affaire = params["chemin"]
if not chemin_affaire.lower().startswith(affaires_directory_baseName.lower()):
raise CustomError(CustomError.DIRECTORY_WRONG_BASE.format(chemin_affaire, affaires_directory_baseName))
else:
relpath = os.path.relpath(chemin_affaire, affaires_directory_baseName)
if os.path.exists(os.path.join(request.registry.settings['affaires_directory'], relpath)):
params["chemin"] = relpath
else:
raise CustomError(CustomError.DIRECTORY_NOT_FOUND.format(chemin_affaire))
record = Utils.set_model_record(record, params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Affaire.__tablename__))
def reservation_numeros_new_view(request):
"""
Add new numeros in affaire
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
nombre = int(request.params["nombre"]) if "nombre" in request.params else None
affaire_id = int(request.params["affaire_id"]) if "affaire_id" in request.params else None
cadastre_id = int(request.params["cadastre_id"]) if "cadastre_id" in request.params else None
etat_id = int(request.params["etat_id"]) if "etat_id" in request.params else None
type_id = int(request.params["type_id"]) if "type_id" in request.params else None
numero_base_id = int(request.params["numero_base_id"]) if "numero_base_id" in request.params else None
ppe_suffixe_start = request.params["ppe_suffixe_start"] if "ppe_suffixe_start" in request.params else None
if not (affaire_id and nombre and cadastre_id and etat_id and type_id):
raise CustomError(CustomError.GENERAL_EXCEPTION)
settings = request.registry.settings
# Récupère les id des états des biens-fonds de la config
numero_projet_id = int(settings['numero_projet_id'])
# Récupère les id des biens-fonds de la config
numero_bf_id = int(settings['numero_bf_id'])
numero_ddp_id = int(settings['numero_ddp_id'])
numero_ppe_id = int(settings['numero_ppe_id'])
numero_pcop_id = int(settings['numero_pcop_id'])
affaire_numero_type_nouveau_id = int(settings['affaire_numero_type_nouveau_id'])
numero_relation_mutation_id = int(settings['numero_relation_mutation_id'])
numero_relation_ddp_id = int(settings['numero_relation_ddp_id'])
numero_relation_ppe_id = int(settings['numero_relation_ppe_id'])
numero_relation_pcop_id = int(settings['numero_relation_pcop_id'])
if type_id in [numero_ddp_id, numero_ppe_id, numero_pcop_id] and numero_base_id is None:
raise CustomError(CustomError.RESERVATION_NUMBER_WITHOUT_BASE_NUMBER)
# Définit la relation entre le numéro de base et le numéro associé
# + Récupère l'id du suffixe de l'unité PPE de départ
suffixe = None
if type_id == numero_ddp_id:
relation_type_id = numero_relation_ddp_id
elif type_id == numero_ppe_id:
relation_type_id = numero_relation_ppe_id
unite_start_idx = Utils.get_index_from_unite(request.params["ppe_suffixe_start"].upper()) if "ppe_suffixe_start" in request.params else 0
elif type_id == numero_pcop_id:
relation_type_id = numero_relation_pcop_id
suffixe = "part"
# Récupère le dernier numéro de bien-fonds réservé dans le cadastre
ln = Utils.last_number(request, cadastre_id, [numero_bf_id, numero_ddp_id, numero_ppe_id, numero_pcop_id])
# Enregistrer le numéro
for i in range(nombre):
if type_id == numero_ppe_id:
# Update
suffixe = Utils.get_unite_from_index(unite_start_idx + i)
params = Utils._params(cadastre_id=cadastre_id, type_id=type_id, etat_id=etat_id, numero=ln+i+1, suffixe=suffixe, no_access="_".join([str(cadastre_id), str(ln+i+1)]))
numero_id = numeros_new_view(request, params)
# enregistrer le lien affaire-numéro
params = Utils._params(affaire_id=affaire_id, numero_id=numero_id, actif=True, type_id=affaire_numero_type_nouveau_id, no_access="_".join([str(cadastre_id), str(ln+i+1)]))
affaire_numero_new_view(request, params)
# enregistrer l'historique de l'état
params = Utils._params(numero_id=numero_id, numero_etat_id=etat_id, no_access="_".join([str(cadastre_id), str(ln+i+1)]))
numeros_etat_histo_new_view(request, params)
# enregistrer le numéro sur un bien-fonds de base si nécessaire
if numero_base_id:
params = Utils._params(numero_id_base=numero_base_id, numero_id_associe=numero_id, relation_type_id=relation_type_id, affaire_id=affaire_id)
numeros_relations_new_view(request, params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Numero.__tablename__))
