Refactored code

src_old/sh_edraft/publish/model/publish_settings_model.py

@@ -0,0 +1,90 @@
+import traceback
+from typing import Optional
+
+from sh_edraft.configuration.base.configuration_model_base import ConfigurationModelBase
+from sh_edraft.publish.model.template import Template
+from sh_edraft.publish.model.publish_settings_name import PublishSettingsName
+from sh_edraft.console.console import Console
+from sh_edraft.console.model.foreground_color import ForegroundColor
+
+
+class PublishSettings(ConfigurationModelBase):
+
+    def __init__(self):
+        ConfigurationModelBase.__init__(self)
+
+        self._source_path: Optional[str] = None
+        self._dist_path: Optional[str] = None
+        self._templates: list[Template] = []
+
+        self._included_files: list[str] = []
+        self._excluded_files: list[str] = []
+
+        self._template_ending: Optional[str] = None
+
+    @property
+    def source_path(self) -> str:
+        return self._source_path
+
+    @source_path.setter
+    def source_path(self, source_path: str):
+        self._source_path = source_path
+
+    @property
+    def dist_path(self) -> str:
+        return self._dist_path
+
+    @dist_path.setter
+    def dist_path(self, dist_path: str):
+        self._dist_path = dist_path
+
+    @property
+    def templates(self) -> list[Template]:
+        return self._templates
+
+    @templates.setter
+    def templates(self, templates: list[Template]):
+        self._templates = templates
+        
+    @property
+    def included_files(self) -> list[str]:
+        return self._included_files
+    
+    @included_files.setter
+    def included_files(self, included_files: list[str]):
+        self._included_files = included_files
+
+    @property
+    def excluded_files(self) -> list[str]:
+        return self._excluded_files
+
+    @excluded_files.setter
+    def excluded_files(self, excluded_files: list[str]):
+        self._excluded_files = excluded_files
+        
+    @property
+    def template_ending(self) -> str:
+        return self._template_ending
+    
+    @template_ending.setter
+    def template_ending(self, template_ending: str):
+        self._template_ending = template_ending
+
+    def from_dict(self, settings: dict):
+        try:
+            self._source_path = settings[PublishSettingsName.source_path.value]
+            self._dist_path = settings[PublishSettingsName.dist_path.value]
+            for template in settings[PublishSettingsName.templates.value]:
+                temp = Template()
+                temp.from_dict(template)
+                self._templates.append(temp)
+
+            self._included_files = settings[PublishSettingsName.included_files.value]
+            self._excluded_files = settings[PublishSettingsName.excluded_files.value]
+            self._template_ending = settings[PublishSettingsName.template_ending.value]
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColor.red)
+            Console.write_line(
+                f'[ ERROR ] [ {__name__} ]: Reading error in {PublishSettingsName.publish.value} settings')
+            Console.write_line(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')
+            Console.set_foreground_color(ForegroundColor.default)

src_old/sh_edraft/publish/model/publish_settings_name.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class PublishSettingsName(Enum):
+
+    publish = 'Publish'
+    source_path = 'SourcePath'
+    dist_path = 'DistPath'
+    templates = 'Templates'
+    included_files = 'IncludedFiles'
+    excluded_files = 'ExcludedFiles'
+    template_ending = 'TemplateEnding'

src_old/sh_edraft/publish/model/template.py

@@ -0,0 +1,122 @@
+from typing import Optional
+
+from sh_edraft.coding.model.version import Version
+from sh_edraft.configuration.base.configuration_model_base import ConfigurationModelBase
+from sh_edraft.publish.model.template_enum import TemplateEnum
+
+
+class Template(ConfigurationModelBase):
+
+    def __init__(
+            self,
+            template_path: Optional[str] = None,
+            name: Optional[str] = None,
+            description: Optional[str] = None,
+            long_description: Optional[str] = None,
+            copyright_date: Optional[str] = None,
+            copyright_name: Optional[str] = None,
+            license_name: Optional[str] = None,
+            license_description: Optional[str] = None,
+            title: Optional[str] = None,
+            author: Optional[str] = None,
+            version: Optional[Version] = Version()
+    ):
+        ConfigurationModelBase.__init__(self)
+        self._template_path: Optional[str] = template_path
+        self._name: Optional[str] = name
+        self._description: Optional[str] = description
+        self._long_description: Optional[str] = long_description
+        self._copyright_date: Optional[str] = copyright_date
+        self._copyright_name: Optional[str] = copyright_name
+        self._license_name: Optional[str] = license_name
+        self._license_description: Optional[str] = license_description
+        self._title: Optional[str] = title
+        self._author: Optional[str] = author
+
+        self._version: Optional[Version] = version
+        
+        self._file_content: Optional[str] = None
+
+    @property
+    def template_path(self) -> Optional[str]:
+        return self._template_path
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @property
+    def long_description(self) -> Optional[str]:
+        return self._long_description
+
+    @property
+    def copyright_date(self) -> Optional[str]:
+        return self._copyright_date
+
+    @property
+    def copyright_name(self) -> Optional[str]:
+        return self._copyright_name
+
+    @property
+    def license_name(self) -> Optional[str]:
+        return self._license_name
+
+    @property
+    def license_description(self) -> Optional[str]:
+        return self._license_description
+
+    @property
+    def title(self) -> Optional[str]:
+        return self._title
+
+    @property
+    def author(self) -> Optional[str]:
+        return self._author
+
+    @property
+    def version(self) -> Optional[Version]:
+        return self._version
+    
+    @property
+    def file_content(self) -> Optional[str]:
+        return self._file_content
+    
+    @file_content.setter
+    def file_content(self, file_content: Optional[str]):
+        self._file_content = file_content
+
+    def from_dict(self, settings: dict):
+        self._template_path = settings[TemplateEnum.TemplatePath.value]
+        self._name = settings[TemplateEnum.Name.value]
+        self._description = settings[TemplateEnum.Description.value]
+        self._long_description = settings[TemplateEnum.LongDescription.value]
+        self._copyright_date = settings[TemplateEnum.CopyrightDate.value]
+        self._copyright_name = settings[TemplateEnum.CopyrightName.value]
+        self._license_name = settings[TemplateEnum.LicenseName.value]
+        self._license_description = settings[TemplateEnum.LicenseDescription.value]
+        self._title = settings[TemplateEnum.Title.value]
+        self._author = settings[TemplateEnum.Author.value]
+        self._version.from_dict(settings[TemplateEnum.Version.value])
+
+    def to_dict(self) -> dict:
+        version: Optional[dict] = None
+        if self._version is not None:
+            version = self._version.to_dict()
+
+        return {
+            TemplateEnum.TemplatePath.value: self._template_path,
+            TemplateEnum.Name.value: self._name,
+            TemplateEnum.Description.value: self._description,
+            TemplateEnum.LongDescription.value: self._long_description,
+            TemplateEnum.CopyrightDate.value: self._copyright_date,
+            TemplateEnum.CopyrightName.value: self._copyright_name,
+            TemplateEnum.LicenseName.value: self._license_name,
+            TemplateEnum.LicenseDescription.value: self._license_description,
+            TemplateEnum.Title.value: self._title,
+            TemplateEnum.Author.value: self._author,
+            TemplateEnum.Version.value: version
+        }

src_old/sh_edraft/publish/model/template_enum.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class TemplateEnum(Enum):
+
+    TemplatePath = 'TemplatePath'
+    Name = 'Name'
+    Description = 'Description'
+    LongDescription = 'LongDescription'
+    CopyrightDate = 'CopyrightDate'
+    CopyrightName = 'CopyrightName'
+    LicenseName = 'LicenseName'
+    LicenseDescription = 'LicenseDescription'
+    Title = 'Title'
+    Author = 'Author'
+    Version = 'Version'