예제 #1
0
def cultivos_update(request):
    gid = request.matchdict['id']
    if not gid:
        raise badrequest_exception({'error': error_msgs['gid_obligatory']})

    msgs = validate_entities(request.json_body)
    if len(msgs) > 0:
        raise badrequest_exception({'error': msgs})

    try:
        cultivo = request.db.query(ActividadesCultivos).filter(ActividadesCultivos.gid == gid).one()
        cultivo.update_from_json(request.json_body)
        request.db.add(cultivo)
        request.db.commit()
        actv = request.db.query(Actividade).filter(Actividade.gid ==cultivo.actividade).one()
        c_estimado_actv = 0
        for cultivo in actv.cultivos:
            c_estimado_actv += cultivo.c_estimado
        actv.c_estimado = c_estimado_actv
        request.db.add(actv)
        exp = request.db.query(Exploracao).filter(Exploracao.gid == actv.exploracao).one()
        exp.c_estimado = c_estimado_actv
        request.db.add(exp)
        request.db.commit()
    except(MultipleResultsFound, NoResultFound):
        raise badrequest_exception({
            'error': error_msgs['no_cultivo_gid'],
            'gid': gid
        })
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})

    return cultivo
예제 #2
0
def exploracaos_delete(request):
    gid = request.matchdict['id']
    if not gid:
        raise badrequest_exception({'error': error_msgs['gid_obligatory']})
    try:
        e = request.db.query(Exploracao).filter(Exploracao.gid == gid).one()
        request.db.delete(e)
        request.db.commit()
    except(MultipleResultsFound, NoResultFound):
        raise badrequest_exception({
            'error': error_msgs['no_gid'],
            'gid': gid
        })
    return {'gid': gid}
예제 #3
0
def settings_update(request):
    property = request.matchdict['property']
    if not property:
        raise badrequest_exception({'error': error_msgs['gid_obligatory']})

    try:
        setting = request.db.query(Setting).filter(Setting.property == property).one()
        setting.update_from_json(request.json_body, property)
        request.db.add(setting)
        request.db.commit()
    except(MultipleResultsFound, NoResultFound):
        raise badrequest_exception({
            'error': error_msgs['no_gid'],
            'gid': gid
        })
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})

    return setting
예제 #4
0
def exploracaos_update(request):
    gid = request.matchdict['id']
    if not gid:
        raise badrequest_exception({
            'error': error_msgs['gid_obligatory']
        })

    try:
        body = request.json_body
        msgs = validate_entities(body)
        if len(msgs) > 0:
            raise badrequest_exception({'error': msgs})

        e = request.db.query(Exploracao).filter(Exploracao.gid == gid).one()

        u_id = body.get('utente').get('id')
        if not u_id:
            u = Utente.create_from_json(body['utente'])
            # TODO:660 validate utente
            request.db.add(u)
        elif e.utente_rel.gid != u_id:
            u_filter = Utente.gid == u_id
            u = request.db.query(Utente).filter(u_filter).one()
        else:
            u = e.utente_rel

        validatorUtente = Validator(UTENTE_SCHEMA)
        msgs = validatorUtente.validate(request.json_body['utente'])
        if len(msgs) > 0:
            raise badrequest_exception({'error': msgs})
        e.utente_rel = u
        u.update_from_json(request.json_body['utente'])
        request.db.add(u)

        if _tipo_actividade_changes(e, request.json_body):
            request.db.delete(e.actividade)
            del e.actividade

        lic_nro_sequence = Exploracao.LIC_NRO_SEQUENCE_FIRST
        for lic in e.licencias:
            lic_nro_sequence = calculate_lic_nro(lic.lic_nro, lic_nro_sequence)
        e.update_from_json(request.json_body, lic_nro_sequence)

        request.db.add(e)
        request.db.commit()
    except(MultipleResultsFound, NoResultFound):
        raise badrequest_exception({'error': error_msgs['no_gid'], 'gid': gid})
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})
    except ValidationException as val_exp:
        if u:
            request.db.refresh(u)
        if e:
            request.db.refresh(e)
        raise badrequest_exception(val_exp.msgs)

    return e
예제 #5
0
def exploracaos_create(request):
    try:
        body = request.json_body
        exp_id = body.get('exp_id')
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})

    msgs = validate_entities(body)
    if len(msgs) > 0:
        raise badrequest_exception({'error': msgs})

    e = request.db.query(Exploracao).filter(Exploracao.exp_id == exp_id).first()
    if e:
        raise badrequest_exception({'error': error_msgs['exploracao_already_exists']})

    u_filter = Utente.nome == body.get('utente').get('nome')
    u = request.db.query(Utente).filter(u_filter).first()
    if not u:
        validatorUtente = Validator(UTENTE_SCHEMA)
        msgs = validatorUtente.validate(body['utente'])
        if len(msgs) > 0:
            raise badrequest_exception({'error': msgs})
        u = Utente.create_from_json(body['utente'])
        request.db.add(u)
    try:
        e = Exploracao.create_from_json(body)
    except ValidationException as val_exp:
        if u:
            request.db.refresh(u)
        if e:
            request.db.refresh(e)
        raise badrequest_exception(val_exp.msgs)
    e.utente_rel = u
    request.db.add(e)
    request.db.commit()
    return e
예제 #6
0
def utentes_create(request):
    try:
        body = request.json_body
        nome = body.get('nome')
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})

    msgs = validate_entities(body)
    if len(msgs) > 0:
        raise badrequest_exception({'error': msgs})

    # TODO:320 is this not covered by schema validations?
    if not nome:
        raise badrequest_exception({'error': 'nome es um campo obligatorio'})

    e = request.db.query(Utente).filter(Utente.nome == nome).first()
    if e:
        raise badrequest_exception({'error': error_msgs['utente_already_exists']})

    u = Utente.create_from_json(body)
    request.db.add(u)
    request.db.commit()
    return u
예제 #7
0
def utentes_update(request):
    gid = request.matchdict['id']
    if not gid:
        raise badrequest_exception({'error': error_msgs['gid_obligatory']})

    msgs = validate_entities(request.json_body)
    if len(msgs) > 0:
        raise badrequest_exception({'error': msgs})

    try:
        e = request.db.query(Utente).filter(Utente.gid == gid).one()
        e.update_from_json(request.json_body)
        request.db.add(e)
        request.db.commit()
    except(MultipleResultsFound, NoResultFound):
        raise badrequest_exception({
            'error': error_msgs['no_gid'],
            'gid': gid
        })
    except ValueError as ve:
        log.error(ve)
        raise badrequest_exception({'error': error_msgs['body_not_valid']})

    return e
예제 #8
0
def utentes_get(request):
    gid = None
    if request.matchdict:
        gid = request.matchdict['id'] or None

    if gid:  # return individual utente
        try:
            return request.db.query(Utente).filter(Utente.gid == gid).one()
        except(MultipleResultsFound, NoResultFound):
            raise badrequest_exception({
                'error': error_msgs['no_gid'],
                'gid': gid
                })
    else:
        return request.db.query(Utente).order_by(Utente.nome).all()
예제 #9
0
def cultivos_get(request):
    gid = None
    if request.matchdict:
        gid = request.matchdict['id'] or None

    if gid:  # return individual cultivo
        try:
            return request.db.query(ActividadesCultivos).filter(ActividadesCultivos.gid == gid).one()
        except(MultipleResultsFound, NoResultFound):
            raise badrequest_exception({
                'error': error_msgs['no_gid'],
                'gid': gid
                })
    else:  # return collection
        return {
            'type': 'FeatureCollection',
            'features': request.db.query(ActividadesCultivos).order_by(ActividadesCultivos.cult_id).all()
        }