def numero_mo_next_view(request):
"""
Return all next available numero MO par cadastre, type et plan
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
cadastre_id = request.params[
'cadastre_id'] if 'cadastre_id' in request.params else None
type_id = request.params['type_id'] if 'type_id' in request.params else None
plan = request.params['plan'] if 'plan' in request.params else None
query = request.dbsession.query(VProchainNumeroDisponible)
if cadastre_id:
query = query.filter(
VProchainNumeroDisponible.cadastre_id == cadastre_id)
if type_id:
query = query.filter(
VProchainNumeroDisponible.numero_type_id == type_id)
if plan:
query = query.filter(VProchainNumeroDisponible.plan == plan)
query = query.all()
return Utils.serialize_many(query)
def reservation_numeros_mo_by_affaire_id_view(request):
"""
Return all reservations_numeros_mo by affaire_id
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
searchLimit = request.registry.settings['search_limit']
affaire_id = request.matchdict['id']
cadastre_id = request.params[
"cadastre_id"] if "cadastre_id" in request.params else None
startDate = request.params[
"startDate"] if "startDate" in request.params else None
endDate = request.params["endDate"] if "endDate" in request.params else None
query = request.dbsession.query(VReservationNumerosMO).filter(
VReservationNumerosMO.affaire_id == affaire_id).order_by(
VReservationNumerosMO.id.desc())
if not cadastre_id is None:
query = query.filter(VReservationNumerosMO.cadastre_id == cadastre_id)
if not startDate is None:
query = query.filter(VReservationNumerosMO.date >= startDate)
if not endDate is None:
query = query.filter(VReservationNumerosMO.date <= endDate)
if request.params == {} or (cadastre_id is None and startDate is None):
query = query.limit(searchLimit)
query = query.all()
return Utils.serialize_many(query)
def numeros_view(request):
"""
Return all numeros
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
numero = int(request.params['numero']) if 'numero' in request.params else None
cadastre_id = [int(a) for a in request.params['cadastre_id'].split(",")] if 'cadastre_id' in request.params else None
type_id = [int(a) for a in request.params['type_id'].split(",")] if 'type_id' in request.params else None
etat_id = [int(a) for a in request.params['etat_id'].split(",")] if 'etat_id' in request.params else None
query = request.dbsession.query(VNumeros)
if numero:
query = query.filter(VNumeros.numero == numero)
if cadastre_id:
query = query.filter(VNumeros.cadastre_id.in_(cadastre_id))
if type_id:
query = query.filter(VNumeros.type_numero_id.in_(type_id))
if etat_id:
query = query.filter(VNumeros.etat_id.in_(etat_id))
query = query.order_by(VNumeros.numero.asc()).all()
return Utils.serialize_many(query)
def affaire_numeros_view(request):
"""
Add new numero_etat_histo
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
conditions = list()
affaire_id = request.matchdict["id"]
# Récupérer les id des numéros de la MO
settings = request.registry.settings
numeros_immeubles_type_id = [
settings['numero_bf_id'],
settings['numero_ddp_id'],
settings['numero_ppe_id'],
settings['numero_pcop_id']
]
conditions.append(VNumerosAffaires.affaire_id == affaire_id)
conditions.append(VNumerosAffaires.numero_type_id.in_(numeros_immeubles_type_id))
if 'affaire_numero_actif' in request.params:
affaire_numero_actif = request.params['affaire_numero_actif']
affaire_numero_actif = True if affaire_numero_actif.upper() == 'TRUE' else False
conditions.append(VNumerosAffaires.affaire_numero_actif == affaire_numero_actif)
records = request.dbsession.query(VNumerosAffaires).filter(
*conditions).order_by(VNumerosAffaires.numero.desc()).all()
return Utils.serialize_many(records)
def etats_numeros_view(request):
"""
Return all etats_numeros
"""
id_artefact = request.registry.settings['numero_artefact_id']
query = request.dbsession.query(NumeroEtat).filter(NumeroEtat.id != id_artefact).all()
return Utils.serialize_many(query)
def numeros_search_view(request):
"""
Search numeros
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
settings = request.registry.settings
search_limit = int(settings['search_limit'])
params = request.params
matDiff = False
if 'matDiff' in params:
matDiff = True if params['matDiff'] == 'true' else False
# Set conditions
conditions = Utils.get_search_conditions(VNumeros, params)
# filter by conditions
query = request.dbsession.query(VNumeros).order_by(
VNumeros.cadastre, VNumeros.numero.desc()).filter(*conditions)
query = query.filter(VNumeros.type_numero_id <= 4)
# if option matDiff selected
if matDiff:
query = query.filter(
and_(VNumeros.diff_entree.isnot(None),
VNumeros.diff_sortie.is_(None)))
query = query.limit(search_limit).all()
return Utils.serialize_many(query)
def types_numeros_view(request):
"""
Return all types_numeros
"""
immeule_thr = request.registry.settings['numero_type_immeuble_thr']
query = request.dbsession.query(NumeroType).filter(
NumeroType.ordre < immeule_thr).order_by(NumeroType.ordre.asc()).all()
return Utils.serialize_many(query)
def types_modification_affaire_view(request):
"""
Return all types modification affaire
"""
records = request.dbsession.query(ModificationAffaireType).filter(
ModificationAffaireType.ordre != None
).order_by(ModificationAffaireType.ordre.asc()).all()
return Utils.serialize_many(records)
def types_affaires_view(request):
"""
Return all types affaires not modif
"""
types_affaires = request.dbsession.query(AffaireType).filter(AffaireType.ordre != None).order_by(AffaireType.ordre.asc()).all()
types_affaires = Utils.serialize_many(types_affaires)
return types_affaires
def affaires_view(request):
"""
Return all affaires
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(VAffaire).order_by(VAffaire.id.desc()).all()
return Utils.serialize_many(query)
def numeros_relations_view(request):
"""
Return all numeros_relations
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(VNumerosRelations).all()
return Utils.serialize_many(query)
def operateurs_view(request):
"""
Return all operateurs
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(Operateur).filter(Operateur.sortie == None).all()
return Utils.serialize_many(query)
def facture_type_view(request):
"""
Return all facture types
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(FactureType).all()
return Utils.serialize_many(query)
def clients_view(request):
"""
Return all clients
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(Client).filter(Client.sortie == None).all()
return Utils.serialize_many(query)
def controles_ppe_view(request):
"""
Return all controles_ppe
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(ControlePPE).all()
return Utils.serialize_many(query)
def tableau_emoluments_view(request):
"""
Return table of emoluments
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(TableauEmoluments).all()
return Utils.serialize_many(query)
def suivi_mandats_view(request):
"""
Return all suivi_mandats
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(SuiviMandat).all()
return Utils.serialize_many(query)
def types_client_moral_personnes_by_client_id_view(request):
"""
Return all people in client_moral
"""
client_id = request.matchdict[
'client_id'] if 'client_id' in request.matchdict else None
query = request.dbsession.query(ClientMoralPersonne).filter(
ClientMoralPersonne.client_id == client_id).all()
return Utils.serialize_many(query)
def plans_mo_view(request):
"""
Return all plans_mo
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
query = request.dbsession.query(VPlan).order_by(VPlan.planno.asc()).all()
return Utils.serialize_many(query)
def reservation_numeros_mo_by_affaire_id_view(request):
"""
Return all reservations_numeros_mo by affaire_id
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
affaire_id = request.matchdict['id']
query = request.dbsession.query(VReservationNumerosMO).filter(
VReservationNumerosMO.affaire_id == affaire_id).all()
return Utils.serialize_many(query)
def etapes_index_view(request):
"""
GET etapes index
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
records = request.dbsession.query(AffaireEtapeIndex).filter(
AffaireEtapeIndex.ordre != None).order_by(
AffaireEtapeIndex.ordre.asc()).all()
return Utils.serialize_many(records)
def services_view(request):
"""
GET services
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
records = request.dbsession.query(Service).order_by(
Service.ordre.asc()).all()
return Utils.serialize_many(records)
def facture_emoluments_view(request):
"""
Return all emoluments in facture
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
facture_id = request.matchdict["id"]
query = request.dbsession.query(VEmolumentsFactures).filter(
VEmolumentsFactures.facture_id == facture_id).all()
return Utils.serialize_many(query)
def cadastre_view(request):
"""
GET cadastre
"""
# Check connected
# if not Utils.check_connected(request):
# raise exc.HTTPForbidden()
records = request.dbsession.query(Cadastre).filter(
Cadastre.id != request.registry.settings['cadastre_cantonal_id']
).order_by(Cadastre.nom).all()
return Utils.serialize_many(records)
def affaires_factures_view(request):
"""
Return all factures in affaire
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
affaire_id = request.matchdict["id"]
query = request.dbsession.query(VFactures).filter(
VFactures.affaire_id == affaire_id).all()
return Utils.serialize_many(query)
def numeros_affaire_view(request):
"""
Get affaires by numero_id
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
numero_id = request.matchdict['id']
query = request.dbsession.query(VNumerosAffaires).filter(
VNumerosAffaires.numero_id == numero_id).all()
return Utils.serialize_many(query)
def affaires_search_view(request):
"""
Search affaires
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
settings = request.registry.settings
search_limit = int(settings['search_limit'])
params_affaires = {}
client = None
client_in_params = False
for key in request.params.keys():
if "client" in key:
client = request.params[key]
client_in_params = True
params_affaires["client_commande_id"] = request.params[key]
params_affaires["client_envoi_id"] = request.params[key]
else:
params_affaires[key] = request.params[key]
# Chercher les affaires par les clients de facture
affaires_id_by_clients_facture = []
if client_in_params:
query_facture = request.dbsession.query(Facture).filter(or_(
Facture.client_id == client,
Facture.client_co_id == client,
)).all()
# Récupérer la liste des id des affaires retenues
for facture in query_facture:
affaires_id_by_clients_facture.append(int(facture.affaire_id))
# Chercher les affaires par les conditions (sauf client_facture)
conditions = Utils.get_search_conditions(VAffaire, params_affaires)
query = request.dbsession.query(VAffaire)
if client_in_params:
query = query.filter(and_(
*conditions,
VAffaire.id.in_(affaires_id_by_clients_facture)
))
else:
query = query.filter(*conditions)
query = query.limit(search_limit).all()
return Utils.serialize_many(query)
def balance_check_existing_oldBF_new_view(request):
"""
Check if oldBF already exist in DB and create it otherwise
"""
# Check connected
if not Utils.has_permission(
request, request.registry.settings['affaire_numero_edition']):
raise exc.HTTPForbidden()
affaire_id = request.params['affaire_id']
oldBF = json.loads(request.params['oldBF'])
# Control existance of each oldBF
numero_obj = []
for bf in oldBF:
bf_cadastre_id, bf_numero = bf.split("_")
numero = request.dbsession.query(Numero).filter(
and_(Numero.cadastre_id == bf_cadastre_id,
Numero.numero == bf_numero)).first()
# Create number if it doesn't exist
if not numero:
numero = Numero(
cadastre_id=bf_cadastre_id,
type_id=request.registry.settings['numero_bf_id'],
numero=bf_numero,
etat_id=request.registry.settings['numero_vigueur_id'])
request.dbsession.flush()
# Add numero to array of Numeros created
numero_obj.append(numero)
# Add numero_affaire link
affNum = AffaireNumero()
affNum(
affaire_id=affaire_id,
numero_id=numero.id,
type_id=request.registry.settings['numero_bf_id'],
actif=True,
)
# Add numero_etat_histo link
numEtatHisto = NumeroEtatHisto()
numEtatHisto(
numero_id=numero.id,
numero_etat_id=request.registry.settings['numero_vigueur_id'],
date=datetime.now().date())
return Utils.serialize_many(numero_obj)
def affaire_preavis_view(request):
"""
GET preavis affaire
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
affaire_id = request.matchdict['id']
records = request.dbsession.query(VAffairesPreavis).filter(
VAffairesPreavis.affaire_id == affaire_id).all()
return Utils.serialize_many(records)
def numeros_relation_by_affaire_id_view(request):
"""
Return Numeros_relations
"""
# Check connected
if not Utils.check_connected(request):
raise exc.HTTPForbidden()
affaire_id = request.matchdict['id']
# filter by conditions
query = request.dbsession.query(VNumerosRelations).filter(
VNumerosRelations.affaire_id == affaire_id).all()
return Utils.serialize_many(query)