Rename questionnaire to project

Author: MarekSuchanek

packages/dsw-database/dsw/database/database.py

@@ -14,7 +14,7 @@
 from .model import DBDocumentTemplate, DBDocumentTemplateFile, \
     DBDocumentTemplateAsset, DBDocument, DBComponent, \
     DocumentState, DBTenantLimits, DBSubmission, \
-    DBInstanceConfigMail, DBQuestionnaireSimple, \
+    DBInstanceConfigMail, DBProjectSimple, \
     DBUserEntity, DBLocale, DBDocumentTemplateFormat, \
     DBDocumentTemplateStep
 
@@ -36,15 +36,15 @@ class Database:
 
     SELECT_DOCUMENT = ('SELECT * FROM document '
                        'WHERE uuid = %s AND tenant_uuid = %s LIMIT 1;')
-    SELECT_QTN_DOCUMENTS = ('SELECT * FROM document '
-                            'WHERE questionnaire_uuid = %s AND tenant_uuid = %s;')
+    SELECT_DOCUMENTS = ('SELECT * FROM document '
+                        'WHERE project_uuid = %s AND tenant_uuid = %s;')
     SELECT_DOCUMENT_SUBMISSIONS = ('SELECT * FROM submission '
                                    'WHERE document_uuid = %s AND tenant_uuid = %s;')
-    SELECT_QTN_SUBMISSIONS = ('SELECT s.* '
-                              'FROM document d JOIN submission s ON d.uuid = s.document_uuid '
-                              'WHERE d.questionnaire_uuid = %s AND d.tenant_uuid = %s;')
-    SELECT_QTN_SIMPLE = ('SELECT qtn.* FROM questionnaire qtn '
-                         'WHERE qtn.uuid = %s AND qtn.tenant_uuid = %s;')
+    SELECT_SUBMISSIONS = ('SELECT s.* '
+                          'FROM document d JOIN submission s ON d.uuid = s.document_uuid '
+                          'WHERE d.project_uuid = %s AND d.tenant_uuid = %s;')
+    SELECT_PROJECT_SIMPLE = ('SELECT p.* FROM project p '
+                             'WHERE p.uuid = %s AND p.tenant_uuid = %s;')
     SELECT_TENANT_LIMIT = ('SELECT uuid, storage FROM tenant_limit_bundle '
                            'WHERE uuid = %(tenant_uuid)s LIMIT 1;')
     UPDATE_DOCUMENT_STATE = 'UPDATE document SET state = %s, worker_log = %s WHERE uuid = %s;'
@@ -79,7 +79,7 @@ class Database:
                       '+ (SELECT COALESCE(SUM(file_size)::bigint, 0) '
                       'FROM document_template_asset WHERE tenant_uuid = %(tenant_uuid)s) '
                       '+ (SELECT COALESCE(SUM(file_size)::bigint, 0) '
-                      'FROM questionnaire_file WHERE tenant_uuid = %(tenant_uuid)s) '
+                      'FROM project_file WHERE tenant_uuid = %(tenant_uuid)s) '
                       'AS result;')
     SELECT_USER = ('SELECT * FROM user_entity '
                    'WHERE uuid = %(user_uuid)s AND tenant_uuid = %(tenant_uuid)s;')
@@ -271,12 +271,11 @@ def fetch_template_assets(
         before=tenacity.before_log(LOG, logging.DEBUG),
         after=tenacity.after_log(LOG, logging.DEBUG),
     )
-    def fetch_qtn_documents(self, questionnaire_uuid: str,
-                            tenant_uuid: str) -> list[DBDocument]:
+    def fetch_project_documents(self, project_uuid: str, tenant_uuid: str) -> list[DBDocument]:
         with self.conn_query.new_cursor(use_dict=True) as cursor:
             cursor.execute(
-                query=self.SELECT_QTN_DOCUMENTS,
-                params=(questionnaire_uuid, tenant_uuid),
+                query=self.SELECT_DOCUMENTS,
+                params=(project_uuid, tenant_uuid),
             )
             return [DBDocument.from_dict_row(x) for x in cursor.fetchall()]
 
@@ -303,12 +302,12 @@ def fetch_document_submissions(self, document_uuid: str,
         before=tenacity.before_log(LOG, logging.DEBUG),
         after=tenacity.after_log(LOG, logging.DEBUG),
     )
-    def fetch_questionnaire_submissions(self, questionnaire_uuid: str,
-                                        tenant_uuid: str) -> list[DBSubmission]:
+    def fetch_submissions(self, project_uuid: str,
+                          tenant_uuid: str) -> list[DBSubmission]:
         with self.conn_query.new_cursor(use_dict=True) as cursor:
             cursor.execute(
-                query=self.SELECT_QTN_SUBMISSIONS,
-                params=(questionnaire_uuid, tenant_uuid),
+                query=self.SELECT_SUBMISSIONS,
+                params=(project_uuid, tenant_uuid),
             )
             return [DBSubmission.from_dict_row(x) for x in cursor.fetchall()]
 
@@ -319,14 +318,14 @@ def fetch_questionnaire_submissions(self, questionnaire_uuid: str,
         before=tenacity.before_log(LOG, logging.DEBUG),
         after=tenacity.after_log(LOG, logging.DEBUG),
     )
-    def fetch_questionnaire_simple(self, questionnaire_uuid: str,
-                                   tenant_uuid: str) -> DBQuestionnaireSimple:
+    def fetch_project_simple(self, project_uuid: str,
+                             tenant_uuid: str) -> DBProjectSimple:
         with self.conn_query.new_cursor(use_dict=True) as cursor:
             cursor.execute(
-                query=self.SELECT_QTN_SIMPLE,
-                params=(questionnaire_uuid, tenant_uuid),
+                query=self.SELECT_PROJECT_SIMPLE,
+                params=(project_uuid, tenant_uuid),
             )
-            return DBQuestionnaireSimple.from_dict_row(cursor.fetchone())
+            return DBProjectSimple.from_dict_row(cursor.fetchone())
 
     @tenacity.retry(
         reraise=True,

packages/dsw-database/dsw/database/model.py

@@ -45,9 +45,9 @@ class DBDocument:
     name: str
     state: str
     durability: str
-    questionnaire_uuid: str
-    questionnaire_event_uuid: str
-    questionnaire_replies_hash: str
+    project_uuid: str
+    project_event_uuid: str
+    project_replies_hash: str
     document_template_id: str
     format_uuid: str
     file_name: str
@@ -67,9 +67,9 @@ def from_dict_row(data: dict):
             name=data['name'],
             state=data['state'],
             durability=data['durability'],
-            questionnaire_uuid=str(data['questionnaire_uuid']),
-            questionnaire_event_uuid=str(data['questionnaire_event_uuid']),
-            questionnaire_replies_hash=data['questionnaire_replies_hash'],
+            project_uuid=str(data['project_uuid']),
+            project_event_uuid=str(data['project_event_uuid']),
+            project_replies_hash=data['project_replies_hash'],
             document_template_id=data['document_template_id'],
             format_uuid=str(data['format_uuid']),
             created_by=str(data['created_by']),
@@ -323,10 +323,10 @@ def to_dict(self) -> dict:
 
 
 @dataclasses.dataclass
-class DBQuestionnaireSimple:
+class DBProjectSimple:
     # without: events, answered_questions, unanswered_questions,
     #          squashed, versions, selected_question_tag_uuids
-    TABLE_NAME = 'questionnaire'
+    TABLE_NAME = 'project'
 
     uuid: str
     name: str
@@ -345,7 +345,7 @@ class DBQuestionnaireSimple:
 
     @staticmethod
     def from_dict_row(data: dict):
-        return DBQuestionnaireSimple(
+        return DBProjectSimple(
             uuid=str(data['uuid']),
             name=data['name'],
             visibility=data['visibility'],

packages/dsw-document-worker/dsw/document_worker/model/context.py

@@ -928,15 +928,15 @@ def __init__(self, *, path: str, created_at: datetime.datetime,
             reply_type='FileReply',
         )
         self.file_uuid = file_uuid
-        self.file: QuestionnaireFile | None = None
+        self.file: ProjectFile | None = None
 
     @property
     def value(self) -> str:
         return self.file_uuid
 
     def resolve_links(self, ctx):
         super().resolve_links_parent(ctx)
-        self.file = ctx.questionnaire.files.get(self.file_uuid, None)
+        self.file = ctx.project.files.get(self.file_uuid, None)
         if self.file is not None:
             self.file.reply = self
 
@@ -1749,7 +1749,7 @@ def load(data: dict, **options):
         )
 
 
-class QuestionnaireVersion:
+class ProjectVersion:
 
     def __init__(self, *, uuid: str, event_uuid: str, name: str, description: str | None,
                  created_at: datetime.datetime, updated_at: datetime.datetime,
@@ -1764,7 +1764,7 @@ def __init__(self, *, uuid: str, event_uuid: str, name: str, description: str |
 
     @staticmethod
     def load(data: dict, **options):
-        return QuestionnaireVersion(
+        return ProjectVersion(
             uuid=data['uuid'],
             event_uuid=data['eventUuid'],
             name=data['name'],
@@ -1805,7 +1805,7 @@ def items(self) -> typing.ItemsView[str, Reply]:
         return self.replies.items()
 
 
-class QuestionnaireFile:
+class ProjectFile:
 
     def __init__(self, *, uuid: str, file_name: str, file_size: int,
                  content_type: str):
@@ -1816,25 +1816,29 @@ def __init__(self, *, uuid: str, file_name: str, file_size: int,
 
         self.reply: FileReply | None = None
         self.download_url: str = ''
-        self.questionnaire_uuid: str | None = None
+        self.project_uuid: str | None = None
+
+    @property
+    def questionnaire_uuid(self) -> str | None:
+        return self.project_uuid
 
     def resolve_links(self, ctx):
-        self.questionnaire_uuid = ctx.questionnaire.uuid
+        self.project_uuid = ctx.project.uuid
         client_url = ctx.config.client_url
-        self.download_url = (f'{client_url}/projects/{self.questionnaire_uuid}'
+        self.download_url = (f'{client_url}/projects/{self.project_uuid}'
                              f'/files/{self.uuid}/download')
 
     @staticmethod
     def load(data: dict, **options):
-        return QuestionnaireFile(
+        return ProjectFile(
             uuid=data['uuid'],
             file_name=data['fileName'],
             file_size=data['fileSize'],
             content_type=data['contentType'],
         )
 
 
-class Questionnaire:
+class Project:
 
     def __init__(self, *, uuid: str, name: str, description: str | None,
                  created_by: User, phase_uuid: str | None,
@@ -1847,9 +1851,9 @@ def __init__(self, *, uuid: str, name: str, description: str | None,
         self.created_at = created_at
         self.updated_at = updated_at
 
-        self.version: QuestionnaireVersion | None = None
-        self.versions: list[QuestionnaireVersion] = []
-        self.files: dict[str, QuestionnaireFile] = {}
+        self.version: ProjectVersion | None = None
+        self.versions: list[ProjectVersion] = []
+        self.files: dict[str, ProjectFile] = {}
         self.todos: list[str] = []
         self.project_tags: list[str] = []
         self.phase: Phase = PHASE_NEVER
@@ -1859,38 +1863,38 @@ def __init__(self, *, uuid: str, name: str, description: str | None,
     def resolve_links(self, ctx):
         for reply in self.replies.values():
             reply.resolve_links(ctx)
-        for questionnaire_file in self.files.values():
-            questionnaire_file.resolve_links(ctx)
+        for file in self.files.values():
+            file.resolve_links(ctx)
 
     @staticmethod
     def load(data: dict, **options):
-        questionnaire_uuid = data['uuid']
-        versions = [QuestionnaireVersion.load(d, **options)
+        entity_uuid = data['uuid']
+        versions = [ProjectVersion.load(d, **options)
                     for d in data['versions']]
         version = None
         replies = {p: _load_reply(p, d, **options)
                    for p, d in data['replies'].items()}
-        files = {d['uuid']: QuestionnaireFile.load(d, **options)
+        files = {d['uuid']: ProjectFile.load(d, **options)
                  for d in data.get('files', [])}
         for v in versions:
             if v.uuid == data['versionUuid']:
                 version = v
-        qtn = Questionnaire(
-            uuid=questionnaire_uuid,
+        entity = Project(
+            uuid=entity_uuid,
             name=data['name'],
             description=data['description'] or '',
             created_by=User.load(data['createdBy'], **options),
             phase_uuid=data['phaseUuid'],
             created_at=_datetime(data['createdAt']),
             updated_at=_datetime(data['updatedAt']),
         )
-        qtn.version = version
-        qtn.versions = versions
-        qtn.files = files
-        qtn.project_tags = data.get('projectTags', [])
-        qtn.replies.replies = replies
-        qtn.todos = [k for k, v in data.get('labels', {}).items() if TODO_LABEL_UUID in v]
-        return qtn
+        entity.version = version
+        entity.versions = versions
+        entity.files = files
+        entity.project_tags = data.get('projectTags', [])
+        entity.replies.replies = replies
+        entity.todos = [k for k, v in data.get('labels', {}).items() if TODO_LABEL_UUID in v]
+        return entity
 
 
 class Package:
@@ -2158,7 +2162,7 @@ def __init__(self, *, ctx, **options):
         )
         self.config = ContextConfig.load(ctx['config'], **options)
         self.km = KnowledgeModel.load(ctx['knowledgeModel'], **options)
-        self.questionnaire = Questionnaire.load(ctx['questionnaire'], **options)
+        self.project = Project.load(ctx['questionnaire'], **options)
         self.report = Report.load(ctx['report'], **options)
         self.document = Document.load(ctx['document'], **options)
         self.package = Package.load(ctx['package'], **options)
@@ -2179,8 +2183,12 @@ def cfg(self) -> ContextConfig:
         return self.config
 
     @property
-    def qtn(self) -> Questionnaire:
-        return self.questionnaire
+    def qtn(self) -> Project:
+        return self.project
+
+    @property
+    def questionnaire(self) -> Project:
+        return self.project
 
     @property
     def org(self) -> Organization:
@@ -2196,16 +2204,16 @@ def doc(self) -> Document:
 
     @property
     def replies(self) -> RepliesContainer:
-        return self.questionnaire.replies
+        return self.project.replies
 
     def resolve_links(self):
-        phase_uuid = self.questionnaire.phase_uuid
+        phase_uuid = self.project.phase_uuid
         if phase_uuid is not None and phase_uuid in self.e.phases:
             self.current_phase = self.e.phases[phase_uuid]
-        self.questionnaire.phase = self.current_phase
+        self.project.phase = self.current_phase
         self.km.resolve_links(self)
         self.report.resolve_links(self)
-        self.questionnaire.resolve_links(self)
+        self.project.resolve_links(self)
 
         rv = ReplyVisitor(context=self)
         rv.visit()

packages/dsw-document-worker/dsw/document_worker/templates/steps/template.py

@@ -10,7 +10,7 @@
 from ...consts import DEFAULT_ENCODING
 from ...context import Context
 from ...documents import DocumentFile, FileFormat, FileFormats
-from ...model.context import QuestionnaireFile
+from ...model.context import ProjectFile
 from ...model.http import RequestsWrapper
 from ..filters import filters
 from ..tests import tests
@@ -178,11 +178,11 @@ def __init__(self, template, options: dict):
             self.raise_exc(f'Failed loading Jinja2 template: {e}')
 
     def _execute(self, **jinja_args):
-        def assets(source: str | QuestionnaireFile | dict):
-            if isinstance(source, QuestionnaireFile):
-                return self.template.fetch_questionnaire_file(source)
+        def assets(source: str | ProjectFile | dict):
+            if isinstance(source, ProjectFile):
+                return self.template.fetch_project_file(source)
             if isinstance(source, dict):
-                return self.template.fetch_questionnaire_file_dict(source)
+                return self.template.fetch_project_file_dict(source)
             if isinstance(source, str):
                 return self.template.fetch_asset(source)
             return None