Syndication - generate libreoffice match document

1 files changed, 99 insertions, 16 deletions

diff --git a/ishtar_common/models_rest.py b/ishtar_common/models_rest.py
index 566a73127..bb260c30d 100644
--- a/ishtar_common/models_rest.py
+++ b/ishtar_common/models_rest.py
@@ -1,7 +1,20 @@
+import datetime
+import os
+import tempfile
+
+from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.contrib.gis.db import models
 from django.contrib.postgres.fields import ArrayField
+from django.utils.text import slugify
+
+try:
+    assert settings.USE_LIBREOFFICE
+    from ishtar_common.libreoffice import UnoCalc
+    from com.sun.star.awt.FontSlant import ITALIC
+except (AssertionError, ImportError):
+    UnoCalc = None
 
 from ishtar_common.utils import ugettext_lazy as _
 
@@ -16,8 +29,8 @@ class ApiUser(models.Model):
     ip = models.GenericIPAddressField(verbose_name=_("IP"))
 
     class Meta:
-        verbose_name = _("API - User")
-        verbose_name_plural = _("API - Users")
+        verbose_name = _("API - Remote access - User")
+        verbose_name_plural = _("API - Remote access - Users")
 
     def __str__(self):
         return self.user_ptr.username
@@ -34,8 +47,8 @@ class ApiSearchModel(models.Model):
     )
 
     class Meta:
-        verbose_name = _("API - Search model")
-        verbose_name_plural = _("API - Search models")
+        verbose_name = _("API - Remote access - Search model")
+        verbose_name_plural = _("API - Remote access - Search models")
 
 
 class ApiExternalSource(models.Model):
@@ -44,8 +57,11 @@ class ApiExternalSource(models.Model):
     key = models.CharField(_("Key"), max_length=40)
 
     class Meta:
-        verbose_name = _("API - External source")
-        verbose_name_plural = _("API - External sources")
+        verbose_name = _("API - Search - External source")
+        verbose_name_plural = _("API - Search - External sources")
+
+    def __str__(self):
+        return self.name
 
     def update_matches(self, content):
         result = {
@@ -93,7 +109,7 @@ class ApiExternalSource(models.Model):
                         if q.count():
                             local_value = q.all()[0]
                             setattr(m, "local_slug", getattr(local_value, slug_key))
-                            m.local_value = str(local_value)
+                            m.local_label = str(local_value)
                             updated = True
                     if updated:
                         m.save()
@@ -103,25 +119,92 @@ class ApiExternalSource(models.Model):
                         result["created"] += 1
                 # delete removed keys
                 q = ApiKeyMatch.objects.filter(
-                    source=self, search_model=ct, associated_type=ct_type,
+                    source=self,
+                    search_model=ct,
+                    associated_type=ct_type,
                 ).exclude(distant_slug__in=current_matches)
                 result["deleted"] += q.count()
                 q.delete()
         return result
 
-    def generate_match_csv(self):
-        pass
+    def generate_match_document(self):
+        if not UnoCalc:
+            return
+        uno = UnoCalc()
+        calc = uno.create_calc()
+        if not calc:
+            return
+        types = list(
+            ApiKeyMatch.objects.filter(
+                source=self,
+            )
+            .order_by()
+            .values_list("associated_type", flat=True)
+            .distinct()
+        )
+        lst_sheet = uno.get_sheet(calc, len(types), str(_("List types")))
+        for idx, tpe in enumerate(types):
+            self._generate_match_page(idx, tpe, uno, calc, lst_sheet)
+        tmpdir = tempfile.mkdtemp(prefix="ishtar-matches-")
+        dest_filename = "{}{}{}-{}.ods".format(tmpdir, os.sep,
+                                               datetime.date.today().isoformat(),
+                                               slugify(self.name))
+        uno.save_calc(calc, dest_filename)
+        return dest_filename
+
+    def _generate_match_page(self, page_number, tpe, uno, calc, lst_sheet):
+        model = ContentType.objects.get(pk=tpe).model_class()
+        ROW_NUMBER = 1000
+        sheet = uno.get_sheet(calc, page_number)
+        sheet.Name = str(model._meta.verbose_name)
+        for col_number, column in enumerate(
+            (_("Distant key"), _("Distant label"), _("Local"))
+        ):
+            # header
+            cell = sheet.getCellByPosition(col_number, 0)
+            cell.CharWeight = 150
+            cell.setString(str(column))
+
+        for idx, match in enumerate(
+            ApiKeyMatch.objects.filter(source=self, associated_type=tpe).all()
+        ):
+            cell = sheet.getCellByPosition(0, idx + 1)
+            cell.setString(match.distant_slug)
+            cell = sheet.getCellByPosition(1, idx + 1)
+            cell.setString(match.distant_label)
+            if match.local_label:
+                cell = sheet.getCellByPosition(2, idx + 1)
+                cell.setString(match.local_label)
+        lst = []
+        for typ in model.get_types(instances=True):
+            lst.append(str(typ))
+        end_row = uno.create_list(
+            lst_sheet, page_number, 0, str(model._meta.verbose_name), lst
+        )
+        uno.set_cell_validation_list(
+            sheet,
+            3,
+            1,
+            ROW_NUMBER + 2,
+            lst_sheet,
+            page_number,
+            [1, end_row],
+        )
 
 
 class ApiKeyMatch(models.Model):
     source = models.ForeignKey(ApiExternalSource, on_delete=models.CASCADE)
     search_model = models.ForeignKey(
-        ContentType, on_delete=models.CASCADE, verbose_name=_("Search model"),
-        related_name="key_match_search_models"
+        ContentType,
+        on_delete=models.CASCADE,
+        verbose_name=_("Search model"),
+        related_name="key_match_search_models",
     )
     associated_type = models.ForeignKey(
-        ContentType, on_delete=models.CASCADE, verbose_name=_("Associated type"),
-        related_name="key_match_types"
+        ContentType,
+        on_delete=models.CASCADE,
+        verbose_name=_("Associated type"),
+        related_name="key_match_types",
     )
     search_keys = ArrayField(
         models.CharField(max_length=200), verbose_name=_("Search keys"), blank=True
@@ -143,5 +226,5 @@ class ApiKeyMatch(models.Model):
     )
 
     class Meta:
-        verbose_name = _("API - Key match")
-        verbose_name_plural = _("API - Keys matches")
+        verbose_name = _("API - Search - Key match")
+        verbose_name_plural = _("API - Search - Keys matches")