def vedtak_klaget_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])

    validator = BaseValidator(data)
    validator.validate_le_max_length("begrunnelse", 300, "begrunnelse")

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    klage = Klage()
    klage.soknad_id = soknad.id
    klage.vedtak_id = data.get('vedtak_id')
    klage.levertdato = datetime.now()
    klage.begrunnelse = data.get('begrunnelse')

    soknad.klage.append(klage)

    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad, autocommit=False)

    # Arkivering
    # ###########
    organisation = get_organisation(soknad.organisation_id, request.cookies)
    person = get_person(soknad.person_id, request.cookies)
    save_journalpost_for_klage(soknad, organisation, person, klage.begrunnelse.encode("UTF-8"), u"soknad-%s-klage-%s.txt" % (soknad.id, datetime.now().isoformat()))

    current_app.db_session.commit()
def fatt_vedtak_action_strategy(soknad, action, data):
    vedtak = VedtakUtils.fatt_vedtak(soknad, data)
    if not data.get('saveOnly'):
        vedtak.vedtaksdato = datetime.now()
        soknad.status = action.get_end_state().id

        current_app.logger.debug("Generating vedtaksbrev...")
        rendered_file, file_size, mimetype, filename = VedtaksbrevGeneratorResource.generate_vedtaksbrev(soknad, vedtak)
        current_app.logger.debug("Saving vedtaksbrev to backend...")
        saved_filename, saved_in_dir = save_file_to_disk(rendered_file, filename,
                                                         relative_path=get_rel_vedtaksmappe_path(soknad, vedtak))
        current_app.logger.debug("Updating vedtaket med vedtaksbrev_file_ref=%s..." % saved_filename)
        vedtak.vedtaksbrev_file_ref = saved_filename

        # Arkivering
        # ###########
        organisation = get_organisation(soknad.organisation_id, request.cookies)
        person = get_person(soknad.person_id, request.cookies)
        save_journalpost_for_vedtaksbrev(soknad, organisation, person, vedtak, is_utgaaende_dokument=True)

        SoknadRepo.save(soknad)

        # Sending mail after save to avoid that mail integration errors make it impossible to perform action.
        # It also makes sense to send mail only when we know that the action is successful
        if action == SoknadStateMachine.t_fatt_vedtak:
            send_email_to_soker_on_action_fatt_vedtak(soknad)
        elif action == SoknadStateMachine.t_fatt_klagevedtak:
            send_email_to_soker_on_action_fatt_klagevedtak(soknad)

    else:
        SoknadRepo.save(soknad)
def godkjenn_rapport_action_strategy(soknad, action, data):
    vedtak = soknad.nyeste_fattet_vedtak()
    if vedtak.tilskuddsordning_type == FORSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_avsluttet.id
    elif vedtak.tilskuddsordning_type == ETTERSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_til_utbetaling.id
    SoknadRepo.save(soknad)
def lever_rapport_action_strategy(soknad, action, data):
    rapport = RapportRepo.find_by_where("soknad_id", soknad.id)
    if len(rapport) != 1:
        abort(400, __error__=['Kan ikke finne rapport'])

    errors = rapport[0].validate_rapport_for_levering()
    if errors:
        abort(400, __error__=errors)

    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad, autocommit=False)

    # Arkivering
    # ###########
    organisation = get_organisation(soknad.organisation_id, request.cookies)
    person = get_person(soknad.person_id, request.cookies)

    csv_file_content = ExportRapporterResource().get(soknad_id=soknad.id, rapport_id=rapport[0].id).data

    save_journalpost_for_rapport(soknad, rapport[0], organisation, person, csv_file_content,
                                 u"soknad-%s-rapport-%s-%s.pdf" % (soknad.id, rapport[0].id, datetime.now().isoformat()))

    current_app.db_session.commit()

    # Sending mail after save to avoid that mail integration errors make it impossible to perform action.
    # It also makes sense to send mail only when we know that the action is successful
    send_email_to_soker_on_action_lever_rapport(soknad)
    send_email_to_saksbehandler_on_action_lever_rapport(soknad)
def send_tilbake_til_saksbehandling_strategy(soknad, action, data):
    errors = soknad.validate_soknad_for_innsending()
    if errors:
        abort(400, __error__=errors)

    soknad.status = action.get_end_state().id

    SoknadRepo.save(soknad, autocommit=False)

    # Arkivering
    ############
    organisation = get_organisation(soknad.organisation_id, request.cookies)
    person = get_person(soknad.person_id, request.cookies)

    csv_file_content = ExportSoknaderResource().get(soknad_id=soknad.id).data

    save_journalpost_for_soknad(soknad, organisation, person, csv_file_content,
                                u"soknad-%s-%s.pdf" % (soknad.id, datetime.now().isoformat()))

    current_app.db_session.commit()

    # Sending mail after save to avoid that mail integration errors make it impossible to perform action.
    # It also makes sense to send mail only when we know that the action is successful
    send_email_to_soker_on_action_send_inn(soknad)
    if not soknad.tilskuddsordning.soknadsfrist:
        send_email_to_saksbehandlere_on_action_send_inn(soknad)
def registrer_utbetaling_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])

    validator = BaseValidator(data)
    validator.validate_le_max_length("fakturanr", 15, "tekst/fakturanummer")
    validator.validate_is_defined('utbetaling_dato', 'utbetalingsdato')

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    utbetaling = Utbetaling()
    utbetaling.soknad_id = soknad.id
    utbetaling.tekst = data.get('fakturanr')
    utbetaling.utbetalingsdato = data.get('utbetaling_dato')
    utbetaling.utbetalt_belop = soknad.nyeste_vedtak().vedtatt_belop
    utbetaling.registrertdato = datetime.now()

    soknad.utbetaling.append(utbetaling)

    if soknad.nyeste_fattet_vedtak().tilskuddsordning_type == FORSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_avventer_rapport.id
    else:
        # søknader til tilskuddsordninger med etterskuddsutbetaling eller som ikke krever rapport skal avsluttes
        soknad.status = SoknadStateMachine.s_avsluttet.id
    SoknadRepo.save(soknad)
def trekk_action_strategy(soknad, action, data):
    if data:
        validator = BaseValidator(data)
        validator.validate_le_max_length("trukket_kommentar", 700, "kommentar")
        if validator.has_errors():
            abort(400, __error__=validator.errors)
        soknad.trukket_kommentar = data.get("trukket_kommentar")
    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)
def apne_soknad_for_redigering_action_strategy(soknad, action, data):
    validator = BaseValidator(data)
    validator.validate_le_max_length("merknad", 600, "merknad")

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    soknad.merknad = data.get('merknad')
    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)
def endre_tilskuddsordning_action_strategy(soknad, action, data):
    validator = BaseValidator(data)
    validator.validate_is_defined('tilskuddsordning_id', label="Tilskuddsordning")
    validator.validate_is_defined('saksbehandler_id', label="Saksbehandler")

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    soknad.tilskuddsordning_id = data.get('tilskuddsordning_id')
    soknad.saksbehandler_id = data.get('saksbehandler_id')

    SoknadRepo.save(soknad)
    def post(self):
        data = request.get_json()

        minutes = data.pop('minutes')

        soknader = self.filter_soknader_for_purring(SoknadRepo.find_soknader(soknad_states=[SoknadStateMachine.s_vedtak_fattet.id]), minutes, **data)

        for soknad in soknader:
            if send_email_to_soker_on_soknad_purring(soknad):
                soknad.nyeste_fattet_vedtak().purret_dato = datetime.now()
                SoknadRepo.save(soknad)

        return None, 201
    def create(cls, rapport):
        soknad = SoknadRepo.find_by_id(rapport.soknad_id)
        for arrangement in soknad.arrangement:
            make_transient(arrangement)
            rapport.arrangement.append(cls.copy_model_object(arrangement))

        for okonomipost in soknad.okonomipost:
            make_transient(okonomipost)
            rapport.okonomipost.append(cls.copy_model_object(okonomipost))

        rapport = cls.save(rapport)

        soknad.status = SoknadStateMachine.s_rapport_pabegynt.id
        SoknadRepo.save(soknad)

        return rapport
def sende_inn_action_strategy(soknad, action, data):
    soknad.levert_dato = date.today()

    errors = soknad.validate_soknad_for_innsending()
    if errors:
        abort(400, __error__=errors)

    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)
    # Sending mail after save to avoid that mail integration errors make it impossible to perform action.
    # It also makes sense to send mail only when we know that the action is successful
    send_email_to_soker_on_action_send_inn(soknad)
    send_email_to_organisasjon_on_action_send_inn(soknad)

    if not soknad.tilskuddsordning.soknadsfrist:
        send_email_to_saksbehandlere_on_action_send_inn(soknad)
def godta_vedtak_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])
    vedtak = VedtakUtils.get_vedtak_for_oppdatering(soknad, data.get('vedtak_id'), False)
    if vedtak is None:
        abort(400, __error__=['Kan ikke finne vedtak'])

    if vedtak.vedtatt_belop == 0:
        soknad.status = SoknadStateMachine.s_avsluttet.id
    else:
        if vedtak.tilskuddsordning_type == ETTERSKUDDSUTBETALING:
            soknad.status = SoknadStateMachine.s_avventer_rapport.id
        else:
            # søknader til tilskuddsordninger med forskuddsutbetaling og som krever ikke rapport skal gå direkte til utbetaling
            soknad.status = SoknadStateMachine.s_til_utbetaling.id

    SoknadRepo.save(soknad)
def til_vedtak_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])
    vedtak = VedtakUtils.get_vedtak_for_oppdatering(soknad, data.get('vedtak_id'))
    if vedtak is None:
        vedtak = Vedtak()
        soknad.vedtak.append(vedtak)

    validator = BaseValidator(data)
    validator.validate_le_max_length("intern_merknad", 600, "merknad")
    validator.validate_le_max_length("vedtakstekst", 1000, "vedtakstekst")
    validator.validate_le_max_length("andre_opplysninger", 1000, "andre_opplysninger")
    validator.validate_is_positive_integer("innstilt_belop", "innstilt beløp", requires_value=True)
    validator.validate_is_defined("tilskuddsordning_type", label="Rapport og utbetaling")

    if not data.get('saveOnly'):
        validator.validate_is_defined("vedtakstekst")
        innstilt_belop = data.get('innstilt_belop')
        if isinstance(innstilt_belop, basestring) and innstilt_belop.isdigit():
            innstilt_belop = int(innstilt_belop)
        if data.get('tilskuddsordning_type') != KREVER_IKKE_RAPPORT and not innstilt_belop == 0:
            validator.validate_is_defined("rapportfrist")
        soknad.status = action.get_end_state().id

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    BaseRepo.update_model(vedtak, 'innstilt_belop', data)
    BaseRepo.update_model(vedtak, 'intern_merknad', data)
    BaseRepo.update_model(vedtak, 'tilskuddsordning_type', data)

    if data.get('behandlet_av_formannskapet'):
        BaseRepo.update_model(vedtak, 'behandlet_av_formannskapet', data)

    if vedtak.tilskuddsordning_type == KREVER_IKKE_RAPPORT:
        vedtak.rapportfrist = None
    else:
        BaseRepo.update_model(vedtak, 'rapportfrist', data)

    BaseRepo.update_model(vedtak, 'vedtakstekst', data)
    BaseRepo.update_model(vedtak, 'andre_opplysninger', data)

    # setter vedtatt belop slik at det blir default verdi for godkjenner (han kan overstyre den)
    vedtak.vedtatt_belop = vedtak.innstilt_belop

    SoknadRepo.save(soknad)
def behandle_action_strategy(soknad, action, data):
    if not data or not data.get("saksbehandler"):
        abort(400, __error__={'saksbehandler': u'Saksbehandler må være satt'})
    soknad.saksbehandler_id = data.get("saksbehandler")
    soknad.status = action.get_end_state().id

    SoknadRepo.save(soknad, autocommit=False)

    # Arkivering
    # ###########
    organisation = get_organisation(soknad.organisation_id, request.cookies)
    person = get_person(soknad.person_id, request.cookies)

    csv_file_content = ExportSoknaderResource().get(soknad_id=soknad.id).data

    save_sak(soknad)
    save_journalpost_for_soknad(soknad, organisation, person, csv_file_content, u"soknad-%s-%s.pdf" % (soknad.id, datetime.now().isoformat()))

    current_app.db_session.commit()
def endre_kontakt_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])

    validator = BaseValidator(data)
    validator.validate_is_defined('person_id', label="Kontaktperson")
    validator.validate_is_norwegian_phone_number("telefon", label="Telefonnummer")
    validator.validate_is_email('epost', label='Epost')

    person_id = data.get('person_id', None)
    if person_id is not None and not is_person_member_of_organisation(soknad.organisation_id, person_id):
        validator.add_error('person_id', 'Ugyldig person')

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    soknad.person_id = person_id
    soknad.epost = data.get('epost')
    soknad.telefon = data.get('telefon')

    SoknadRepo.save(soknad)
def avskriv_rapportkrav_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])

    if soknad.status in (SoknadStateMachine.s_rapport_pabegynt.id, SoknadStateMachine.s_avventer_rapport.id):
        soknad.rapport = []

    validator = BaseValidator(data)
    validator.validate_is_defined("avskrevet_rapportkrav_kommentar", 'Årsak')
    validator.validate_le_max_length("avskrevet_rapportkrav_kommentar", 700, 'Årsak')
    if validator.has_errors():
        abort(400, __error__=validator.errors)

    soknad.avskrevet_rapportkrav_kommentar = data.get("avskrevet_rapportkrav_kommentar")

    vedtak = soknad.nyeste_fattet_vedtak()
    if vedtak.tilskuddsordning_type == FORSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_avsluttet.id
    elif vedtak.tilskuddsordning_type == ETTERSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_til_utbetaling.id
    SoknadRepo.save(soknad)
def rediger_rapportfrist_action_strategy(soknad, action, data):
    if data is None:
        abort(400, __error__=['Data mangler'])
    vedtak = VedtakUtils.get_vedtak_for_oppdatering(soknad, data.get('vedtak_id'), False)
    if vedtak is None:
        abort(400, __error__=['Kan ikke finne vedtak'])

    validator = BaseValidator(data)
    validator.validate_le_max_length("endre_rapportfrist_arsak", 150, "aarsak til rapportfrist")
    validator.validate_is_defined("rapportfrist")

    BaseRepo.update_model(vedtak, 'endre_rapportfrist_arsak', data)
    BaseRepo.update_model(vedtak, 'rapportfrist', data)

    if validator.has_errors():
        abort(400, __error__=validator.errors)

    # dersom rapport er levert, settes den tilbake til påbegynt
    if soknad.status == SoknadStateMachine.s_rapport_levert.id:
        soknad.status = action.get_end_state().id

    SoknadRepo.save(soknad)
def underkjenn_rapport_action_strategy(soknad, action, data):
    rapport = RapportRepo.find_by_where("soknad_id", soknad.id)
    if len(rapport) != 1:
        abort(400, __error__=['Kan ikke finne rapport'])

    if data:
        validator = BaseValidator(data)
        validator.validate_le_max_length("saksbehandler_kommentar", 300)
        if validator.has_errors():
            abort(400, __error__=validator.errors)

        rapport[0].saksbehandler_kommentar = data.get("saksbehandler_kommentar")

        RapportRepo.save(rapport[0])
        # Sending mail after save to avoid that mail integration errors make it impossibv to perform action.
        # It also makes sense to send mail only when we know that the action is successful
        send_email_to_soker_on_action_underkjenn(soknad, data.get("saksbehandler_kommentar"))

    vedtak = soknad.nyeste_fattet_vedtak()
    if vedtak.tilskuddsordning_type == FORSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_tilbakebetaling_kreves.id
    elif vedtak.tilskuddsordning_type == ETTERSKUDDSUTBETALING:
        soknad.status = SoknadStateMachine.s_trukket.id
    SoknadRepo.save(soknad)
def endre_saksbehandler_action_strategy(soknad, action, data):
    if not data or not data.get("saksbehandler"):
        abort(400, __error__={'saksbehandler': u'Saksbehandler må være satt'})
    soknad.saksbehandler_id = data.get("saksbehandler")

    SoknadRepo.save(soknad)
def default_action_strategy(soknad, action, data):
    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)
def tilbake_til_innstilling_action_strategy(soknad, action, data):
    VedtakUtils.tilbake_til_innstilling(soknad, data)
    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)
def tilbake_til_vurder_klage_action_strategy(soknad, action, data):
    VedtakUtils.fatt_vedtak(soknad, data)
    soknad.status = action.get_end_state().id
    SoknadRepo.save(soknad)