Merge pull request #157 from INRIM/t_1332

[UPD] updated controllo_accessi_portale portal

Author: archetipo

controllo_accessi_portale/__manifest__.py

@@ -13,6 +13,8 @@
     'data': [
         'security/security.xml',
         'views/partner_portals_views.xml',
+        'views/badge_return_views.xml',
+        'views/badge_release_views.xml',
     ],
      'assets': {
         'web.assets_frontend': [

controllo_accessi_portale/controllers/__init__.py

@@ -1,2 +1,5 @@
-from . import portal
-from . import main
+from . import home
+from . import anagrafiche
+from . import badge_docs
+from . import badge_return
+from . import badge_release

controllo_accessi_portale/controllers/anagrafiche.py

@@ -0,0 +1,105 @@
+import datetime
+from typing import Dict
+from pytz import UTC
+
+from odoo import http
+from odoo.http import request
+from odoo.osv import expression
+from odoo.tools.misc import format_datetime
+from werkzeug.exceptions import Forbidden, NotFound
+
+from .common import check_access_permission
+
+
+class PortalAnagrafiche(http.Controller):
+
+    @http.route('/anagrafiche', type='http', auth='user', website=True)
+    def anagrafiche(self, **kwargs):
+        user = request.env.user
+        if not user.has_group('controllo_accessi_portale.inrim_access_portal'):
+            raise NotFound()
+        return request.render('controllo_accessi_portale.portal_partner_view', {})
+
+    @http.route('/get/anagrafiche', type='json', auth='user', website=True, csrf=False)
+    def get_anagrafiche(self, limit: int, offset: int, query: str, filter: Dict, **kwargs):
+        user = request.env.user
+        today_at_00 = datetime.datetime.combine(datetime.date.today(), datetime.time.min).astimezone(UTC).replace(tzinfo=None)
+        if not user.has_group('controllo_accessi_portale.inrim_access_portal'):
+            raise Forbidden()
+        search_domain = [("ca_tag_ids", "!=", False), ("last_access", ">=", today_at_00)]
+        if query:
+            search_domain = expression.AND([[("display_name", "ilike", query)], search_domain])
+        if filter:
+            if filter.get("internal"):
+                search_domain = expression.AND([[("is_internal", "=", True)], search_domain])
+            elif filter.get("external"):
+                search_domain = expression.AND([[("is_external", "=", True)], search_domain])
+            if filter.get("is_present"):
+                search_domain = expression.AND([[("present", "=", "yes")], search_domain])
+            if filter.get("pa_category_id"):
+                search_domain = expression.AND([[("person_access_ids.ca_punto_accesso_category_id", "=", filter["pa_category_id"])], search_domain])
+        records = request.env['ca.persona'].search(search_domain, limit=limit, offset=offset)
+        count = request.env['ca.persona'].search_count(search_domain)
+        access_map = {}
+        if records:
+            person_ids = records.ids
+            access_domain = [
+                ('ca_persona_id', 'in', person_ids),
+                ('ca_punto_accesso_category_id', '!=', False),
+                ('typology', '=', 'stamping')
+            ]
+            if filter and filter.get("pa_category_id"):
+                access_domain = expression.AND([[("ca_punto_accesso_category_id", "=", filter["pa_category_id"])], access_domain])
+            all_accesses = request.env['ca.anag_registro_accesso'].search_read(
+                access_domain,
+                fields=['ca_persona_id', 'datetime_event', 'direction', 'ca_punto_accesso_category_id'],
+                order='datetime_event desc, id desc'
+            )
+            for acc in all_accesses:
+                p_id = acc['ca_persona_id'][0]
+                if p_id not in access_map:
+                    access_map[p_id] = acc
+        data = {"items": [], "total": count}
+        AccessModel = request.env['ca.anag_registro_accesso']
+        direction_selection = dict(AccessModel.fields_get(['direction'])['direction']['selection'])
+        cat_ids = set()
+        for acc in access_map.values():
+            if acc['ca_punto_accesso_category_id']:
+                cat_ids.add(acc['ca_punto_accesso_category_id'][0])
+        cat_names = {}
+        if cat_ids:
+            cats = request.env['ca.punto_accesso_category'].browse(cat_ids)
+            for c in cats:
+                cat_names[c.id] = c.display_name
+        present_labels = dict(request.env['ca.persona'].fields_get(['present'])['present']['selection'])
+        for record in records:
+            row = {
+                'id': record.id, 
+                'display_name': record.display_name, 
+                'fiscalcode': record.fiscalcode,
+                'is_external': record.is_external, 
+                'is_internal': record.is_internal,
+                'present': (record.present, present_labels.get(record.present)),
+                'datetime_event': '', 
+                'last_reading_event': '', 
+                'event_direction': '', 
+                'event_punto_accesso': ''
+            }
+            last_access = access_map.get(record.id)
+            if last_access:
+                if last_access['datetime_event']:
+                    row['datetime_event'] = format_datetime(request.env, last_access['datetime_event'], tz=user.tz, lang_code=user.lang)
+                raw_dir = last_access['direction']
+                row['event_direction'] = direction_selection.get(raw_dir, raw_dir)
+                cat_tuple = last_access['ca_punto_accesso_category_id']
+                if cat_tuple:
+                    row['event_punto_accesso'] = cat_names.get(cat_tuple[0], cat_tuple[1])
+            data["items"].append(row)
+        return data
+
+    @http.route('/get/anagrafiche/ca_punto_accesso_category', type='json', auth='user', website=True, csrf=False)
+    def anagrafiche_pa_category(self, **kwargs):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise NotFound()
+        return request.env['ca.punto_accesso_category'].search([("ca_access_point_ids", "!=", False)]).read()

controllo_accessi_portale/controllers/badge_docs.py

@@ -0,0 +1,45 @@
+from odoo import http, _
+from odoo.http import request
+from werkzeug.exceptions import Forbidden, NotFound
+from .common import check_access_permission
+
+
+class PortalBadgeDocs(http.Controller):
+
+    @http.route('/badge_release_docs/<int:persona_id>', auth='user', type='http', website=True)
+    def badge_release_docs_form(self, persona_id, **post):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise NotFound()
+
+        persona_obj = request.env['ca.persona'].browse(persona_id)
+        if not persona_obj.exists():
+            raise NotFound()
+
+        if post and request.httprequest.method == 'POST':
+            return self._handle_docs_post(persona_obj, post)
+
+        return request.render('controllo_accessi_portale.badge_release_docs_view', {
+            "persona_id": persona_obj.id, "errors": {}, "error_message": "", "values": {}
+        })
+
+    @http.route('/get/badge_release_docs/tipo_documento', auth='user', type='json', website=True, csrf=False)
+    def badge_release_tipo_documento(self, **kwargs):
+        if not check_access_permission(request.env.user): raise Forbidden()
+        return request.env['ca.tipo_doc_ident'].search([]).read()
+
+    def _handle_docs_post(self, persona_obj, post):
+        req_fields = ["tipo_documento_id", "validity_start_date", "validity_end_date", "document_code", "issued_by"]
+        errors = {f: 'missing' for f in req_fields if not post.get(f)}
+        
+        values = {f: post.get(f) for f in req_fields}
+        values['persona_id'] = persona_obj.id
+        if values.get('tipo_documento_id'): values['tipo_documento_id'] = int(values['tipo_documento_id'])
+
+        if errors:
+            return request.render('controllo_accessi_portale.badge_release_docs_view', {
+                "persona_id": persona_obj.id, "errors": errors, "error_message": _('Some required fields are empty.'), "values": values
+            })
+
+        request.env['ca.registra_doc_persona'].create(values).action_confirm()
+        return request.redirect('/anagrafiche')

controllo_accessi_portale/controllers/badge_release.py

@@ -0,0 +1,130 @@
+import datetime
+from pytz import UTC
+from odoo import http, _
+from odoo.http import request
+from werkzeug.exceptions import Forbidden, NotFound
+from .common import check_access_permission
+
+
+class PortalBadgeRelease(http.Controller):
+    
+    @http.route('/badge_release', auth='user', type='http', website=True)
+    def badge_release_form(self, **post):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise NotFound()
+
+        if post and request.httprequest.method == 'POST':
+            return self._handle_badge_release_post(post)
+
+        vals = {k: v for k, v in post.items()} if post else {}
+
+        return request.render('controllo_accessi_portale.badge_release_view', {
+            "errors": {}, "error_message": "", "values": vals
+        })
+
+    @http.route('/badge_release/submit', auth='user', type='http', website=True, methods=['POST'], csrf=False)
+    def badge_release_submit(self, **kwargs):
+        return self._handle_badge_release_post(kwargs)
+
+    def _handle_badge_release_post(self, post):
+        vals = {
+            'vat': post['vat'], 'ca_ente_name': post['ca_ente_name'], 'fiscalcode': post['fiscalcode'],
+            'lastname': post['lastname'], 'name': post['name'], 'freshman': post['freshman'],
+            'email': post['email'], 'mobile': post['mobile'], 'ref_domain': post.get('ref_domain'),
+        }
+        
+        if post.get('date_start'):
+            vals['date_start'] = datetime.datetime.fromisoformat(post['date_start']).astimezone(UTC).replace(tzinfo=None)
+        if post.get('date_end'):
+            vals['date_end'] = datetime.datetime.fromisoformat(post['date_end']).astimezone(UTC).replace(tzinfo=None)
+
+        for key in ['persona_id', 'tipo_ente_azienda_id', 'azienda', 'ca_work_info_type_id', 'ca_title_id', 'ca_tag_id', 'parent_id']:
+            if post.get(key) and post[key] != "":
+                clean_key = 'ente_azienda' if key == 'azienda' else key
+                vals[clean_key] = int(post[key])
+
+        REQ_FIELDS = ["lastname", "name", "fiscalcode", "tipo_ente_azienda_id", "ca_ente_name", 
+                      "ca_work_info_type_id", "ca_title_id", "date_start", "date_end", "ca_tag_id"]
+        
+        is_internal = False
+        if vals.get('persona_id'):
+            p = request.env['ca.persona'].browse(vals['persona_id'])
+            if p.exists() and p.is_internal: is_internal = True
+        
+        if not is_internal:
+            REQ_FIELDS.extend(["ref_domain", "parent_id"])
+
+        errors = {f: 'missing' for f in REQ_FIELDS if not post.get(f)}
+        if errors:
+            return request.render('controllo_accessi_portale.badge_release_view', {
+                "errors": errors, "error_message": _('Some required fields are empty.'), "values": post
+            })
+
+        add_doc = not vals.get("persona_id")
+        wiz = request.env['ca.registra_persona'].with_context(no_compute_tag_id_number=True).create(vals)
+        wiz.action_confirm()
+        if add_doc:
+            return request.redirect(f"/badge_release_docs/{wiz.persona_id.id}")
+        return request.redirect('/anagrafiche')
+
+    @http.route('/get/badge_release/init_data', auth='user', type='json', website=True)
+    def get_badge_release_init_data(self, **kwargs):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise Forbidden()
+        
+        Env = request.env
+        
+        tags = Env['ca.tag'].search_read(
+            [('in_use', '=', False), ('revoked', '=', False)],
+            fields=['id', 'name', 'display_name', 'tag_code', 'temp', 'ca_proprieta_tag_ids']
+        )
+
+        tag_domains = {
+            'visitor': [Env.ref('inrim_anagrafiche.proprieta_tag_visitatore').id, Env.ref('inrim_anagrafiche.proprieta_tag_servizio').id],
+            'internal': [Env.ref('inrim_anagrafiche.proprieta_tag_jolly').id, Env.ref('inrim_anagrafiche.proprieta_tag_definitivo').id],
+            'temp': [Env.ref('inrim_anagrafiche.proprieta_tag_jolly').id]
+        }
+        
+        work_infos = Env['ca.work_info'].search_read(
+            [('state', '=', 'active')],
+            fields=['ca_persona_id', 'date_start', 'date_end', 'ca_work_info_type_id', 'ca_title_id']
+        )
+
+        ids_hidden = [
+            Env.ref('inrim_anagrafiche.tipo_ente_azienda_sede').id,
+            Env.ref('inrim_anagrafiche.tipo_ente_azienda_sede_distaccata').id
+        ]
+        
+        tipo_enti_hidden = Env['ca.tipo_ente_azienda'].search_read([('id', 'in', ids_hidden)], ['id', 'display_name'])
+        
+        tipo_enti = Env['ca.tipo_ente_azienda'].search_read(
+            [('id', 'not in', ids_hidden)], 
+            ['id', 'name', 'display_name']
+        )
+
+        return {
+            'tags': tags,
+            'tag_domains': tag_domains,
+            'work_infos': work_infos,
+            'titoli': Env['ca.titolo_persona'].search_read([], ['id', 'name', 'display_name', 'structured']),
+            'work_info_types': Env['ca.work_info_type'].search_read([], ['id', 'name', 'display_name']),
+            'enti_aziende': Env['ca.ente_azienda'].search_read([], ['id', 'name', 'display_name', 'vat', 'tipo_ente_azienda_id']),
+            'tipo_enti_hidden_ids': [t['id'] for t in tipo_enti_hidden],
+            'tipo_enti': tipo_enti,
+            'persona_parent': Env['ca.persona'].search_read([('is_internal', '=', True)], ['id', 'display_name', 'present'])
+        }
+
+    @http.route('/get/badge_release/ca_persona', auth='user', type='json', website=True)
+    def badge_release_ca_persona(self, **kwargs):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise Forbidden()
+            
+        fields = [
+            'id', 'display_name', 'name', 'lastname', 'fiscalcode', 'email', 'mobile', 
+            'is_internal', 'freshman', 'ca_ente_azienda_ids', 'current_tag', 
+            'present'
+        ]
+        return request.env['ca.persona'].search_read([], fields=fields)

controllo_accessi_portale/controllers/badge_return.py

@@ -0,0 +1,44 @@
+from odoo import http
+from odoo.http import request
+from werkzeug.exceptions import Forbidden, NotFound
+from .common import check_access_permission
+
+
+class PortalBadgeReturn(http.Controller):
+
+    @http.route('/badge_return', type='http', auth='user', website=True)
+    def portal_badge_return(self, **kwargs):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise NotFound()
+        return request.render('controllo_accessi_portale.badge_return_view', {})
+
+    @http.route('/badge_return/submit', auth='user', type='http', website=True, methods=['POST'], csrf=False)
+    def badge_return_submit(self, **kwargs):
+        tag_persona_id = int(kwargs['tag_id'])
+        tag_persona = request.env['ca.tag_persona'].browse(tag_persona_id)
+        if not tag_persona.exists():
+             return request.redirect('/badge_return')
+
+        vals = {'ca_tag_id': tag_persona.id}
+        wiz = request.env['ca.restituisci_badge'].create(vals)
+        wiz.action_confirm()
+        return request.redirect('/badge_return')
+
+    @http.route('/get/badge_return/tags', auth='user', type='json', website=True)
+    def badge_return_tags(self, **kwargs):
+        user = request.env.user
+        if not check_access_permission(user):
+            raise Forbidden()
+
+        records = request.env['ca.tag_persona'].search([
+            ('state', '=', "to_give_back"),
+            ('ca_tag_id.in_use', '=', True)
+        ])
+        
+        ret = []
+        for r in records:
+            d = r.read(['ca_persona_id', 'ca_tag_id', 'temp', 'display_name'])[0] 
+            d['tag_code'] = r.ca_tag_id.tag_code
+            ret.append(d)
+        return ret

controllo_accessi_portale/controllers/common.py

@@ -0,0 +1,4 @@
+def check_access_permission(user):
+    return (user.has_group('controllo_accessi.ca_portineria') or
+            (user.has_group('controllo_accessi.ca_ru') or
+             user.has_group('controllo_accessi_portale.inrim_access_portal')))

controllo_accessi_portale/controllers/home.py

@@ -0,0 +1,30 @@
+from odoo import http
+from odoo.addons.web.controllers.home import Home
+from odoo.http import request
+
+
+class CustomHome(Home):
+
+    def _get_redirect_url(self, user):
+        """ Metodo unico per determinare la pagina di destinazione """
+        if user.has_group('base.group_system'):
+            return "/web"
+        elif user.has_group('controllo_accessi_portale.inrim_access_portal'):
+            return "/anagrafiche"
+        return "/web"
+
+    def _login_redirect(self, uid, redirect=None):
+        user = request.env['res.users'].sudo().browse(uid)
+        return self._get_redirect_url(user)
+
+    @http.route('/web/login', type='http', auth="public", website=True)
+    def web_login(self, redirect=None, **kw):
+        response = super().web_login(redirect, **kw)
+        if request.params.get('login_success'):
+            user = request.env.user
+            return request.redirect(self._get_redirect_url(user))
+        return response
+
+    @http.route('/', type='http', auth="user", website=True)
+    def home_redirect(self, **kwargs):
+        return request.redirect(self._get_redirect_url(request.env.user))