adding --include-unpublished when exporting entities

core/importer/datasets_exporter.py

@@ -10,14 +10,17 @@ logger = DaisyLogger(__name__)
 
 
 class DatasetsExporter:
-    def __init__(self, include_unpublished=False, objects=None):
+    def __init__(
+            self, 
+            include_unpublished=False,
+            objects=None):
+        self.include_unpublished = include_unpublished
         """
         objects would be Django object manager containing datasets to export,
         i.e.:
         objects = Dataset.objects.all()
         objects = Dataset.objects.filter(acronym='test')
         """
-        self.include_unpublished = include_unpublished
         if objects is not None:
             self.objects = objects
         else:
@@ -47,20 +50,24 @@ class DatasetsExporter:
         for dataset in objects:
             dataset_repr = str(dataset)
             logger.debug(f' * Exporting dataset: "{dataset_repr}"...')
-            try:
-                pd = dataset.to_dict()
-                pd["source"] = settings.SERVER_URL
-                dataset_dicts.append(pd)
-            except Exception as e:
-                logger.error(f'Export failed for dataset {dataset.title}')
-                logger.error(str(e))
-                if verbose:
-                    import traceback
-                    ex = traceback.format_exception(*sys.exc_info())
-                    logger.error('\n'.join([e for e in ex]))
-                if stop_on_error:
-                    raise e
-            logger.debug("   ... complete!")
+            if dataset.is_published or self.include_unpublished:
+                try:
+                    pd = dataset.to_dict()
+                    pd["source"] = settings.SERVER_URL
+                    dataset_dicts.append(pd)
+                except Exception as e:
+                    logger.error(f'Export failed for dataset {dataset.title}')
+                    logger.error(str(e))
+                    if verbose:
+                        import traceback
+                        ex = traceback.format_exception(*sys.exc_info())
+                        logger.error('\n'.join([e for e in ex]))
+                    if stop_on_error:
+                        raise e
+                logger.debug("   ... complete!")
+            else:
+                logger.debug(f' "{dataset_repr}" is not published, it can not be exported')
+
         json.dump({
             "$schema": "https://raw.githubusercontent.com/elixir-luxembourg/json-schemas/master/schemas/elu-dataset.json",
             "items": dataset_dicts}, buffer, indent=4)

core/importer/partners_exporter.py

@@ -10,8 +10,10 @@ logger = DaisyLogger(__name__)
 
 
 class PartnersExporter:
-    def __init__(self, include_unpublished=False):
-        include_unpublished = include_unpublished
+    def __init__(
+            self,
+            include_unpublished=False):
+        self.include_unpublished = include_unpublished
 
     def export_to_file(self, file_handle, stop_on_error=False, verbose=False):
         result = True
@@ -33,21 +35,24 @@ class PartnersExporter:
             partners = Partner.objects.all()
             for partner in partners:
                 logger.debug(f' * Exporting partner: "{partner.name}"...')
-                try:
-                    pd = partner.to_dict()
-                    pd["source"] = settings.SERVER_URL
-                    partner_dicts.append(pd)
-
-                except Exception as e:
-                    logger.error('Export failed')
-                    logger.error(str(e))
-                    if verbose:
-                        import traceback
-                        ex = traceback.format_exception(*sys.exc_info())
-                        logger.error('\n'.join([e for e in ex]))
-                    if stop_on_error:
-                        raise e
-                logger.debug("   ... complete!")
+                if partner.is_published or self.include_unpublished:
+                    try:
+                        pd = partner.to_dict()
+                        pd["source"] = settings.SERVER_URL
+                        partner_dicts.append(pd)
+
+                    except Exception as e:
+                        logger.error('Export failed')
+                        logger.error(str(e))
+                        if verbose:
+                            import traceback
+                            ex = traceback.format_exception(*sys.exc_info())
+                            logger.error('\n'.join([e for e in ex]))
+                        if stop_on_error:
+                            raise e
+                    logger.debug("   ... complete!")
+                else:
+                    logger.debug(f' "{partner.name}" is not published, it can not be exported')
             json.dump({
                 "$schema": "https://raw.githubusercontent.com/elixir-luxembourg/json-schemas/master/schemas/elu-institution.json",
                 "items": partner_dicts}, buffer , indent=4)

core/importer/projects_exporter.py

@@ -11,14 +11,17 @@ logger = DaisyLogger(__name__)
 
 
 class ProjectsExporter:
-    def __init__(self, include_unpublished=False, objects=None):
+    def __init__(
+            self, 
+            include_unpublished=False,
+            objects=None):
+        self.include_unpublished = include_unpublished   
         """
         objects would be Django obejct manager containing projects to export,
         i.e.:
         objects = Project.objects.all()
         objects = Project.objects.filter(acronym='test')
         """
-        include_unpublished = include_unpublished
         if objects is not None:
             self.objects = objects
         else:
@@ -50,21 +53,24 @@ class ProjectsExporter:
 
         for project in objects:
             logger.debug(f' * Exporting project: "{project.acronym}"...')
-            try:
-                pd = project.to_dict()
-                pd["source"] = settings.SERVER_URL
-                project_dicts.append(pd)
-            except Exception as e:
-                project_repr = str(project)
-                logger.error(f'Export failed for project f{project_repr}')
-                logger.error(str(e))
-                if verbose:
-                    import traceback
-                    ex = traceback.format_exception(*sys.exc_info())
-                    logger.error('\n'.join([e for e in ex]))
-                if stop_on_error:
-                    raise e
-            logger.debug("   ... complete!")
+            if project.is_published or self.include_unpublished:
+                try:
+                    pd = project.to_dict()
+                    pd["source"] = settings.SERVER_URL
+                    project_dicts.append(pd)
+                except Exception as e:
+                    project_repr = str(project)
+                    logger.error(f'Export failed for project f{project_repr}')
+                    logger.error(str(e))
+                    if verbose:
+                        import traceback
+                        ex = traceback.format_exception(*sys.exc_info())
+                        logger.error('\n'.join([e for e in ex]))
+                    if stop_on_error:
+                        raise e
+                logger.debug("   ... complete!")
+            else:
+                logger.debug(f' "{project.acronym}" is not published, it can not be exported')
         json.dump({
             "$schema": "https://raw.githubusercontent.com/elixir-luxembourg/json-schemas/master/schemas/elu-project.json",
             "items": project_dicts}, buffer , indent=4)

core/management/commands/_private.py

@@ -91,10 +91,6 @@ class ImportBaseCommand(BaseCommand):
 
         ):
         raise NotImplementedError("Abstract method: Implement this method in the child class.")
-    def get_exporter(self,
-            include_unpublished=False
-        ):
-        raise NotImplementedError("Abstract method: Implement this method in the child class.")
 
     def import_directory(self, importer, dir_path):
         for json_file_path in os.listdir(dir_path):
@@ -136,13 +132,10 @@ class ExportBaseCommand(BaseCommand):
             include_unpublished = options.get('include_unpublished')
             path_to_json_file = options.get('file')
 
-            exporter = self.get_exporter(
-                                include_unpublished = include_unpublished
-                
-                            )
+        
 
             with open(path_to_json_file,  mode="w+", encoding='utf-8') as json_file:
-                exp = self.get_exporter()
+                exp = self.get_exporter( include_unpublished = include_unpublished)
                 exp.export_to_file(json_file)
                 self.stdout.write(self.style.SUCCESS("Export complete!"))