das-cli 1.0.6__py3-none-any.whl → 1.2.5__py3-none-any.whl

das/common/api.py

@@ -27,6 +27,26 @@ def get_data(url, headers=None, params=None):
         print(f"Error fetching API data: {e}")
         return {"error": str(e)}
 
+def get_binary_response(url, headers=None, params=None, stream=True):
+    """
+    Perform a GET request expected to return binary content.
+
+    Returns the raw requests.Response so callers can inspect headers
+    and stream content to disk.
+    """
+    try:
+        response = requests.get(
+            url,
+            headers=headers,
+            params=params,
+            verify=load_verify_ssl(),
+            stream=stream,
+        )
+        response.raise_for_status()
+        return response
+    except requests.RequestException as e:
+        return {"error": str(e)}
+
 def post_data(url, headers=None, data=None):
     """
     Send data to a REST API endpoint.

das/common/config.py

@@ -81,12 +81,18 @@ def load_verify_ssl() -> bool:
             
             if os.getenv("VERIFY_SSL") is not None:
                 VERIFY_SSL = os.getenv("VERIFY_SSL") == "True"
+                if not VERIFY_SSL:
+                    print("SSL certificate verification is disabled")
                 return VERIFY_SSL
 
             verify = config.get("verify_ssl")
             if verify is not None:
                 VERIFY_SSL = verify
+                if not VERIFY_SSL:
+                    print("SSL certificate verification is disabled")
                 return verify
+            else:
+                raise ValueError("SSL certificate verification is not set")
         except Exception:
             pass
     return VERIFY_SSL

das/managers/digital_objects_manager.py

@@ -0,0 +1,84 @@
+import os
+import sys
+from das.common.config import load_api_url
+from das.services.search import SearchService
+from das.services.entries import EntriesService
+from das.services.digital_objects import DigitalObjectsService
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+class DigitalObjectsManager:
+    """Manager for digital objects."""
+    
+    def __init__(self):
+        base_url = load_api_url()
+        if base_url is None or base_url == "":
+            raise ValueError(f"Base URL is required - {self.__class__.__name__}")
+
+        self.__attribute_id_digital_object_type = 5;
+        self.digital_objects_service = DigitalObjectsService(base_url)
+        self.entry_service = EntriesService(base_url)
+        self.search_service = SearchService(base_url)
+
+    def link_existing_digital_objects(
+        self, entry_code: str, digital_object_code_list: list[str], is_unlink: bool = False
+    ) -> bool:
+        """Attach or detach (unlink) digital objects to an entry using codes."""
+        entry_response = self.entry_service.get_entry(entry_code)
+
+        if entry_response is None:
+            raise ValueError(f"Entry with code '{entry_code}' not found")
+
+        entry_payload = entry_response.get("entry")
+        if entry_payload is None:
+            raise ValueError(f"Entry with code '{entry_code}' not found")
+
+        digital_object_id_list: list[str] = []
+
+        for code in digital_object_code_list:
+            do_response = self.entry_service.get_entry(code)
+            do_entry = do_response.get("entry") if do_response else None
+            if do_entry is None:
+                raise ValueError(f"Digital object with code '{code}' not found")
+            digital_object_id_list.append(do_entry.get("id"))
+
+        result = self.digital_objects_service.link_existing_digital_objects(
+            attribute_id=entry_response.get("attributeId"),
+            entry_id=entry_payload.get("id"),
+            digital_object_id_list=digital_object_id_list,
+            is_unlink=is_unlink,
+        )
+
+        return result
+
+    def upload_digital_object(self, entry_code: str, file_description: str, digital_object_type: str, file_path: str):
+        """Upload a digital object to the digital object service."""
+        response = self.search_service.search_entries(
+            queryString=f"displayname({digital_object_type})",
+            attributeId=self.__attribute_id_digital_object_type,
+            maxResultCount=1,
+            skipCount=0
+            )
+
+        entry_response = self.entry_service.get_entry(entry_code)
+        if entry_response is None:
+            raise ValueError(f"Entry with code '{entry_code}' not found")
+
+        if response.get('totalCount', 0) == 0:
+            raise ValueError(f"Digital object type '{digital_object_type}' not found")
+        
+        digital_object_type_id = response.get('items', [])[0].get('entry').get('id')
+        digital_object_id = self.digital_objects_service.upload_digital_object(file_description, digital_object_type_id, file_path)
+        
+        self.digital_objects_service.link_existing_digital_objects(
+            attribute_id=entry_response.get('attributeId'), 
+            entry_id=entry_response.get('entry').get('id'), 
+            digital_object_id_list=[digital_object_id]
+        )
+
+        return digital_object_id
+
+
+if __name__ == "__main__":
+    digital_objects_manager = DigitalObjectsManager()
+    digital_objects_manager.upload_digital_object(entry_code="zb.b.f7", file_description="test", digital_object_type="Dataset", file_path="my_new_file.txt")

das/managers/download_manager.py

@@ -90,4 +90,46 @@ class DownloadManager:
 
     def get_my_requests(self):
         """Get all download requests for the current user."""
-        return self.download_request_service.get_my_requests()
+        return self.download_request_service.get_my_requests()
+
+    def download_files(self, request_id: str):
+        """Return streaming response for files of a download request."""
+        return self.download_request_service.download_files(request_id)
+
+    def save_download(self, request_id: str, output_path: str, overwrite: bool = False) -> str:
+        """
+        Download and save the request bundle to disk.
+
+        Returns the path to the saved file.
+        """
+        import os
+
+        resp = self.download_files(request_id)
+        # If an error structure was returned from lower layer
+        if isinstance(resp, dict) and resp.get('error'):
+            raise ValueError(resp['error'])
+
+        # Determine filename from headers if available
+        filename = f"download_{request_id}.zip"
+        try:
+            cd = resp.headers.get('Content-Disposition') if hasattr(resp, 'headers') else None
+            if cd and 'filename=' in cd:
+                filename = cd.split('filename=')[-1].strip('"')
+        except Exception:
+            pass
+
+        # If output_path is a directory, join with filename
+        target_path = output_path
+        if os.path.isdir(output_path) or output_path.endswith(os.path.sep):
+            target_path = os.path.join(output_path, filename)
+
+        if os.path.exists(target_path) and not overwrite:
+            raise FileExistsError(f"File already exists: {target_path}. Use overwrite to replace.")
+
+        # Stream to disk
+        with open(target_path, 'wb') as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        return target_path

das/managers/entries_manager.py

@@ -23,6 +23,23 @@ class EntryManager:
         self.attribute_service = AttributesService(base_url)
         self.user_service = UsersService(base_url)
 
+    def delete(self, id: str = None, code: str = None) -> bool:
+        """Delete an entry by its id or code."""
+        if not id and not code:
+            raise ValueError("Entry ID or code is required")
+        if id:
+            if self.entry_service.delete_by_id(id=id) is True:
+                return True
+            else:
+                return False
+        elif code:
+            if self.entry_service.delete(code=code) is True:
+                return True
+            else:
+                return False
+        else:
+            raise ValueError("Entry ID or code is required")
+        
     def get_entry(self, entry_id: str):
         """Get entry details by ID"""
         if not entry_id:
@@ -222,6 +239,9 @@ class EntryManager:
             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()}
 
         if not attribute_id:
             raise ValueError("Attribute ID is missing in the existing entry")
@@ -244,6 +264,10 @@ class EntryManager:
 
             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)
     
@@ -276,7 +300,7 @@ class EntryManager:
                         if (datasource is not None and isinstance(datasource, dict) and "attributeid" in datasource):
                             attribute_id = datasource.get("attributeid")
                 except json.JSONDecodeError:
-                    raise ValueError(f"Invalid customdata JSON: {field.get('customdata')}")        
+                    raise ValueError(f"Invalid customdata JSON: {field.get('customdata')}")             
 
         search_params = {
             "attributeId": attribute_id,            
@@ -285,6 +309,14 @@ class EntryManager:
             "skipCount": 0
         }
 
+        # checks if source is GUID, if so, than we search by id   
+        if self.is_guid(source):
+            search_params['queryString'] = f"id({source});"
+            search_response = self.search_service.search_entries(**search_params)
+        else:
+            search_params['queryString'] = f"displayname({source});"
+            search_response = self.search_service.search_entries(**search_params)
+
         search_response = self.search_service.search_entries(**search_params)
 
         if search_response.get('totalCount', 0) == 0:
@@ -303,6 +335,10 @@ class EntryManager:
             return json.dumps([result])
         else:           
             return source
+
+    def is_guid(self, source: str) -> bool:
+        """Helper method to check if a string is a GUID."""
+        return len(source) == 36 and source.count('-') == 4
         
     def __get_field_value(self, entry_raw, field):
         """Helper method to safely get field value from entry_raw."""

das/managers/search_manager.py

@@ -3,7 +3,6 @@ from das.services.attributes import AttributesService
 from das.services.entry_fields import EntryFieldsService
 from das.services.search import SearchService
 
-
 class SearchManager:
     def __init__(self):        
         base_url = load_api_url()
@@ -59,6 +58,22 @@ class SearchManager:
                 "sorting": self.__convert_sorting(entry_fields, sort_by, sort_order)
             }
             results = self.search_service.search_entries(**search_params)
-            return results
+
+            # Build user-friendly items list while preserving totalCount
+            friendly_items = []
+            for result in results.get('items', []):
+                entry = result.get('entry', {}) if isinstance(result, dict) else {}
+                friendly_item = {}
+                for field in entry_fields:
+                    display_name = field.get('displayName')
+                    column_name = field.get('column')
+                    if display_name and column_name:
+                        friendly_item[display_name] = entry.get(column_name)
+                friendly_items.append(friendly_item)
+
+            return {
+                'items': friendly_items,
+                'totalCount': results.get('totalCount', len(friendly_items))
+            }
         except Exception as e:
             raise ValueError(f"Search failed: {str(e)}")

das/services/digital_objects.py

@@ -0,0 +1,142 @@
+import os
+import sys
+from math import ceil
+from os.path import exists
+import json
+from base64 import b64encode
+from das.common.api import post_data
+from das.common.config import load_token, load_verify_ssl
+from pathlib import Path
+import math
+import uuid
+import requests
+
+CHUNK_SIZE = 1000000 # 1MB
+class DigitalObjectsService:
+    def __init__(self, base_url):
+        self.base_url = f"{base_url}/api/services/app/DigitalObject"
+        # Common possible upload endpoints observed across deployments
+        self.upload_digital_object_url = f"{base_url}/File/UploadDigitalObject"
+
+    def link_existing_digital_objects(self, attribute_id: int, entry_id: str, digital_object_id_list: list[str], is_unlink: bool = False):
+        """Link existing digital objects to an entry."""
+        token = load_token()
+
+        if token is None or token == "":
+            raise ValueError("Authorization token is required")
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "attributeId": attribute_id,
+            "attributeValueId": entry_id,
+            "digitalObjects": [],
+        }
+
+        for digital_object_id in digital_object_id_list:
+            payload["digitalObjects"].append(
+                {
+                    "attributeId": attribute_id,
+                    "attributeValueId": entry_id,
+                    "digitalObjectId": digital_object_id,
+                    "isDeleted": is_unlink,
+                }
+            )
+
+        response = post_data(
+            f"{self.base_url}/LinkExistingDigitalObject", data=payload, headers=headers
+        )
+
+        return response.get("success")
+
+    # This is our chunk reader. This is what gets the next chunk of data ready to send.
+    def __read_in_chunks(self, file_object, chunk_size):
+        while True:
+            data = file_object.read(chunk_size)
+            if not data:
+                break
+            yield data
+
+
+    def upload_digital_object(self,  file_description: str, digital_object_type_id: str, file_path: str):
+
+        if not exists(file_path):
+            raise ValueError(f"File '{file_path}' does not exist")
+
+        head, tail = os.path.split(file_path)
+
+        metadata = {
+            "fileName": tail,
+            "fileSize": os.path.getsize(file_path),
+            "description": file_description,
+            "digitalObjectTypeId": digital_object_type_id,
+            "id": str(uuid.uuid4()).lower(),
+            "description": file_description,
+            "totalCount": ceil(os.path.getsize(file_path) / CHUNK_SIZE),
+            "index": 0,
+        }
+
+        binary_file = open(file_path, "rb")
+        index = 0
+        offset = 0
+        digital_object_id = None        
+        headers = {}
+
+        try:
+            for chunk in self.__read_in_chunks(binary_file, CHUNK_SIZE):
+                offset = index + len(chunk)
+                headers['Content-Range'] = 'bytes %s-%s/%s' % (index, offset - 1, metadata.get('fileSize'))
+                index = offset   
+                json_metadata = json.dumps(metadata)
+                base654_bytes = b64encode(json_metadata.encode('utf-8')).decode('ascii')
+                headers['metadata'] = base654_bytes               
+
+                r = self.upload_file(chunk, metadata, headers)
+
+                if r.get('result', None) is None:                    
+                    continue
+
+                digital_object_id = r.get('result').get('id')
+                metadata['index'] = index + 1
+                
+            binary_file.close()               
+
+        except Exception as e:
+            raise ValueError(f"Error uploading file '{file_path}': {str(e)}")
+        finally:
+            binary_file.close()
+
+            return digital_object_id
+
+        
+
+    def upload_file(self, file, body, headers):
+        """Upload a file to the digital object service."""
+        token = load_token()
+        headers.update({
+            "Accept": "application/json",
+            "Authorization": f"Bearer {token}",
+            # Do NOT set Content-Type here when sending files; requests will set proper multipart boundary
+        })
+
+        files = {
+            "file": ("chunk", file, "application/octet-stream"),
+        }
+
+        try:
+            response = requests.post(self.upload_digital_object_url, headers=headers, files=files, verify=load_verify_ssl())
+            response.raise_for_status()
+            if response.status_code == 200:
+                return response.json()
+            else:
+                raise ValueError(f"Error uploading file: {response.status_code} - {response.text}")
+        except requests.RequestException as e:
+            raise ValueError(f"Error uploading file: {str(e)}")
+
+
+    
+
+

das/services/downloads.py

@@ -1,84 +1,101 @@
-from das.common.api import post_data, get_data
-from das.common.config import load_token
-
-
-class DownloadRequestService:
-    def __init__(self, base_url):
-        self.base_url = f"{base_url}/api/services/app/DownloadRequest"
-
-    def create(self, request_data: list[dict]):
-        """Create a new download request."""
-        token = load_token()
-
-        if (token is None or token == ""):
-            raise ValueError("Authorization token is required")
-
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-
-        url = f"{self.base_url}/Create"
-
-        response = post_data(url, data=request_data, headers=headers)
-
-        if response.get('success') == True:
-            return response.get('result')
-        else:
-            raise ValueError(response.get('error'))        
-        
-    def delete(self, request_id: str):
-        """Delete a download request by ID."""
-
-        #check if request_id is valid uuid
-        if not isinstance(request_id, str) or len(request_id) != 36:
-            raise ValueError("Invalid request ID")
-
-        token = load_token()
-
-        if (token is None or token == ""):
-            raise ValueError("Authorization token is required")
-
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-
-        url = f"{self.base_url}/Delete?downloadRequestId={request_id}"
-
-        response = post_data(url, data={}, headers=headers)
-
-        if response.get('success') == True:
-            return response.get('result')
-        else:
-            raise ValueError(response.get('error'))
-
-    def get_my_requests(self):
-        """Get all download requests for the current user."""
-        token = load_token()
-
-        if (token is None or token == ""):
-            raise ValueError("Authorization token is required")
-
-        headers = {
-            "Authorization": f"Bearer {token}"
-        }
-        
-        url = f"{self.base_url}/GetMyRequests"
-        response = get_data(url, headers=headers)
-
-        # Expected API response shape:
-        # { success: true, result: { totalCount: number, items: [...] }, ... }
-        if isinstance(response, dict) and response.get('success') is True:
-            return response.get('result')
-        # Some backends might already return the result without 'success'
-        if isinstance(response, dict) and 'result' in response and 'success' not in response:
-            return response.get('result')
-        # If the API directly returns the payload (result), pass it through
-        if isinstance(response, dict) and 'items' in response and 'totalCount' in response:
-            return response
-        # Otherwise raise a meaningful error
-        error_msg = None
-        if isinstance(response, dict):
-            error_msg = response.get('error') or response.get('message')
-        raise ValueError(error_msg or 'Failed to fetch download requests')
+from das.common.api import post_data, get_data, get_binary_response
+from das.common.config import load_token
+
+
+class DownloadRequestService:
+    def __init__(self, base_url):
+        self.base_url = f"{base_url}/api/services/app/DownloadRequest"
+        self.download_files_url = f"{base_url}/File/DownloadRequestSet"
+
+    def create(self, request_data: list[dict]):
+        """Create a new download request."""
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+
+        url = f"{self.base_url}/Create"
+
+        response = post_data(url, data=request_data, headers=headers)
+
+        if response.get('success') == True:
+            return response.get('result')
+        else:
+            raise ValueError(response.get('error'))        
+        
+    def delete(self, request_id: str):
+        """Delete a download request by ID."""
+
+        #check if request_id is valid uuid
+        if not isinstance(request_id, str) or len(request_id) != 36:
+            raise ValueError("Invalid request ID")
+
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+
+        url = f"{self.base_url}/Delete?downloadRequestId={request_id}"
+
+        response = post_data(url, data={}, headers=headers)
+
+        if response.get('success') == True:
+            return response.get('result')
+        else:
+            raise ValueError(response.get('error'))
+
+    def get_my_requests(self):
+        """Get all download requests for the current user."""
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+        
+        url = f"{self.base_url}/GetMyRequests"
+        response = get_data(url, headers=headers)
+
+        # Expected API response shape:
+        # { success: true, result: { totalCount: number, items: [...] }, ... }
+        if isinstance(response, dict) and response.get('success') is True:
+            return response.get('result')
+        # Some backends might already return the result without 'success'
+        if isinstance(response, dict) and 'result' in response and 'success' not in response:
+            return response.get('result')
+        # If the API directly returns the payload (result), pass it through
+        if isinstance(response, dict) and 'items' in response and 'totalCount' in response:
+            return response
+        # Otherwise raise a meaningful error
+        error_msg = None
+        if isinstance(response, dict):
+            error_msg = response.get('error') or response.get('message')
+        raise ValueError(error_msg or 'Failed to fetch download requests')
+
+    def download_files(self, request_id: str):
+        """Return a streaming HTTP response for the download bundle of a request."""
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+            
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+
+        url = f"{self.download_files_url}?requestId={request_id}"
+
+        response = get_binary_response(url, headers=headers, params=None, stream=True)
+        return response

das/services/entries.py

@@ -52,8 +52,34 @@ class EntriesService():
             raise ValueError(f"API returned invalid JSON: {response.get('error')}\nResponse content: {raw_content}")
         else:
             raise ValueError(response.get('error') or "Unknown error occurred")
-        
-    def delete(self, code: str):
+
+    def delete_by_id(self, id: str) -> bool:
+        """Delete an entry by its id."""
+
+        token = load_token()
+
+        if (token is None or token == ""):
+            raise ValueError("Authorization token is required")
+
+        headers = {
+            "Authorization": f"Bearer {token}"
+        }
+
+        response_entry = self.get(id=id)
+
+        if response_entry is None:
+            raise ValueError(f"Entry with id {id} not found")
+
+        url = f"{self.base_url}/Delete?Id={response_entry.get('entry',{}).get('id')}&AttributeId={response_entry.get('attributeId')}"
+
+        response = delete_data(url, headers=headers)
+
+        if response.get('success') == True:
+            return True
+        else:
+            raise ValueError(response.get('error'))
+
+    def delete(self, code: str) -> bool:
         """Delete an entry by its code."""
         token = load_token()
 
@@ -74,7 +100,7 @@ class EntriesService():
         response = delete_data(url, headers=headers)
 
         if response.get('success') == True:
-            return response
+            return True
         else:
             raise ValueError(response.get('error'))