Products.urban 2.7.30__tar.gz → 2.7.31__tar.gz

{Products.urban-2.7.30 → Products.urban-2.7.31}/MANIFEST.in

@@ -17,6 +17,7 @@
   recursive-include src *.gif
   recursive-include src *.ini
   recursive-include src *.js
+  recursive-include src *.json
   recursive-include src *.metadata
   recursive-include src *.odt
   recursive-include src *.oxt

{Products.urban-2.7.30/src/Products.urban.egg-info → Products.urban-2.7.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Products.urban
-Version: 2.7.30
+Version: 2.7.31
 Summary: Urban Certificate Management
 Home-page: http://www.communesplone.org/les-outils/applications-metier/gestion-des-permis-durbanisme
 Author: Simon Delcourt
@@ -46,6 +46,36 @@ Description: *********
         
         .. towncrier release notes start
         
+        2.7.31 (2025-03-12)
+        -------------------
+        
+        New features:
+        
+        
+        - Add possibility to get template merged when import
+          [jchandelle] (SUP-39711)
+        
+        
+        Bug fixes:
+        
+        
+        - Ensure 'in_progress'state covers 'complete' and 'deposit' states in statistics calculation.
+          [WBoudabous] (SUP-42045)
+        - Fix lost value in licence duplication
+          [jchandelle] (SUP-42578)
+        - Clarify `Copy to claimant`
+          [daggelpop] (SUP-42931)
+        - Add External method to fix annoncements tasks
+          [jchandelle] (URB-2680)
+        
+        
+        Internal:
+        
+        
+        - Fix ViewPageTemplateFile import
+          [jchandelle] (SUP-41619, URB-3237)
+        
+        
         2.7.30 (2025-02-07)
         -------------------
         

{Products.urban-2.7.30 → Products.urban-2.7.31}/docs/CHANGES.rst

@@ -8,6 +8,36 @@ Changelog
 
 .. towncrier release notes start
 
+2.7.31 (2025-03-12)
+-------------------
+
+New features:
+
+
+- Add possibility to get template merged when import
+  [jchandelle] (SUP-39711)
+
+
+Bug fixes:
+
+
+- Ensure 'in_progress'state covers 'complete' and 'deposit' states in statistics calculation.
+  [WBoudabous] (SUP-42045)
+- Fix lost value in licence duplication
+  [jchandelle] (SUP-42578)
+- Clarify `Copy to claimant`
+  [daggelpop] (SUP-42931)
+- Add External method to fix annoncements tasks
+  [jchandelle] (URB-2680)
+
+
+Internal:
+
+
+- Fix ViewPageTemplateFile import
+  [jchandelle] (SUP-41619, URB-3237)
+
+
 2.7.30 (2025-02-07)
 -------------------
 

{Products.urban-2.7.30 → Products.urban-2.7.31}/setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup, find_packages
 import os
 
-version = "2.7.30"
+version = "2.7.31"
 
 setup(
     name="Products.urban",

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/Extensions/fix_schedule_config.py

@@ -4,6 +4,7 @@ from Products.urban.config import URBAN_TYPES
 from importlib import import_module
 from plone import api
 
+import transaction
 import logging
 
 logger = logging.getLogger("urban: fix schedule config")
@@ -92,3 +93,27 @@ def fix_schedule_config():
  'description': '',
  'end_conditions': (<imio.schedule.content.object_factories.EndConditionObject object at 0x7f806ae3f450>,),
 """
+
+
+def fix_announcement_task(schedule_config):
+    if (
+        hasattr(schedule_config, "additional_delay_type")
+        and isinstance(schedule_config.additional_delay_type, dict)
+        and "token" in schedule_config.additional_delay_type
+    ):
+        schedule_config.additional_delay_type = schedule_config.additional_delay_type["token"]
+
+
+def fix_announcement_tasks():
+    portal = api.portal.get()
+    portal_urban = portal["portal_urban"]
+    for ptype in URBAN_TYPES:
+        cfg_folder = portal_urban[ptype.lower()]
+        if "schedule" not in cfg_folder:
+            continue
+        schedule_config = cfg_folder["schedule"]
+        if hasattr(schedule_config, "announcement-preparation"):
+            fix_announcement_task(schedule_config["announcement-preparation"])
+        if hasattr(schedule_config, "announcement"):
+            fix_announcement_task(schedule_config["announcement"])
+    transaction.commit

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/exportimport/import_config.py

@@ -20,6 +20,7 @@ from zope.interface import noLongerProvides
 from zope.schema.interfaces import IVocabularyFactory
 
 import logging
+import os
 
 
 logger = logging.getLogger("Import Urban Config")
@@ -73,6 +74,7 @@ class ConfigImportContent(ImportContent):
         iterator=None,
         import_to_current_lic_config_folder=False,
         import_in_same_instance=False,
+        fix_parent_path=False,
     ):
         self.handle_missing_parent = int(self.request.get("handle_missing_parent", 0))
         self.handle_missing_parent_options = (
@@ -81,6 +83,7 @@ class ConfigImportContent(ImportContent):
         )
         self.import_to_current_lic_config_folder = import_to_current_lic_config_folder
         self.import_in_same_instance = import_in_same_instance
+        self.fix_parent_path = fix_parent_path
         if not self.check_in_portal_urban():
             self.context = api.portal.get_tool("portal_urban")
         alsoProvides(self.request, IConfigImportMarker)
@@ -131,13 +134,98 @@ class ConfigImportContent(ImportContent):
             current = aq_parent(current)
         return False
 
+    def get_obj_from_path(self, path):
+        if "portal_urban" not in path:
+            return None
+        split_path = path.split("portal_urban")[-1].lstrip("/")
+        return api.content.get(path=os.path.join("/portal_urban/", split_path))
+
+    def _get_uid_from_brain(self, brain):
+        catalog = api.portal.get_tool("portal_catalog")
+        rid = brain.getRID()
+        return catalog.getIndexDataForRID(rid)["UID"]
+
+    def get_uid_from_proximity_context(self, context, id, ignore_uid=[]):
+        brains = api.content.find(context=context, portal_type="UrbanTemplate")
+        for brain in brains:
+            brain_uid = self._get_uid_from_brain(brain)
+            if brain_uid in ignore_uid:
+                continue
+            obj = brain.getObject()
+            merge_templates = obj.merge_templates
+            for template in merge_templates:
+                template_obj = api.content.get(UID=template["template"])
+                if template_obj.id == id:
+                    return template["template"]
+            ignore_uid.append(brain_uid)
+        if ILicenceConfig.providedBy(context):
+            return None
+        return self.get_uid_from_proximity_context(aq_parent(context), id, ignore_uid)
+
+    def get_template_uid(self, item, template):
+        if isinstance(template["template"], str):
+            obj = api.content.get(UID=template["template"])
+            if obj:
+                return template["template"]
+            else:
+                return None
+
+        uid = template["template"]["uid"]
+        obj = api.content.get(UID=uid)
+        if obj:
+            return uid
+
+        context = self.get_obj_from_path(item["parent"]["@id"])
+        if context:
+            template_uid = self.get_uid_from_proximity_context(
+                context, template["template"]["id"]
+            )
+            if template_uid:
+                return template_uid
+
+        path = template["template"]["path"]
+        obj = self.get_obj_from_path(path)
+        if not obj:
+            return None
+        return obj.UID()
+
+    def dict_hook_urbantemplate(self, item):
+        merge_templates = item.get("merge_templates", None)
+        if merge_templates is None:
+            return item
+        output_template = []
+        for template in merge_templates:
+            uid = self.get_template_uid(item, template)
+            if uid is None:
+                uid = "--NOVALUE--"
+            template["template"] = uid
+            output_template.append(template)
+        item["merge_templates"] = output_template
+        return item
+
+    def handle_fix_parent_path(self, item):
+        parent = item["parent"]
+        path = parent["@id"]
+        if "portal_urban" not in path:
+            return item
+        path_split = path.split("portal_urban")
+        portal = api.portal.get()
+        fix_path = os.path.join(
+            portal.absolute_url(), "portal_urban", path_split[-1].lstrip("/")
+        )
+        parent["@id"] = fix_path
+        item["parent"] = parent
+        return item
+
     def global_dict_hook(self, item):
         item = self.handle_default_value_none(item)
-        item = self.handle_template_urbantemplate(item)
         item = self.handle_scheduled_contenttype(item)
         item = self.handle_wrong_type(item)
         item = self.handle_textDefaultValues(item)
 
+        if self.fix_parent_path:
+            item = self.handle_fix_parent_path(item)
+
         if self.import_to_current_lic_config_folder:
             item = self.handle_change_id(item)
 
@@ -222,22 +310,6 @@ class ConfigImportContent(ImportContent):
                 item[key] = self.default_value_none[item["@type"]][key]
         return item
 
-    def handle_template_urbantemplate(self, item):
-        if item["@type"] != "UrbanTemplate":
-            return item
-        context = api.portal.get_tool("portal_urban")
-        factory = getUtility(
-            IVocabularyFactory, "collective.documentgenerator.MergeTemplates"
-        )
-        vocabulary = factory(context)
-
-        new_merge_templates = []
-        for merge_template in item.get("merge_templates", []):
-            merge_template["template"] = "--NOVALUE--"
-            new_merge_templates.append(merge_template)
-        item["merge_templates"] = new_merge_templates
-        return item
-
     def handle_scheduled_contenttype(self, item):
         scheduled_contenttype = item.get("scheduled_contenttype", None)
         if scheduled_contenttype is None:

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/exportimport/serializer.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
 
 from Products.urban.browser.exportimport.interfaces import IConfigExportMarker
+from Products.urban.docgen.UrbanTemplate import IUrbanTemplate
 from collective.exportimport.serializer import ChoiceFieldSerializer
 from collective.exportimport.serializer import CollectionFieldSerializer
+from plone import api
 from plone.dexterity.interfaces import IDexterityContent
 from plone.restapi.interfaces import IFieldSerializer
 from plone.restapi.serializer.converters import json_compatible
@@ -13,8 +15,8 @@ from zope.schema.interfaces import ICollection
 from zope.schema.interfaces import IVocabularyTokenized
 
 
-@adapter(ICollection, IDexterityContent, IConfigExportMarker)
 @implementer(IFieldSerializer)
+@adapter(ICollection, IDexterityContent, IConfigExportMarker)
 class UrbanConfigCollectionFieldSerializer(CollectionFieldSerializer):
     def __call__(self):
         values = super(UrbanConfigCollectionFieldSerializer, self).__call__()
@@ -25,6 +27,11 @@ class UrbanConfigCollectionFieldSerializer(CollectionFieldSerializer):
             and IVocabularyTokenized.providedBy(value_type.vocabulary)
         ):
             values = [value for value in values if self._check_value(value, value_type)]
+        if (
+            IUrbanTemplate.providedBy(self.context)
+            and self.field.getName() == "merge_templates"
+        ):
+            values = self.handle_merge_templates(values)
         return values
 
     def _check_value(self, value, value_type):
@@ -34,9 +41,26 @@ class UrbanConfigCollectionFieldSerializer(CollectionFieldSerializer):
         except LookupError:
             return False
 
+    def handle_merge_templates(self, values):
+        output = []
+        for value in values:
+            template = value.get("template", None)
+            if template is None:
+                output.append(value)
+                continue
+            try:
+                template_obj = api.content.get(UID=template)
+            except ValueError:
+                output.append(value)
+                continue
+            path = "/".join(template_obj.getPhysicalPath())
+            value["template"] = {"uid": template, "path": path, "id": template_obj.id}
+            output.append(value)
+        return output
+
 
-@adapter(IChoice, IDexterityContent, IConfigExportMarker)
 @implementer(IFieldSerializer)
+@adapter(IChoice, IDexterityContent, IConfigExportMarker)
 class UrbanConfigChoiceFieldSerializer(ChoiceFieldSerializer):
     def __call__(self):
         value = super(UrbanConfigChoiceFieldSerializer, self).__call__()

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/exportimport/templates/import_urban_config.pt

@@ -115,6 +115,18 @@
               </label>
             </div>
 
+            <div class="field">
+              <label>
+                <input
+                    type="checkbox"
+                    name="fix_parent_path:boolean"
+                    id="fix_parent_path"
+                    tal:attributes="checked python:'checked' if view.fix_parent_path else None"
+                    />
+                <span i18n:translate="">Fix parent path</span>
+              </label>
+            </div>
+
             <div class="formControls" class="form-group">
                 <input type="hidden" name="form.submitted" value="1"/>
                 <button class="btn btn-primary submit-widget button-field context"

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/licence/duplicate_licence.py

@@ -137,7 +137,6 @@ class DuplicateLicenceForm(form.Form):
         postCreationActions(duplicated_licence, None)
 
         duplicated_licence.reindexObject()
-        duplicated_licence.processForm()
 
         return self.request.RESPONSE.redirect(duplicated_licence.absolute_url())
 

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/urbanstatsview.py

@@ -71,7 +71,11 @@ class UrbanStatsView(BrowserView):
                 ),
                 "date_end": self.getSearchArgument(["to_year", "to_month", "to_day"]),
             }
+
+        # Adjust licence_state to include 'deposit' and 'complete' if 'in_progress' is requested
+        mapped_states = self.map_in_progress_state(args["licence_state"])
         catalog = getToolByName(context, "portal_catalog")
+        
         brains = catalog(
             portal_type=args["licence_type"],
             created={
@@ -81,16 +85,22 @@ class UrbanStatsView(BrowserView):
                 ],
                 "range": "minmax",
             },
-            review_state=args["licence_state"],
+            review_state=mapped_states
         )
+        
         if not brains:
             return {"sum": {"sum": "0"}}
+
         result = self.getEmptyResultTable(args)
+
         for brain in brains:
-            result[brain.portal_type][brain.review_state] += 1
+            state = self.map_deposit_and_complete_state_to_in_progress(brain.review_state)
+            result[brain.portal_type][state] += 1
+            
         self.sumPartialResults(result, total=len(brains))
-        return result
 
+        return result
+    
     def sumPartialResults(self, table, total):
         # in case where no result is found, partials sums are useless
         sum_line = {}
@@ -116,3 +126,11 @@ class UrbanStatsView(BrowserView):
             for licence_state in arguments["licence_state"]:
                 matrix_line[licence_state] = 0
         return matrix
+    
+    def map_deposit_and_complete_state_to_in_progress(self, review_state):
+            """Map 'complete' and 'deposit' states to 'in_progress'."""
+            return 'in_progress' if review_state in ('complete', 'deposit') else review_state
+
+    def map_in_progress_state(self, licence_states):
+            """Ensure 'in_progress' covers 'complete' and 'deposit' in the filter."""
+            return licence_states + ["deposit", "complete"] if "in_progress" in licence_states else licence_states

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/view_utils/close_task.py

@@ -3,7 +3,7 @@
 from Products.CMFPlone.utils import safe_unicode
 from Products.urban import UrbanMessage as _
 from Products.urban.interfaces import IGenericLicence
-from zope.app.pagetemplate.viewpagetemplatefile import ViewPageTemplateFile
+from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
 from plone import api
 from plone.z3cform.layout import FormWrapper
 from z3c.form import button

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/browser/view_utils/fix_task_uid_error.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from Products.Five import BrowserView
-from zope.app.pagetemplate.viewpagetemplatefile import ViewPageTemplateFile
+from Products.Five.browser.pagetemplatefile import ViewPageTemplateFile
 from imio.schedule.interfaces import TaskConfigNotFound
 from imio.schedule.utils import get_container_tasks
 from plone import api

{Products.urban-2.7.30 → Products.urban-2.7.31}/src/Products/urban/locales/fr/LC_MESSAGES/urban.po

@@ -217,7 +217,7 @@ msgstr "Configurer l'élément"
 
 #: ../profiles/default/actions.xml
 msgid "Copy to claimant"
-msgstr "Copier au demandeur"
+msgstr "Créer comme réclamant"
 
 #: ../browser/templates/coring_update.pt:7
 msgid "Coring"

Products.urban-2.7.31/src/Products/urban/tests/json/urban_template_test_no_other_document.json

@@ -0,0 +1,90 @@
+[{
+    "@id": "http://localhost:8086/Plone/portal_urban/codt_urbancertificatetwo/eventconfigs/depot-demande/codt_cu2_depot_de_la_demande.odt", 
+    "@type": "UrbanTemplate", 
+    "UID": "a6011644490b401288a4b06262dcede8", 
+    "allow_discussion": false, 
+    "column_modifier": -1, 
+    "context_variables": null, 
+    "created": "2024-10-10T07:42:07+00:00", 
+    "csv_field_delimiter": ",", 
+    "csv_string_delimiter": "\"", 
+    "description": "", 
+    "enabled": true, 
+    "id": "codt_cu2_depot_de_la_demande.odt", 
+    "initial_md5": "d996ddbf0ba5e2a37e514677a96725a1", 
+    "is_folderish": false, 
+    "is_reusable": false, 
+    "layout": "view", 
+    "licence_url": "http://localhost:8086/Plone/portal_urban/codt_urbancertificatetwo", 
+    "lock": {}, 
+    "mailing_loop_template": "8f362583daf64916a6e1bf429c22dade", 
+    "merge_templates": [
+        {
+            "do_rendering": true, 
+            "pod_context_name": "footer", 
+            "template": {
+                "id": "footer.odt", 
+                "path": "/Plone/portal_urban/globaltemplates/urbantemplates/footer.odt", 
+                "uid": "829c78cf46524c208ee4b775f8ebabc3"
+            }
+        }, 
+        {
+            "do_rendering": true, 
+            "pod_context_name": "header", 
+            "template": {
+                "id": "header.odt", 
+                "path": "/Plone/portal_urban/globaltemplates/urbantemplates/header.odt", 
+                "uid": "7cfd46f375304d4c84269d447c3dd0fd"
+            }
+        }
+    ], 
+    "modified": "2024-10-10T07:42:07+00:00", 
+    "odt_file": {
+        "content-type": "application/vnd.oasis.opendocument.text", 
+        "data": "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", 
+        "encoding": "base64", 
+        "filename": "codt_cu2_depot_de_la_demande.odt"
+    }, 
+    "parent": {
+        "@id": "http://localhost:8086/Plone/portal_urban/codt_urbancertificatetwo/eventconfigs/depot-demande", 
+        "@type": "EventConfig", 
+        "UID": "8a15d9759a744376a06a43bac4955ac3", 
+        "description": "", 
+        "licence_url": "http://localhost:8086/Plone/portal_urban/codt_urbancertificatetwo", 
+        "review_state": "enabled", 
+        "title": "D\u00e9p\u00f4t de la demande"
+    }, 
+    "pod_formats": [
+        "odt"
+    ], 
+    "pod_portal_types": [
+        "UrbanEvent", 
+        "UrbanEventInquiry", 
+        "UrbanEventOpinionRequest", 
+        "UrbanEventAnnouncement", 
+        "UrbanEventCollege", 
+        "UrbanEventFollowUp", 
+        "UrbanEventMayor", 
+        "UrbanEventInspectionReport", 
+        "UrbanEventNotificationCollege"
+    ], 
+    "pod_template_to_use": null, 
+    "review_state": "enabled", 
+    "roles_bypassing_talcondition": [], 
+    "style_modification_md5": "d996ddbf0ba5e2a37e514677a96725a1", 
+    "style_template": null, 
+    "tal_condition": "", 
+    "title": "R\u00e9c\u00e9piss\u00e9 du d\u00e9p\u00f4t de la demande", 
+    "version": "current", 
+    "workflow_history": {
+        "activation_workflow": [
+            {
+                "action": null, 
+                "actor": "admin", 
+                "comments": "", 
+                "review_state": "enabled", 
+                "time": "2024-10-10T07:42:07+00:00"
+            }
+        ]
+    }
+}]