@sw-tsdk/plugin-connector 3.13.1 → 3.13.2-next.3dfd44a

package/lib/templates/migrator-runners/runner_override.txt

@@ -5,7 +5,37 @@ class SwimlaneContext:
         self.asset = asset
         self.asset_schema = asset_schema
         self.http_proxy = http_proxy
+        url = inputs.pop("SwimlaneUrl", "")
+        self.config = {
+            "ApplicationId": inputs.pop("ApplicationId", ""),
+            "RecordId": inputs.pop("RecordId", ""),
+            "InternalSwimlaneUrl": url,
+            "SwimlaneUrl": url
+        }
+        self.user = {
+            "first_name": "Swimlane",
+            "last_name": "Admin",
+            "middle_initial": "",
+            "display_name": "Swimlane Admin",
+            "last_login": "2026-02-09T18:40:10.386Z",
+            "domain": "",
+            "active": True,
+            "name": "swimlanesystem",
+            "last_password_change_date": "2026-01-22T00:31:49.783Z",
+            "password_reset_required": False,
+            "default_workspace_id": "",
+            "default_dashboard_id": "",
+            "groups": [],
+            "roles": [],
+            "primary_group": "",
+            "email": "",
+            "user_name": "swimlaneadmin",
+            "phone_number": "",
+            "disabled":False,
+            "id": ""
+        }
         self.inputs = inputs
+        self.state = {}
         # We purposefully do not include the sw_context.config object here as it is not supported
 
 class Authenticate:

package/lib/templates/migrator-runners/script_override.txt

@@ -9,23 +9,95 @@ class RunnerOverride(RO):
         super().__init__(asset, asset_schema, http_proxy)
 
     def run(self, inputs, action_schema):
+        # Rebuild inputs from YAML-defined keys (empty per type), then merge asset, then overlay incoming inputs
+        # INPUTS_MERGE_HERE
+        
         sw_context = SwimlaneContext(asset=self.asset, asset_schema=self.asset_schema,
                                      http_proxy=self.http_proxy, inputs=inputs)
-        sw_outputs = None
+        sw_outputs = []
+        from swimlane import Swimlane
+        Swimlane.turbineAccountId = sw_context.inputs.pop('TurbineAccountId', '')
+        Swimlane.turbineTenantId = sw_context.inputs.pop('TurbineTenantId', '')
+        Swimlane._api_root = f'/api/account/{Swimlane.turbineAccountId}/tenant/{Swimlane.turbineTenantId}/'
+        Swimlane._execute_task_webhook_url = sw_context.inputs.pop('ExecuteTaskWebhookUrl', '')
 
         # IMPORTED CODE BELOW
         # HERE
 
 
         # END OF IMPORTED CODE
+        import os
+        import base64
+        import requests
+        IPC_API_URI = os.getenv('IPC_API_URI', '')
+        IPC_API_TOKEN = os.getenv('IPC_API_TOKEN', '')
+
+        OUTPUT_DATE_CONVERSIONS = __OUTPUT_DATE_CONVERSIONS__
+
+        def convert_timestamp(value, timetype):
+            import pendulum
+            if timetype == "milliseconds":
+                value = value / 1000
+            if timetype in ('milliseconds', 'seconds'):
+                return pendulum.from_timestamp(value).to_iso8601_string()
+            return pendulum.from_format(value, timetype).to_iso8601_string()
+        
+        def sanitize_filename(filename):
+            """Removes or replaces illegal characters from file names."""
+            illegal_chars = r'[\/:*?"<>|[\]{}()\%]'  # Define characters to be removed
+            sanitized = re.sub(illegal_chars, '', filename)  # Remove illegal characters
+            return sanitized.strip()  # Remove leading/trailing spaces
+
+        def handle_output_files(output):
+            post_url = f"{IPC_API_URI}/files"
+            params = {"token": IPC_API_TOKEN}
+            # There are potentially many dicts in output, but usually only one
+            for o in output:
+                for key in o:
+                    file_output = o.get(key, None)
+                    temp_files = []
+                    if file_output and isinstance(file_output, list):
+                        # value is a list, but we only want to proceed if it's a list of files
+                        if all(isinstance(i, dict) and 'base64' in i and 'filename' in i for i in file_output):
+                            # we need to convert the objects to turbine format, then upload
+                            temp_files = [{'file_data': base64.b64decode(i['base64']), 'file_name': sanitize_filename(i['filename'])} for i in file_output]
+                            attachments = []
+                            for file in temp_files:
+                                attachments.append(
+                                    (
+                                        "files",
+                                        (
+                                            file["file_name"],
+                                            file["file_data"],
+                                            "multipart/form-data",
+                                        )
+                                    )
+                                )
+                            res = requests.post(post_url, files=attachments, params=params)
+                            res.raise_for_status()
+                            o[key] = res.json()
+                for key, timetype in OUTPUT_DATE_CONVERSIONS.items():
+                    if key in o and o[key] is not None:
+                        try:
+                            o[key] = convert_timestamp(o[key], timetype)
+                        except Exception:
+                            pass
+
+            return output
         if isinstance(sw_outputs, dict):
-            return sw_outputs  # Already a dictionary
+            sw_outputs["sw_task_status"] = "success"
+            return {"output": handle_output_files([sw_outputs])}  # Already a dictionary
 
         elif isinstance(sw_outputs, list):
-            return {"list_output": sw_outputs}  # Wrap in a dictionary
+            # Add sw_task_status to each dictionary in the list
+            for item in sw_outputs:
+                if isinstance(item, dict):
+                    item["sw_task_status"] = "success"
+            return {"output": handle_output_files(sw_outputs)}  # Wrap in a dictionary
 
         elif sw_outputs is None:
-            return {"output": None}  # Handle None case explicitly
+            return {"output": [{"sw_task_status": "success"}]}  # Handle None case explicitly
 
         else:
-            return {"output": sw_outputs}  # Wrap other types in a dictionary
+            # For other types, wrap in a dictionary with sw_task_status
+            return {"output": [{"result": sw_outputs, "sw_task_status": "success"}]}  # Wrap other types in a dictionary

package/lib/templates/swimlane/__init__.py

@@ -0,0 +1,18 @@
+"""Swimlane Python API driver"""
+
+from __future__ import absolute_import
+
+import logging
+
+from .core.client import Swimlane
+from .utils.version import get_package_version
+
+__all__ = [
+    'Swimlane',
+]
+
+__version__ = get_package_version()
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+

package/lib/templates/swimlane/core/adapters/__init__.py

@@ -0,0 +1,10 @@
+"""Contains various adapters encapsulating API logic for retrieving, searching, listing, or creating resource objects"""
+
+from .app import AppAdapter
+from .record import RecordAdapter
+from .report import ReportAdapter
+from .usergroup import UserAdapter, GroupAdapter
+from .helper import HelperAdapter
+from .app_revision import AppRevisionAdapter
+from .record_revision import RecordRevisionAdapter
+from .task import TaskAdapter

package/lib/templates/swimlane/core/adapters/app.py

@@ -0,0 +1,59 @@
+from swimlane.core.cache import check_cache
+from swimlane.core.resolver import SwimlaneResolver
+from swimlane.core.resources.app import App
+from swimlane.utils import one_of_keyword_only
+
+
+class AppAdapter(SwimlaneResolver):
+    """Handles retrieval of Swimlane App resources"""
+
+    @check_cache(App)
+    @one_of_keyword_only('id', 'name')
+    def get(self, key, value):
+        """Get single app by one of id or name
+
+        Supports resource cache
+
+        Keyword Args:
+            id (str): Full app id
+            name (str): App name
+
+        Returns:
+            App: Corresponding App resource instance
+
+        Raises:
+            TypeError: No or multiple keyword arguments provided
+            ValueError: No matching app found on server
+            ValueError: The lookup value is empty or None
+        """
+        if not value:
+            raise ValueError('The value provided for the key "{0}" cannot be empty or None'.format(key))
+
+        if key == 'id':
+            # Server returns 204 instead of 404 for a non-existent app id
+            response = self._swimlane.request('get', 'app/{}'.format(value))
+            if response.status_code == 204:
+                raise ValueError('No app with id "{}"'.format(value))
+
+            return App(
+                self._swimlane,
+                response.json()
+            )
+        else:
+            # Workaround for lack of support for get by name
+            # Holdover from previous driver support, to be fixed as part of 3.x
+            for app in self.list():
+                if value and value == app.name:
+                    return app
+
+            # No matching app found
+            raise ValueError('No app with name "{}"'.format(value))
+
+    def list(self):
+        """Retrieve list of all apps
+
+        Returns:
+            :class:`list` of :class:`~swimlane.core.resources.app.App`: List of all retrieved apps
+        """
+        response = self._swimlane.request('get', 'app')
+        return [App(self._swimlane, item) for item in response.json()]

package/lib/templates/swimlane/core/adapters/app_revision.py

@@ -0,0 +1,49 @@
+import math
+
+from swimlane.core.cache import check_cache
+from swimlane.core.resolver import AppResolver
+from swimlane.core.resources.app_revision import AppRevision
+from swimlane.utils import one_of_keyword_only
+
+
+class AppRevisionAdapter(AppResolver):
+    """Handles retrieval of Swimlane App Revision resources"""
+
+    def get_all(self):
+        """
+        Gets all app revisions.
+
+        Returns:
+            AppRevision[]: Returns all AppRevisions for this Adapter's app.
+        """
+        raw_revisions = self._swimlane.request('get', 'app/{0}/history'.format(self._app.id)).json()
+        return [AppRevision(self._swimlane, raw) for raw in raw_revisions]
+
+    def get(self, revision_number):
+        """
+        Gets a specific app revision.
+
+        Supports resource cache
+
+        Keyword Args:
+            revision_number (float): App revision number
+
+        Returns:
+            AppRevision: The AppRevision for the given revision number.
+            Raises: When revision is not an integer, a float NOT ending in ".0", or is less than 1
+        """
+
+        if isinstance(revision_number, (int, float)):
+            if revision_number > 0 and revision_number % math.floor(revision_number) == 0:
+                key_value = AppRevision.get_unique_id(self._app.id, revision_number)
+                return self.__get(app_id_revision=key_value)
+
+        raise ValueError('The revision number must be a positive whole number greater than 0')
+
+    @check_cache(AppRevision)
+    @one_of_keyword_only('app_id_revision')
+    def __get(self, key, value):
+        """Underlying get method supporting resource cache."""
+        app_id, revision_number = AppRevision.parse_unique_id(value)
+        app_revision_raw = self._swimlane.request('get', 'app/{0}/history/{1}'.format(app_id, revision_number)).json()
+        return AppRevision(self._swimlane, app_revision_raw)

package/lib/templates/swimlane/core/adapters/helper.py

@@ -0,0 +1,84 @@
+import pendulum
+
+from swimlane.core.resolver import SwimlaneResolver
+from swimlane.utils.version import requires_swimlane_version
+from swimlane.utils.list_validator import validate_str_list
+from swimlane.utils.str_validator import validate_str
+
+
+class HelperAdapter(SwimlaneResolver):
+    """Adapter providing any miscellaneous API calls not better suited for another adapter"""
+
+    @requires_swimlane_version('2.15')
+    def add_record_references(self, app_id, record_id, field_id, target_record_ids):
+        """Bulk operation to directly add record references without making any additional requests
+
+        Warnings:
+            Does not perform any app, record, or target app/record validation
+
+        Args:
+            app_id (str): Full App ID string
+            record_id (str): Full parent Record ID string
+            field_id (str): Full field ID to target reference field on parent Record string
+            target_record_ids (List(str)): List of full target reference Record ID strings
+        """
+        validate_str_list(target_record_ids, "target_record_ids")
+
+        self._swimlane.request(
+            'post',
+            'app/{0}/record/{1}/add-references'.format(app_id, record_id),
+            json={
+                'fieldId': field_id,
+                'targetRecordIds': target_record_ids
+            }
+        )
+
+    def add_comment(self, app_id, record_id, field_id, message, rich_text=False):
+        """Directly add a comment to a record without retrieving the app or record first
+
+        Warnings:
+            Does not perform any app, record, or field ID validation
+
+        Args:
+            app_id (str): Full App ID string
+            record_id (str): Full parent Record ID string
+            field_id (str): Full field ID to target reference field on parent Record string
+            message (str): New comment message body
+            rich_text (bool): Declare the message as being rich text, default is False
+        """
+        validate_str(app_id, 'app_id')
+        validate_str(record_id, 'record_id')
+        validate_str(field_id, 'field_id')
+        validate_str(message, 'message')
+        
+        if not isinstance(rich_text, bool):
+            raise ValueError('rich_text must be a boolean value.')
+
+        self._swimlane.request(
+            'post',
+            'app/{0}/record/{1}/{2}/comment'.format(
+                app_id,
+                record_id,
+                field_id
+            ),
+            json={
+                'message': message,
+                'isRichText': rich_text,
+                'createdDate': pendulum.now().to_rfc3339_string()
+            }
+        )
+
+    def check_bulk_job_status(self, job_id):
+        """Check status of bulk_delete or bulk_modify jobs
+        .. versionadded:: 2.17.0
+        Args:
+            job_id (str): Job ID
+
+        Returns:
+            :class:`list` of :class:`dict`: List of dictionaries containing job history
+
+        """
+        
+        validate_str(job_id, 'job_id')
+
+        return self._swimlane.request('get', "logging/job/{0}".format(job_id)).json()