Esempio n. 1
0
def send_email_to_applicant(application):

    person_data = get_person_from_web(application.person.uri)
    resource_data = get_resource_from_web(application.resource.uri)

    person_email = person_data.get('email_address')
    resource_name = resource_data.get('name', None)

    message = None
    topic = None

    if application.type == 'single':
        topic = u'Søknad om engangslån'
        message = render_template(
            'email_application_created.txt',
            resource_name=resource_name
        )

    if application.type == 'repeating':
        topic = u'Søknad om fast lån'
        message = render_template(
            'email_application_created.txt',
            resource_name=resource_name
        )

    if not person_email or not topic or not message:
        return

    send_email_task.delay(
        topic,
        u'*****@*****.**',
        [person_email],
        message
    )
Esempio n. 2
0
def send_email_to_resource(application):

    person_data = get_person_from_web(application.person.uri)
    resource_data = get_resource_from_web(application.resource.uri)

    person_name = get_person_name(person_data)
    resource_name = resource_data.get('name', None)
    slots = generate_slots(application)

    unit_email = resource_data.get('unit_email_address', None)
    unit_name = resource_data.get('unit_name', 'Ukjent enhet')
    org_name = get_organisation_name(application)

    if application.type == 'strotime':
        to_email = unit_email
        topic = u'Strøtime tildelt'
        message = render_template(
            'email_strotime_granted_unit.txt',
            resource_name=resource_name,
            unit_name=unit_name,
            person_name=person_name,
            slots=slots
        )

    message = None
    topic = None
    to_email = None
    if application.type == 'single':
        to_email = unit_email
        topic = u'Søknad om engangslån for %s' % unit_name
        message = render_template(
            'email_single_applied_unit.txt',
            resource_name=resource_name,
            unit_name=unit_name,
            person_name=person_name,
            slots=slots,
            organisation_name=org_name
        )

    if application.type == 'repeating':
        to_email = TK_EMAIL
        topic = u'Søknad om fast lån for %s' % unit_name
        message = render_template(
            'email_repeating_applied_unit.txt',
            resource_name=resource_name,
            unit_name=unit_name,
            person_name=person_name,
            slots=slots,
            organisation_name=org_name
        )

    if not to_email or not topic or not message:
        return

    send_email_task.delay(
        topic,
        u'*****@*****.**',
        [to_email],
        message
    )
def send_email_strotime_granted(application):
    personJSON = get_person_from_web(application.person.uri)
    resourceJSON = get_resource_from_web(application.resource.uri)
    person_name = ""
    if personJSON["first_name"] and personJSON["last_name"]:
        person_name = personJSON["first_name"] + " " + personJSON["last_name"]
    if personJSON["email_address"]:
        application_status = format_application_status_for_email(application.status)

        resource_name = ""
        if resourceJSON["name"]:
            resource_name = resourceJSON["name"]

        slots = []
        for slot in application.slots:
            slots.append(format_slot_for_email(slot))
        message = render_template(
            "email_strotime_granted.txt",
            resource_name=resource_name,
            application_status=application_status,
            slots=slots,
            person_name=person_name,
        )
        resource_email = personJSON["email_address"]
        if message is not None and resource_email is not None:
            send_email_task.delay(u"Strøtime tildelt", u"*****@*****.**", [resource_email], message)
def render_email_template(application, status=None):
    resource_details = get_resource_from_web(application.resource.uri)
    requested_resource_details = get_resource_from_web(
        application.requested_resource.uri)
    org_name = None
    org_email = None
    org_local_email = None
    if application.organisation is not None:
        org_details = get_organisation_from_web(application.organisation.uri)
        org_name = org_details.get('name')
        org_email = org_details.get('email_address', None)
        org_local_email = org_details.get('local_email_address', None)

    email_address = None
    if application.person is not None:
        person_details = get_person_from_web(application.person.uri)
        email_address = person_details.get("email_address", None)

    resource_name = resource_details['name']
    requested_resource_name = requested_resource_details['name']
    application_time = application.application_time.strftime("%Y.%m.%d %H:%M")

    # Override status if given, used for previewing template
    if status is not None:
        application_status = format_application_status_for_email(status)
    else:
        application_status = format_application_status_for_email(
            application.status)

    application_type = application.get_type()
    requested_slots = format_slots_for_email(application.requested_slots,
                                             application_type)
    slots = format_slots_for_email(application.slots, application_type)

    requested_period = get_period_from_slots(application.requested_slots, application_type)
    period = get_period_from_slots(application.slots, application_type)

    changed_period = not is_period_equal(period, requested_period)
    changed_time = not is_slots_equal(slots, requested_slots) or changed_period;

    resource_documents = resource_details.get("documents", [])

    message = render_template("email_applications_processed.txt",
                              org_name=org_name,
                              resource_name=resource_name,
                              requested_resource_name=requested_resource_name,
                              application_time=application_time,
                              message=application.message,
                              application_status=application_status,
                              resource_documents=resource_documents,
                              slots=slots,
                              requested_slots=requested_slots,
                              changed_period=changed_period,
                              changed_time=changed_time,
                              period=period,
                              requested_period=requested_period)

    return [email_address, org_email, org_local_email], message
def filter_applications(applications, cookies):
    """Filter applications based on user roles"""

    is_superuser = verify_superuser_auth_token(
        request.cookies.get('auth_token'))
    if is_superuser:
        # No filter for superuser
        return applications

    user = get_user(request.cookies)
    if user is None:
        abort(401)

    if has_role(user, 'flod_saksbehandlere'):
        # No filter for flod_saksbehandlere
        return applications

    if has_role(user, 'flod_brukere'):
        # Administratosr should only see applications for resources they own
        remote_resource_ids = [c['resource_id']
                               for c in user.get('credentials', [])
                               if c['id'].startswith('CAN_EDIT_FACILITY_')]

        # Need to map the ids in the credentials which uses remote ids
        # to the local ones used in booking.
        uris = ["/facilities/%s" % i for i in remote_resource_ids]
        res = current_app.db_session.query(Resource).filter(Resource.uri.in_(uris)).all()
        local_resource_ids = [r.id for r in res]

        applications = applications.filter(
            Application.resource_id.in_(local_resource_ids)
        )
    else:
        # External users should only see their own applications and the applications belonging to their organisations
        org_ids = []
        orgs = get_person_from_web('/persons/%s/organisations/' % user['person_id'])
        org_uris = [org.get('uri') for org in orgs]
        if len(org_uris) > 0:
            res = current_app.db_session.query(Organisation).filter(Organisation.uri.in_(org_uris)).all()
            org_ids = [o.id for o in res]

        person_uri = '/persons/{}'.format(user['person_id'])

        if len(org_ids) == 0:
            applications = applications.filter(
                Application.person.has(uri=person_uri)
            )
        else:
            applications = applications.filter(
                or_(
                    Application.person.has(uri=person_uri),
                    Application.organisation_id.in_(org_ids)
                )
            )

    return applications
 def get_applicant(self, slot):
     application = slot['application']
     if application.organisation is not None:
         org = get_organisation_from_web(application.organisation.uri)
         return (org.get('name'), org.get('email_address'))
     if application.person is not None:
         person = get_person_from_web(application.person.uri)
         name = u'{}, {}'.format(person.get('last_name', ''),
                                 person.get('first_name', ''))
         return (name, person.get('email_address'))
     return None
Esempio n. 7
0
def is_organisation_member(organisation_id, user):
    if not is_idporten_user(user):
        return False

    if organisation_id:
        org_ids = []
        orgs = get_person_from_web('/persons/%s/organisations/' % user['person_id'])
        org_uris = [org.get('uri') for org in orgs]
        if len(org_uris) > 0:
            res = current_app.db_session.query(Organisation).filter(Organisation.uri.in_(org_uris)).all()
            org_ids = [o.id for o in res]

        return organisation_id in org_ids

    return False
def get_display_name(application):

    if application.organisation:
        try:
            org = get_organisation_from_web(application.organisation.uri)
            return org.get('name')
        except werkzeug.exceptions.NotFound:
            return u'Ad-hoc aktør'


    user = get_user(request.cookies)
    show_person = user is not None and has_role(user, 'flod_saksbehandlere')
    if show_person:
        person = get_person_from_web(application.person.uri)
        return '%s, %s' % (person.get('last_name', ''), person.get('first_name', ''))
    return "Privatperson"
    def send_email_to_affected_applications(self, arrangement,
                                            affected_applications,
                                            message):
        arrangement_slots = []
        for arrangement_slot in arrangement.slots:
            arrangement_slots.append(format_slot_for_email(arrangement_slot))

        for affected_application in affected_applications:
            if affected_application.slots:
                resource_details = get_resource_from_web(affected_application.resource.uri)
                resource_name = resource_details['name']

                person_details = get_person_from_web(affected_application.person.uri)
                email_address = person_details['email_address']

                org_name = None
                if affected_application.organisation is not None:
                    org_details = get_organisation_from_web(affected_application.organisation.uri)
                    org_name = org_details.get('name')

                application_time = affected_application.application_time.strftime("%Y.%m.%d %H:%M:00")

                slots = []
                # Just create human readable text out of slots
                for slot in affected_application.slots:
                    if affected_application.get_type() == "repeating":
                        slots.append(format_repeating_slot_for_email(slot))
                    else:
                        slots.append(format_slot_for_email(slot))

                msg = render_template("email_arrangement_notification.txt",
                                      org_name=org_name,
                                      resource_name=resource_name,
                                      application_time=application_time,
                                      slots=slots,
                                      arrangement_slots=arrangement_slots,
                                      message=message)

                if email_address and msg is not None:
                    send_email_task.delay(u'Arrangement',
                                          u'*****@*****.**',
                                          [email_address],
                                           msg)
 def post(self):
     data = request.get_json()        
     start_time = data["start_time"]
     end_time = data["end_time"]             
     if start_time is None or end_time is None:
         abort(400)
     strotime_slots = self.get_strotime_slots(start_time, end_time)
     result = []
     for strotime_slot in strotime_slots:            
         personJSON = get_person_from_web(strotime_slot.application.person.uri)                                            
         resourceJSON = get_resource_from_web(strotime_slot.application.resource.uri)                                    
         result.append({             
             'id': strotime_slot.id,
             'start_time': strotime_slot.start_time,
             'end_time': strotime_slot.end_time,                
             'application_id': strotime_slot.application.id,
             'resource_name': resourceJSON['name'],
             'email_address': personJSON['email_address'],
             'person_name': personJSON['first_name'] + " " + personJSON['last_name']
         })
     return result, 201
def create_ws_journalpost(application, resource, document, ws_sak):
    person = get_person_from_web(application.person.uri)
    organisation = get_organisation_from_web(application.organisation.uri)

    adressat = WSAdressat(fornavn=person['first_name'] or '',
                          etternavn=person['last_name'] or '',
                          adresse1=person['address_line'] or '',
                          adresse2='',
                          postnr=person['postal_code'] or '',
                          sted=person['postal_city'] or '',
                          foedselsnr=person['national_identity_number'] or '',
                          orgnr=organisation['org_number'] or '')

    dok_tittel = u'Søknad godkjent: {} for lokale {}'.format(
        organisation['name'], resource['name'])
    dokument = WSDokument(dokument_tittel=dok_tittel,
                          fil_innhold=b64encode(document.encode('utf-8')))
    tittel2 = u' '.join((adressat.fornavn, adressat.etternavn))

    return WSJournalpost(adressat1=adressat,
                         saksbehandler=ws_sak['Saksansvarlig'],
                         tittel1=ws_sak['Tittel1'],
                         tittel2=tittel2,
                         dokument=dokument)
    def put(self, application_id):
        data = request.get_json()

        application = self.get_object_by_id(application_id)
        ensure(PUT, application)

        status = data.get("status", None)
        resource_uri = data["resource"]["uri"]
        application_message = data.get("message", "")
        to_be_invoiced = data.get("to_be_invoiced", None)
        invoice_amount = data.get("invoice_amount") or None
        if invoice_amount is not None and type(invoice_amount) is not int \
                and not invoice_amount.isdigit():
            abort(400, __error__=[u'Fakturabeløp må være heltall'])
        resource = get_resource_for_uri(resource_uri)
        if not resource:
            abort(404)
        resource_details = get_resource_from_web(application.resource.uri)
        if not resource_details:
            abort(404)

        settings = SettingsResource().get()

        user = get_user(request.cookies)

        # Check that the resource allows the type of application
        if application.get_type() == "single" and not resource.single_booking_allowed:
            abort(403, __error__=[u'Det er ikke mulig å behandle en søknad om engangslån fordi type utlån er deaktivert for lokalet'])

        if application.get_type() == "repeating" and (not resource.repeating_booking_allowed or \
                                                              (resource.repeating_booking_allowed and not settings["repeating_booking_allowed"] and not has_role(user,
                                                                                                                                                                 'flod_saksbehandlere'))):
            abort(403, __error__=[u'Det er ikke mulig å behandle en søknad om fast lån fordi type utlån er deaktivert for lokalet'])

        # The application might have been moved to a different resource.
        application.resource = resource
        if status == "Pending":
            application.amenities = application.requested_amenities
            application.accessibility = application.requested_accessibility
            application.equipment = application.requested_equipment
            application.suitability = application.requested_suitability
            application.facilitators = application.requested_facilitators
        else:
            application.amenities = data.get('amenities')
            application.accessibility = data.get('accessibility')
            application.equipment = data.get('equipment')
            application.suitability = data.get('suitability')
            application.facilitators = data.get('facilitators')

        slot_data = data.get("slots", None)
        if status == "Granted" and not slot_data:
            abort(403, __error__=[u'Tildelt tid mangler'])

        if application.get_type() == "single":
            slots = [parse_single_slot(slot, application) for slot in slot_data]
            application.single_slots = slots
        elif application.get_type() == "repeating":
            slots = [parse_repeating_slot(slot, application) for slot in slot_data]
            application.repeating_slots = slots

        # Check if there are any conflicts
        for slot in slots:
            if application.get_type() == "single":
                start_date = slot.start_time.date()
                end_date = slot.end_time.date()
                week_day = slot.start_time.isoweekday()
                start_time = slot.start_time.time()
                end_time = slot.end_time.time()
            elif application.get_type() == "repeating":
                start_date = slot.start_date
                end_date = slot.end_date
                week_day = slot.week_day
                start_time = slot.start_time
                end_time = slot.end_time

            if application.get_type() == "single":
                self.validate_end_date_of_slot(settings["single_booking_enddate"], end_date.isoformat(), u'engangslån')
            elif application.get_type() == "repeating":
                self.validate_end_date_of_slot(settings["repeating_booking_enddate"], end_date.isoformat(), u'fast lån')

            self.validate_start_and_end_times(start_date, end_date, start_time, end_time)
            if application.is_arrangement or status == "Denied":
                # NOTE: Arrangements trumph all other applications. If we reject an application, we dont nede to
                # check if the time is available...
                pass
            else:
                if self.is_conflict_slot_time(resource, start_date, end_date, week_day, start_time, end_time) or \
                        self.is_conflict_rammetid(resource, start_date, end_date, week_day, start_time, end_time):
                    abort(
                        400,
                        __error__=[u'Tiden du har søkt på er ikke tilgjengelig']
                    )

            if status != "Denied":
                if self.is_conflict_blocked_time(resource, start_date, end_date, week_day, start_time, end_time):
                    abort(
                        400,
                        __error__=[u'Tiden du har søkt på er blokkert']
                    )

        if status == "Granted" or status == "Denied" or (status == "Pending" and len(slots) == 0):
            application.status = status
        else:
            application.status = "Processing"

        application.message = application_message
        application.invoice_amount = invoice_amount
        application.to_be_invoiced = to_be_invoiced
        application.comment = data.get('comment')

        current_app.db_session.add(application)
        current_app.db_session.commit()
        current_app.db_session.refresh(application)

        document = ''
        if status == "Granted" or status == "Denied":
            document = send_email_application_processed(application)

        # Create erv code
        if invoice_amount is not None and status == "Granted":
            invoice_amount = int(invoice_amount)
            org_number = None
            if application.organisation is not None:
                organisation = get_organisation_from_web(
                    application.organisation.uri)
                org_number = organisation.get('org_number', None)

            if org_number is None:
                person = get_person_from_web(application.person.uri)
                erv_code = erv_person(application, invoice_amount,
                                      person['national_identity_number'])
            else:
                erv_code = erv_organisation(application, invoice_amount,
                                            org_number)

            print 'erv: "{}"'.format(erv_code)
            # Skip sending mail for now
            # send_erv_code_mail("{},".format(erv_code))

        application_dict = {}
        if application.get_type() == "single":
            application_dict = marshal(application, single_application_fields)
        elif application.get_type() == "repeating":
            # Authentication is not implemented for all resources yet, so we
            # skip creating sak/journalpost if no auth_token exists
            if status == 'Granted' and 'auth_token' in request.cookies:
                arkiver(application, document)

            application_dict = marshal(application, repeating_application_fields)

        # Include emails in response, if requested
        if data.get("include_emails", False):
            _, granted_message = render_email_template(application, "Granted")
            _, denied_message = render_email_template(application, "Denied")
            application_dict['emails'] = dict(
                granted_message=granted_message,
                denied_message=denied_message
            )

        return application_dict