das-cli 1.2.5__tar.gz → 1.2.14__tar.gz

{das_cli-1.2.5/das_cli.egg-info → das_cli-1.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: das-cli
-Version: 1.2.5
+Version: 1.2.14
 Summary: DAS api client.
 Author: Royal Netherlands Institute for Sea Research
 License-Expression: MIT

{das_cli-1.2.5 → das_cli-1.2.14}/das/cli.py

@@ -290,38 +290,39 @@ def entry():
     pass
 
 @entry.command("update")
-@click.option('--attribute', required=True, help='Attribute name')
-@click.option('--code', help='Entry code to update (only used when --data is provided)')
+@click.option('--id', default=None, help='Entry ID to update (only used with --data for single entry)')
+@click.option('--code', default=None, help='Entry code to update (only used with --data for single entry)')
 @click.argument('file_path', required=False)
 @click.option('--data', help='Data string in format { "key1": "value1", "key2": "value2", ... } or a list of such objects')
 @pass_das_context
-def update_entry(das_ctx, attribute, code=None, file_path=None, data=None):
-    """Update entries from file or data string
+def update_entry(das_ctx, id, code, file_path, data):
+    """Update entries from file or data string by ID or code.
     
-    Each entry to update must contain a Code field that identifies the entry.
+    For single updates, provide either --id or --code (or Id/Code in the data).
+    For bulk updates, each entry must contain a Code or Id field.
     Files can contain multiple entries (rows in CSV/XLS or list of objects in JSON).
     
     Examples:
     
     \b
-    # Update entries from JSON file
-    das entry update --attribute core c:\\data\\entries.json
+    # Update by code from data string
+    das entry update --code ENT001 --data "{ 'Grant Public Access': 'Yes' }"
     
     \b
-    # Update entries from CSV file
-    das entry update --attribute core c:\\data\\entries.csv
+    # Update by ID from data string
+    das entry update --id 9b826efc-36f3-471c-ad18-9c1e00abe4fa --data "{ 'Name': 'Updated' }"
     
     \b
-    # Update entries from Excel file
-    das entry update --attribute core c:\\data\\entries.xls
+    # Update entries from JSON file (each object needs Code or Id)
+    das entry update c:\\data\\entries.json
     
     \b
-    # Update a single entry from data string
-    das entry update --attribute core --code ENT001 --data { 'Grant Public Access': Yes, ... }
+    # Update entries from CSV file
+    das entry update c:\\data\\entries.csv
     
     \b
     # Update multiple entries from data string
-    das entry update --attribute core --data [{ 'Code': 'ENT001', ... }, { 'Code': 'ENT002', ... }]
+    das entry update --data "[{ 'Code': 'ENT001', ... }, { 'Code': 'ENT002', ... }]"
     """
     try:
         # Ensure client and entry_manager are initialized
@@ -341,13 +342,14 @@ def update_entry(das_ctx, attribute, code=None, file_path=None, data=None):
                 is_bulk_update = True
                 click.echo(f"Found {len(entry_data)} entries to update")
             else:
-                # If we got a single object but no code was provided, check if it has a Code field
-                if not code:
-                    # Look for Code field (case-insensitive)
-                    entry_code = next((entry_data.get(key) for key in entry_data if key.lower() == 'code'), None)
-                    if not entry_code:
-                        raise click.UsageError("No code provided and entry data doesn't contain a Code field")
-                    code = entry_code
+                # If we got a single object but no id/code was provided, check if it has Id or Code in data
+                if not id and not code:
+                    data_id = next((entry_data.get(key) for key in entry_data if key.lower() == 'id'), None)
+                    data_code = next((entry_data.get(key) for key in entry_data if key.lower() == 'code'), None)
+                    if not data_id and not data_code:
+                        raise click.UsageError("No --id or --code provided and entry data doesn't contain an Id or Code field")
+                    id = id or data_id
+                    code = code or data_code
                     
         elif data:
             click.echo("Parsing data string")
@@ -357,19 +359,25 @@ def update_entry(das_ctx, attribute, code=None, file_path=None, data=None):
             if isinstance(entry_data, list):
                 is_bulk_update = True
                 click.echo(f"Found {len(entry_data)} entries to update")
-            elif not code:
-                # If we got a single object but no code was provided, check if it has a Code field
-                entry_code = next((entry_data.get(key) for key in entry_data if key.lower() == 'code'), None)
-                if not entry_code:
-                    raise click.UsageError("No code provided and data doesn't contain a Code field")
-                code = entry_code
+            elif not id and not code:
+                # If we got a single object but no id/code was provided, check if it has Id or Code in data
+                data_id = next((entry_data.get(key) for key in entry_data if key.lower() == 'id'), None)
+                data_code = next((entry_data.get(key) for key in entry_data if key.lower() == 'code'), None)
+                if not data_id and not data_code:
+                    raise click.UsageError("No --id or --code provided and data doesn't contain an Id or Code field")
+                id = id or data_id
+                code = code or data_code
                 
         if not entry_data:
             raise click.UsageError("No valid entry data found")
 
+        # For single entry update, require id or code
+        if not is_bulk_update and not id and not code:
+            raise click.UsageError("Please provide either --id or --code, or include Id or Code in the data")
+
         # Update the entries
         if is_bulk_update:
-            results = das_ctx.entry_manager.update(attribute=attribute, entries=entry_data)
+            results = das_ctx.entry_manager.update(entries=entry_data)
             
             # Display results
             success_count = sum(1 for result in results if result.get('status') == 'success')
@@ -385,13 +393,16 @@ def update_entry(das_ctx, attribute, code=None, file_path=None, data=None):
                 click.echo("\nFailed updates:")
                 for result in results:
                     if result.get('status') == 'error':
-                        click.echo(f"  Code: {result.get('code', 'Unknown')}, Error: {result.get('error', 'Unknown error')}")
+                        ident = result.get('code') or result.get('id') or 'Unknown'
+                        click.echo(f"  {ident}: {result.get('error', 'Unknown error')}")
         else:
             # Single entry update
-            results = das_ctx.entry_manager.update(attribute=attribute, code=code, entry=entry_data)
+            results = das_ctx.entry_manager.update(id=id, code=code, entry=entry_data)
             
             if results and results[0].get('status') == 'success':
-                click.secho(f"✓ Entry '{code}' updated successfully!", fg="green")
+                identifier = id or code
+                id_label = "ID" if id else "code"
+                click.secho(f"✓ Entry '{identifier}' ({id_label}) updated successfully!", fg="green")
                 click.echo(f"Entry ID: {results[0].get('id')}")
             else:
                 error_msg = results[0].get('error', 'No response from server') if results else 'No response from server'

{das_cli-1.2.5 → das_cli-1.2.14}/das/common/entry_fields_constants.py

@@ -1,3 +1,4 @@
 # Constants for Entry Fields - Input Types
+SELECT_COMBO_INPUT = 4
 DIGITAL_OBJECT_INPUT = 13
-SELECT_COMBO_INPUT = 4
+GROUP_BOX_INPUT = 34

{das_cli-1.2.5 → das_cli-1.2.14}/das/common/file_utils.py

@@ -67,6 +67,9 @@ def load_csv_file(file_path: str) -> List[Dict[str, Any]]:
             
             if not headers:
                 raise ValueError("CSV file is empty or has no headers")
+
+            # Strip leading/trailing whitespace from column headers
+            headers = [h.strip() for h in headers]
             
             result = []
             for row in reader:

{das_cli-1.2.5 → das_cli-1.2.14}/das/managers/entries_manager.py

@@ -4,7 +4,7 @@ from das.managers.search_manager import SearchManager
 from das.services.attributes import AttributesService
 from das.services.entry_fields import EntryFieldsService
 from das.services.entries import EntriesService
-from das.common.entry_fields_constants import DIGITAL_OBJECT_INPUT, SELECT_COMBO_INPUT
+from das.common.entry_fields_constants import DIGITAL_OBJECT_INPUT, SELECT_COMBO_INPUT, GROUP_BOX_INPUT
 from das.services.search import SearchService
 from das.services.users import UsersService
 
@@ -161,18 +161,26 @@ class EntryManager:
 
         new_entry = {}
 
+        # all keys must be strings and lowercase
+        entry = {str(k).lower(): v for k, v in entry.items()}
+        
         for field in fields:
-            field_name = field.get("displayName")
+            field_name = field.get("displayName").lower()
             column_name = field.get("column").lower()
 
-            if field_name in entry:
-                new_entry[column_name] = self.__get_value(field, entry[field_name])
+            if field.get('inputType') == GROUP_BOX_INPUT:
+                new_entry = self.__set_group_box_field_value(new_entry, field, entry)
             else:
-                new_entry[column_name] = None
-
+                if field_name in entry:
+                    new_entry[column_name] = self.__get_value(field, entry[field_name])
+                elif column_name in entry:
+                    new_entry[column_name] = self.__get_value(field, entry[column_name])
+                else:
+                    new_entry[column_name] = None
+                
         return self.entry_service.create(attribute_id=attribute_id, entry=new_entry)
     
-    def update(self, attribute: str, code: str = None, entry: dict = None, entries: list = None) -> list:
+    def update(self, id: str = None, code: str = None, entry: dict = None, entries: list = None) -> list:
         """
         Update one or more existing entries.
         
@@ -180,7 +188,7 @@ class EntryManager:
         If 'entries' is provided, updates multiple entries based on the code in each entry.
         
         Args:
-            attribute (str): The attribute name
+            id (str, optional): The entry ID for single entry update
             code (str, optional): The entry code for single entry update
             entry (dict, optional): The entry data for single entry update
             entries (list, optional): List of entry data for multiple updates
@@ -206,42 +214,48 @@ class EntryManager:
                 
                 # Each entry must have a Code field
                 entry_code = next((entry_data.get(key) for key in entry_data if key.lower() == 'code'), None)
+                entry_id = next((entry_data.get(key) for key in entry_data if key.lower() == 'id'), None)   
                 if not entry_code:
-                    raise ValueError(f"Entry code is missing in entry data: {entry_data}")
+                    entry_data['code'] = code
+                if not entry_id:
+                    entry_data['id'] = id
                 
                 try:
-                    result = self._update_single_entry(attribute, entry_code, entry_data)
+                    result = self._update_single_entry(id=id, code=code, entry=entry_data)
                     results.append({"code": entry_code, "id": result, "status": "success"})
                 except Exception as e:
                     results.append({"code": entry_code, "error": str(e), "status": "error"})
             
             return results
         
-        elif code and entry:
+        elif (code or id) and entry:
             # Single entry update
-            result = self._update_single_entry(attribute, code, entry)
+            result = self._update_single_entry(id=id, code=code, entry=entry)
             return [{"code": code, "id": result, "status": "success"}]
         
         else:
-            raise ValueError("Either 'code' and 'entry' or 'entries' must be provided")
+            raise ValueError("Either 'id', 'code' and 'entry' or 'entries' must be provided")
     
-    def _update_single_entry(self, attribute: str, code: str, entry: dict) -> str:
+    def _update_single_entry(self, id: str = None, code: str = None, entry: dict = None) -> str:
         """Internal method to update a single entry."""
-        if not code:
-            raise ValueError("Entry code is required")
-
-        if not entry or not isinstance(entry, dict):
-            raise ValueError("Entry data must be a non-empty dictionary")
-
-        existing_entry_response = self.entry_service.get_entry(code=code)
+        if not id and not code:
+            raise ValueError("Entry ID or code is required")
+        if id:
+            if not entry:
+                raise ValueError("Entry data is required")
+            existing_entry_response = self.entry_service.get(id=id)
+        elif code:
+            existing_entry_response = self.entry_service.get(code=code)
+        else:
+            raise ValueError("Entry ID or code is required")
 
         if not existing_entry_response or not isinstance(existing_entry_response, dict):
             raise ValueError(f"Invalid existing entry response: {existing_entry_response}")
 
         attribute_id = existing_entry_response.get("attributeId")
         
-        # make all keys lowercase
-        entry = {k.lower(): v for k, v in entry.items()}
+        # all keys must be strings and lowercase
+        entry = {str(k).lower(): v for k, v in entry.items()}
 
         if not attribute_id:
             raise ValueError("Attribute ID is missing in the existing entry")
@@ -259,24 +273,49 @@ class EntryManager:
         updated_entry = existing_entry_response.get('entry', {})
 
         for field in fields:
-            field_name = field.get("displayName")
+
+            field_name = field.get("displayName").lower()
             column_name = field.get("column").lower()
 
-            if field_name in entry:
-                updated_entry[column_name] = self.__get_value(field, entry[field_name])
-            elif column_name in entry:
-                updated_entry[column_name] = self.__get_value(field, entry[column_name])
+            if field.get('inputType') == GROUP_BOX_INPUT:
+                # remove the column from the entry                
+                updated_entry = self.__set_group_box_field_value(updated_entry, field, entry)
             else:
-                updated_entry[column_name] = None
+                if field_name in entry:
+                    updated_entry[column_name] = self.__get_value(field, entry[field_name])
+                elif column_name in entry:
+                    updated_entry[column_name] = self.__get_value(field, entry[column_name])
+                else:
+                    updated_entry[column_name] = None
 
         return self.entry_service.update(attribute_id=attribute_id, entry=updated_entry)
     
+    def __set_group_box_field_value(self, current_entry: dict, field, entry: dict) -> dict:
+        """Helper method to set group box field value."""
+        custom_data = field.get('customData', None)
+        if custom_data is not None:
+            custom_data = json.loads(custom_data)
+            if custom_data.get('fields') is not None:
+                for field in custom_data.get('fields'):
+                    field_name = field.get("displayName").lower()
+                    column_name = field.get("column").lower()
+                    if field_name in entry:
+                        current_entry[column_name] = self.__get_value(field, entry[field_name])
+                    elif column_name in entry:
+                        current_entry[column_name] = self.__get_value(field, entry[column_name])
+                    else:
+                        current_entry[column_name] = None
+
+        return current_entry
 
     def __get_value(self, field, source: str):
         """Helper method to get field value based on its type."""
         if field.get('inputType') == SELECT_COMBO_INPUT:  # SELECT_COMBO_INPUT
             select_value = self.__get_select_combobox_field_value(field, source)
             return select_value
+        elif field.get('inputType') == GROUP_BOX_INPUT:
+            # group_box_value = self.__get_group_box_field_value(entry_raw, field)
+            return None
         else:
             return source    
     

{das_cli-1.2.5 → das_cli-1.2.14/das_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: das-cli
-Version: 1.2.5
+Version: 1.2.14
 Summary: DAS api client.
 Author: Royal Netherlands Institute for Sea Research
 License-Expression: MIT

{das_cli-1.2.5 → das_cli-1.2.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "das-cli"
-version = "1.2.5"
+version = "1.2.14"
 authors = [
   { name="Royal Netherlands Institute for Sea Research" },
 ]

{das_cli-1.2.5 → das_cli-1.2.14}/tests/entries_manager_test.py

@@ -1,3 +1,4 @@
+import code
 from dotenv import load_dotenv
 import unittest
 import os
@@ -95,10 +96,24 @@ class TestEntriesManager(unittest.TestCase):
             "27": "ca9ab414-31e1-4aa7-98b9-b69744ffee92"
         }
 
-        updated_entry_id = self.entry_manager.update(attribute="Cores", code="zb.b.qdc", entry=updated_entry_data)
+        updated_entry_id = self.entry_manager.update(id="9b826efc-36f3-471c-ad18-9c1e00abe4fa", entry=updated_entry_data)
         self.assertIsNotNone(updated_entry_id)
         self.assertRegex(updated_entry_id[0]['id'], r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$')
 
+    def test_update_entry_by_code(self):
+        """Test updating an entry"""
+        
+        updated_entry_data = {
+            "Availability": "pc.b.c",
+            "Number" : 2,
+            "diameterincm": 15,
+            "27": "#2319-03_03HM"
+        }
+
+        updated_entry_id = self.entry_manager.update(code="zb.b.0", entry=updated_entry_data)
+        self.assertIsNotNone(updated_entry_id)
+        self.assertRegex(updated_entry_id[0]['id'], r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$')        
+
 
     def test_create_entry_with_json_file(self):
         """Test creating an entry from a JSON file"""
@@ -108,12 +123,50 @@ class TestEntriesManager(unittest.TestCase):
 
     def test_create_entry_with_csv_file(self):
         """Test creating an entry from a CSV file"""
-        file_path = os.path.join(os.path.dirname(__file__), 'test_data', 'entry_data.csv')
+        file_path = os.path.join(os.path.dirname(__file__), 'test_data', 'sample_entry.csv')
         self.entry_manager.create_from_file(attribute="Cores", file_path=file_path)
         # If no exception is raised, the test is considered passed for this example
 
-    def test_create_entry_with_excel_file(self):
-        """Test creating an entry from an Excel file"""
-        file_path = os.path.join(os.path.dirname(__file__), 'test_data', 'entry_data.xlsx')
-        self.entry_manager.create_from_file(attribute="Cores", file_path=file_path)
-        # If no exception is raised, the test is considered passed for this example
+    # def test_create_entry_with_excel_file(self):
+    #     """Test creating an entry from an Excel file"""
+    #     file_path = os.path.join(os.path.dirname(__file__), 'test_data', 'entry_data.xlsx')
+    #     self.entry_manager.create_from_file(attribute="Cores", file_path=file_path)
+    #     # If no exception is raised, the test is considered passed for this example
+
+    def test_update_entry_with_column_names(self):
+            """Test updating an entry with column names"""
+            updated_entry_data = {
+                'displayname': 'Eveline Garritsen-van Arnhem', 
+                'personid': 100015, 
+                'name': 'Eveline', 
+                'surname': 'Garritsen-van Arnhem', 
+                'phonenumber': '+31222369559', 
+                'emailaddress': 'eveline.garritsen@nioz.nl', 
+                'jobtitle': 'Research Assistant', 
+                'DutchJobTitle': 'Onderzoekmedewerker', 
+                'contractenddate': '2034-12-01', 
+                'showuntildate': '2034-12-01', 
+                'educationaltitle': 'ing.', 
+                'educationaldegree': None, 
+                'location': 'T', 
+                'taborder': 3, 
+                'IsDefaultProfileOnWebsite': False, 
+                'isPrivate': True, 
+                '128': [{'id': 'd080b26e-2db0-4d68-acae-44c3a7399c51', 'attributeid': 128}]
+                }
+
+            updated_entry_id = self.entry_manager.update(id="994a9fa5-5ccb-11f0-aafa-a84a63c8db73", entry=updated_entry_data)
+            self.assertIsNotNone(updated_entry_id[0]['id'])
+            self.assertRegex(updated_entry_id[0]['id'], r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$')
+
+    def test_create_entry_with_column_names(self):
+        """Test creating an entry with column names"""
+        created_entry_data = {
+            'displayname': 'Maximilian Garritsen-van Arnhem', 
+            'personid': 100099, 
+            'name': 'Maximilian', 
+            'surname': 'Garritsen-van Arnhem', 
+        }
+        created_entry_id = self.entry_manager.create(attribute="Person", entry=created_entry_data)
+        self.assertIsNotNone(created_entry_id[0]['id'])
+        self.assertRegex(created_entry_id[0]['id'], r'^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$')    

{das_cli-1.2.5 → das_cli-1.2.14}/tests/file_utils_test.py

@@ -51,9 +51,9 @@ class TestFileUtils(unittest.TestCase):
             
         # Test loading the file
         result = load_csv_file(str(csv_path))
-        self.assertEqual(result["Name"], "Test Entry")
-        self.assertEqual(result["Description"], "Test Description")
-        self.assertEqual(result["Grant Public Access"], "Yes")
+        self.assertEqual(result[0]["Name"], "Test Entry")
+        self.assertEqual(result[0]["Description"], "Test Description")
+        self.assertEqual(result[0]["Grant Public Access"], "Yes")
         
     def test_load_excel_file(self):
         """Test loading Excel file."""
@@ -74,9 +74,9 @@ class TestFileUtils(unittest.TestCase):
             
             # Test loading the file
             result = load_excel_file(str(excel_path))
-            self.assertEqual(result["Name"], "Test Entry")
-            self.assertEqual(result["Description"], "Test Description")
-            self.assertEqual(result["Grant Public Access"], "Yes")
+            self.assertEqual(result[0]["Name"], "Test Entry")
+            self.assertEqual(result[0]["Description"], "Test Description")
+            self.assertEqual(result[0]["Grant Public Access"], "Yes")
         except ImportError:
             self.skipTest("pandas not installed, skipping Excel test")
         

{das_cli-1.2.5 → das_cli-1.2.14}/tests/search_manager_test.py

@@ -11,7 +11,7 @@ load_dotenv()
 
 class TestSearchManager(unittest.TestCase):
     def setUp(self):
-        self.das_client = Das(base_url="https://localhost:44301")
+        self.das_client = Das(base_url=os.getenv("API_URL"))
         self.das_client.authenticate(username=os.getenv("USER_NAME"), password=os.getenv("USER_PASSWORD"))
 
     def test_search_manager(self):