def clients_update_view(request):
"""
Update 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))
# Read params client
model = Utils.set_model_record(model, request.params)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Client.__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 test_error(exc, request):
"""
Test (temp endpoint)
"""
query = request.dbsession.query(Client).first()
query = Utils.set_model_record(query, request.params)
return Utils.serialize_one(query)
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 numeros_etat_histo_new_view(request, params=None):
"""
Add new numero_etat_histo
"""
# Check authorization
settings = request.registry.settings
if not Utils.has_permission(request, settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
if not params:
params = request.params
# check if etat already exists
numEtatHisto = request.dbsession.query(NumeroEtatHisto).filter(
NumeroEtatHisto.numero_id == params['numero_id']).filter(
NumeroEtatHisto.numero_etat_id ==
params['numero_etat_id']).first()
if not numEtatHisto is None:
return
# nouveau numero
record = NumeroEtatHisto()
record = Utils.set_model_record(record, params)
request.dbsession.add(record)
request.dbsession.flush()
Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(NumeroEtatHisto.__tablename__))
return record.id
def affaire_numero_new_view(request, params=None):
"""
Add new affaire-numero
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
if not params:
params = request.params
# check if affaire_numero relation already exists
affaireNumero = request.dbsession.query(AffaireNumero).filter(
AffaireNumero.affaire_id == params['affaire_id']).filter(
AffaireNumero.numero_id == params['numero_id']).filter(
AffaireNumero.type_id == params['type_id']).first()
if not affaireNumero is None:
return
# nouveau affaire_numero
record = AffaireNumero()
record = Utils.set_model_record(record, params)
request.dbsession.add(record)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(AffaireNumero.__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 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 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 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 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 modification_affaires_view(request):
"""
Modification affaire
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_edition']):
raise exc.HTTPForbidden()
# Get client instance
model = Utils.set_model_record(ModificationAffaire(), request.params)
request.dbsession.add(model)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(ModificationAffaire.__tablename__))
def operateurs_new_view(request):
"""
Add new operateur
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['fonction_admin']):
raise exc.HTTPForbidden()
# Get operateur instance
model = Utils.set_model_record(Operateur(), request.params)
request.dbsession.add(model)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(Operateur.__tablename__))
def numero_differe_new_view(request):
"""
Add new numero_differe
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
# nouveau numero_differe
record = NumeroDiffere()
record = Utils.set_model_record(record, request.params)
request.dbsession.add(record)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(NumeroDiffere.__tablename__))
def services_new_view(request):
"""
Add preavis affaire
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['fonction_admin']):
raise exc.HTTPForbidden()
model = Service()
model = Utils.set_model_record(model, request.params)
request.dbsession.add(model)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Service.__tablename__))
def clients_moral_personne_new_view(request):
"""
Add new contact in entreprise
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['client_edition']):
raise exc.HTTPForbidden()
# Get clientMoralPersonne instance
model = Utils.set_model_record(ClientMoralPersonne(), request.params)
request.dbsession.add(model)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(ClientMoralPersonne.__tablename__))
def preavis_new_view(request):
"""
POST preavis affaire
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_preavis_edition']):
raise exc.HTTPForbidden()
model = Preavis()
model = Utils.set_model_record(model, request.params)
request.dbsession.add(model)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Preavis.__tablename__))
def clients_new_view(request):
"""
Add new client
"""
# Check authorization
if not Utils.has_permission(request,
request.registry.settings['client_edition']):
raise exc.HTTPForbidden()
# Get client instance
model = Utils.set_model_record(Client(), request.params)
request.dbsession.add(model)
request.dbsession.flush()
return json.dumps({'client_id': model.id})
def affaire_numero_new_view(request, params=None):
"""
Add new affaire-numero
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
if not params:
params = request.params
# nouveau affaire_numero
record = AffaireNumero()
record = Utils.set_model_record(record, params)
request.dbsession.add(record)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(AffaireNumero.__tablename__))
def numeros_relations_new_view(request, params=None):
"""
Add new numeros_relations
"""
if params is None:
params = request.params
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
# Get numeros_relations instance
model = Utils.set_model_record(NumeroRelation(), params)
request.dbsession.add(model)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(NumeroRelation.__tablename__))
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 emolument_affaire_new_view(request):
"""
Add new emolument_affaire
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
params = request.params
data = json.loads(params["data"])
record = EmolumentAffaire()
record = Utils.set_model_record(record, data)
request.dbsession.add(record)
request.dbsession.flush()
return {"emolument_affaire_id": record.id}
def numero_differe_update_view(request):
"""
Update numero_differe
"""
# Check authorization
if not Utils.has_permission(request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
if "numero_diff_id" in request.params:
numdiff_id = request.params["numero_diff_id"]
record = request.dbsession.query(NumeroDiffere).filter(NumeroDiffere.id == numdiff_id).first()
if "numero_id" in request.params:
num_id = request.params["numero_id"]
record = request.dbsession.query(NumeroDiffere).filter(NumeroDiffere.numero_id == num_id).first()
# update numero_differe
record = Utils.set_model_record(record, request.params)
return Utils.get_data_save_response(Constant.SUCCESS_SAVE.format(NumeroDiffere.__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 update_emolument_affaire_view(request):
"""
Update emolument_affaire
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
params = request.params
data = json.loads(params["data"])
record_id = request.params[
'emolument_affaire_id'] if 'emolument_affaire_id' in request.params else None
record = request.dbsession.query(EmolumentAffaire).filter(
EmolumentAffaire.id == record_id).first()
record = Utils.set_model_record(record, data)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(EmolumentAffaire.__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 emolument_new_view(request):
"""
Add new emolument
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['affaire_facture_edition']):
raise exc.HTTPForbidden()
params = request.params
data = json.loads(params['data'])
emolument_affaire_id = params['emolument_affaire_id']
for batiment_i in data:
for emolument_i in batiment_i:
if float(batiment_i[emolument_i]['montant']) > 0 and float(
batiment_i[emolument_i]['nombre']) > 0:
params = Utils._params(
emolument_affaire_id=int(emolument_affaire_id),
tableau_emolument_id=int(
batiment_i[emolument_i]['tableau_emolument_id']),
position=batiment_i[emolument_i]['nom'],
prix_unitaire=float(
batiment_i[emolument_i]['prix_unitaire']),
nombre=int(batiment_i[emolument_i]['nombre']),
batiment=int(batiment_i[emolument_i]['batiment']),
batiment_f=float(batiment_i[emolument_i]['batiment_f']),
montant=float(batiment_i[emolument_i]['montant']))
record = Emolument()
record = Utils.set_model_record(record, params)
request.dbsession.add(record)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(Emolument.__tablename__))
def reservation_numeros_mo_new_view(request):
"""
Add new reservation_numeros_mo
"""
# Check authorization
if not Utils.has_permission(
request, request.registry.settings['numero_mo_edition']):
raise exc.HTTPForbidden()
# get cadastres jumeaux
cadastres_ChauxDeFonds_Eplatures_id = [
int(i) for i in request.registry.
settings['cadastres_ChauxDeFonds_Eplatures_id'].split(",")
]
cadastres_BrotPlamboz_Plamboz_id = [
int(i) for i in request.registry.
settings['cadastres_BrotPlamboz_Plamboz_id'].split(",")
]
cadastres_Neuchatel_Coudre_id = [
int(i) for i in
request.registry.settings['cadastres_Neuchatel_Coudre_id'].split(",")
]
cadastres_Sauge_StAubin_id = [
int(i) for i in
request.registry.settings['cadastres_Sauge_StAubin_id'].split(",")
]
# get request params
cadastre_id = int(request.params["cadastre_id"])
type_id = int(request.params["type_id"])
plan_id = request.params["plan_id"] if "plan_id" in request.params else None
# Corriger la liste des cadastres où la réservation de numéros se fait sur deux cadastres
if cadastre_id in cadastres_ChauxDeFonds_Eplatures_id:
# Cadastre de la Chaux-de-Fonds et des Eplatures
max_reservation = max(
Utils.last_number_mo(request,
cadastres_ChauxDeFonds_Eplatures_id[0],
type_id, plan_id),
Utils.last_number_mo(request,
cadastres_ChauxDeFonds_Eplatures_id[1],
type_id, plan_id))
elif cadastre_id in cadastres_BrotPlamboz_Plamboz_id:
# Cadastre de Brot-Plamboz et Plamboz
max_reservation = max(
Utils.last_number_mo(request, cadastres_BrotPlamboz_Plamboz_id[0],
type_id, plan_id),
Utils.last_number_mo(request, cadastres_BrotPlamboz_Plamboz_id[1],
type_id, plan_id))
elif cadastre_id in cadastres_Neuchatel_Coudre_id:
# Cadastre de Neuchâtel et de la Coudre
max_reservation = max(
Utils.last_number_mo(request, cadastres_Neuchatel_Coudre_id[0],
type_id, plan_id),
Utils.last_number_mo(request, cadastres_Neuchatel_Coudre_id[1],
type_id, plan_id))
elif cadastre_id in cadastres_Sauge_StAubin_id:
# Cadastre de Sauge et de Saint-Aubin
max_reservation = max(
Utils.last_number_mo(request, cadastres_Sauge_StAubin_id[0],
type_id, plan_id),
Utils.last_number_mo(request, cadastres_Sauge_StAubin_id[1],
type_id, plan_id))
else:
max_reservation = Utils.last_number_mo(request, cadastre_id, type_id,
plan_id)
# get params into mutable dict
params = {}
for key in request.params:
params[key] = request.params[key]
# Adjust numbers
params['numero_de'] = max_reservation + int(params['numero_de'])
params['numero_a'] = max_reservation + int(params['numero_a'])
# Save in database
model = ReservationNumerosMO()
model = Utils.set_model_record(model, params)
request.dbsession.add(model)
return Utils.get_data_save_response(
Constant.SUCCESS_SAVE.format(ReservationNumerosMO.__tablename__))