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

package/lib/templates/swimlane/core/fields/list.py

@@ -0,0 +1,266 @@
+try:
+    from collections.abc import defaultdict
+except ImportError:
+    from collections import defaultdict
+from copy import deepcopy
+from numbers import Number
+
+import six
+from shortid import ShortId
+
+from swimlane.core.fields.base import FieldCursor
+from swimlane.exceptions import ValidationError
+from .base import CursorField
+
+SID = ShortId()
+
+
+class _ListFieldCursor(FieldCursor):
+    """Base class for Text and Numeric FieldCursors emulating a basic list"""
+
+    def _validate_list(self, target):
+        """Validate a list against field validation rules"""
+        # Check list length restrictions
+        min_items = self._field.field_definition.get('minItems')
+        max_items = self._field.field_definition.get('maxItems')
+
+        if min_items is not None:
+            if len(target) < min_items:
+                raise ValidationError(
+                    self._record,
+                    'Field "{}" must have a minimum of {} item(s)'.format(self._field.name, min_items)
+                )
+
+        if max_items is not None:
+            if len(target) > max_items:
+                raise ValidationError(
+                    self._record,
+                    'Field "{}" can only have a maximum of {} item(s)'.format(self._field.name, max_items)
+                )
+
+        # Individual item validation
+        for item in target:
+            self._validate_item(item)
+
+    def _validate_item(self, item):
+        """Validate individual item against field rules. Defaults to no-op"""
+
+    def __getattr__(self, item):
+        """Fallback to any builtin list methods on self._elements for any undefined methods called on cursor
+
+        List methods are wrapped in a function ensuring the updated value passes field validation before actually
+        applying to the internal value
+
+        Wrapper function creates a copy of the current elements in the cursor, calls whatever list method was executed
+        on the copy, then validates the updated list against field rules.
+
+        If validation fails, raise ValidationError, otherwise update the cursor elements and field value to the modified
+        list copy
+        """
+        try:
+            # Check for method on list class
+            func = getattr(list, item)
+
+            # Create a copy of elements if function exists to be the actual target of the method call
+            elements_copy = self._elements[:]
+
+            # Wrap in function adding validation after the method is executed
+            def wrapper(*args, **kwargs):
+                # Execute method against the copied elements
+                result = func(elements_copy, *args, **kwargs)
+
+                # Validate elements copy after any potential modification
+                self._validate_list(elements_copy)
+
+                # Update internal cursor elements to modified copy and sync with field
+                self._elements = elements_copy
+                self._sync_field()
+
+                # Return in case of methods retrieving values instead of modifying state
+                return result
+
+            return wrapper
+        except AttributeError:
+            # Raise separate AttributeError with correct class reference instead of list
+            raise AttributeError('{} object has no attribute {}'.format(self.__class__, item))
+
+
+class TextListFieldCursor(_ListFieldCursor):
+    """Cursor for Text ListField"""
+
+    def _validate_item(self, item):
+        """Validate char/word count"""
+        if not isinstance(item, six.string_types):
+            raise ValidationError(
+                self._record,
+                'Text list field items must be strings, not "{}"'.format(item.__class__)
+            )
+
+        words = item.split(' ')
+
+        item_length_type = self._field.field_definition.get('itemLengthType')
+        item_max_length = self._field.field_definition.get('itemMaxLength')
+        item_min_length = self._field.field_definition.get('itemMinLength')
+        if item_length_type is not None:
+            # Min/max word count
+            if item_length_type == 'words':
+                if item_max_length is not None:
+                    if len(words) > item_max_length:
+                        raise ValidationError(
+                            self._record,
+                            'Field "{}" items cannot contain more than {} words'.format(
+                                self._field.name,
+                                item_max_length
+                            )
+                        )
+                if item_min_length is not None:
+                    if len(words) < item_min_length:
+                        raise ValidationError(
+                            self._record,
+                            'Field "{}" items must contain at least {} words'.format(
+                                self._field.name,
+                                item_min_length
+                            )
+                        )
+
+            # Min/max char count of full item
+            else:
+                if item_max_length is not None:
+                    if len(item) > item_max_length:
+                        raise ValidationError(
+                            self._record,
+                            'Field "{}" items cannot contain more than {} characters'.format(
+                                self._field.name,
+                                item_max_length
+                            )
+                        )
+                if item_min_length is not None:
+                    if len(item) < item_min_length:
+                        raise ValidationError(
+                            self._record,
+                            'Field "{}" items must contain at least {} characters'.format(
+                                self._field.name,
+                                item_min_length
+                            )
+                        )
+
+
+class NumericListFieldCursor(_ListFieldCursor):
+    """Cursor for Numeric ListField"""
+
+    def _validate_item(self, item):
+        if not isinstance(item, Number):
+            raise ValidationError(
+                self._record,
+                'Numeric list field items must be numbers, not "{}"'.format(item.__class__)
+            )
+
+        # range restrictions
+        item_max = self._field.field_definition.get('itemMax')
+        item_min = self._field.field_definition.get('itemMin')
+
+        if item_max is not None:
+            if item > item_max:
+                raise ValidationError(
+                    self._record,
+                    'Field "{}" items cannot be greater than {}'.format(
+                        self._field.name,
+                        item_max
+                    )
+                )
+
+        if item_min is not None:
+            if item < item_min:
+                raise ValidationError(
+                    self._record,
+                    'Field "{}" items cannot be less than {}'.format(
+                        self._field.name,
+                        item_min
+                    )
+                )
+
+
+class ListField(CursorField):
+    """Text and Numeric List field"""
+
+    field_type = (
+        'Core.Models.Fields.List.ListField, Core',
+        'Core.Models.Fields.ListField, Core',
+    )
+
+    _type_map = {
+        'numeric': {
+            'list_item_type': 'Core.Models.Record.ListItem`1[[System.Double, mscorlib]], Core',
+            'cursor_class': NumericListFieldCursor
+        },
+        'text': {
+            'list_item_type': 'Core.Models.Record.ListItem`1[[System.String, mscorlib]], Core',
+            'cursor_class': TextListFieldCursor
+        }
+    }
+
+    def __init__(self, *args, **kwargs):
+        super(ListField, self).__init__(*args, **kwargs)
+        self.cursor_class = self._type_map[self.input_type]['cursor_class']
+
+        # dict of value -> list(ids) for each value from record raw data
+        # Set by set_swimlane during record init from app.records.get() or after record.save()
+        self._initial_value_to_ids_map = defaultdict(list)
+
+    def set_swimlane(self, value):
+        """Convert from list of dicts with values to list of values
+
+        Cache list items with their ID pairs to restore existing IDs to unmodified values to prevent workflow
+        evaluating on each save for any already existing values
+        """
+        value = value or []
+
+        self._initial_value_to_ids_map = defaultdict(list)
+        for item in value:
+            self._initial_value_to_ids_map[item['value']].append(item['id'])
+
+        return super(ListField, self).set_swimlane([d['value'] for d in value])
+
+    def set_python(self, value):
+        """Validate using cursor for consistency between direct set of values vs modification of cursor values"""
+        if not isinstance(value, (list, type(None))):
+            raise ValidationError(
+                self.record,
+                'Field "{}" must be set to a list, not "{}"'.format(
+                    self.name,
+                    value.__class__
+                )
+            )
+        value = value or []
+        self.cursor._validate_list(value)
+        return super(ListField, self).set_python(value)
+
+    def cast_to_swimlane(self, value):
+        """Restore swimlane format, attempting to keep initial IDs for any previously existing values"""
+        value = super(ListField, self).cast_to_swimlane(value)
+
+        if not value:
+            return None
+
+        # Copy initial values to pop IDs out as each value is hydrated back to server format, without modifying initial
+        # cache of value -> list(ids) map
+        value_ids = deepcopy(self._initial_value_to_ids_map)
+
+        return [self._build_list_item(item, value_ids[item].pop(0) if value_ids[item] else None) for item in value]
+
+    def cast_to_bulk_modify(self, value):
+        """List fields use raw list values for bulk modify"""
+        self.validate_value(value)
+        return value
+
+    def _build_list_item(self, item_value, id_=None):
+        """Return a dict with ID and $type for API representation of value
+
+        Uses id_ param if provided, defaults to new random ID
+        """
+        return {
+            '$type': self._type_map[self.input_type]['list_item_type'],
+            'id': id_ or SID.generate(),
+            'value': item_value
+        }
+

package/lib/templates/swimlane/core/fields/number.py

@@ -0,0 +1,38 @@
+import numbers
+
+from swimlane.exceptions import ValidationError
+from .base import Field
+
+
+class NumberField(Field):
+
+    field_type = (
+        'Core.Models.Fields.NumericField, Core',
+        'Core.Models.Fields.Numeric.NumericField, Core'
+    )
+
+    supported_types = [numbers.Number]
+
+    def __init__(self, *args, **kwargs):
+        super(NumberField, self).__init__(*args, **kwargs)
+
+        self.min = self.field_definition.get('min')
+        self.max = self.field_definition.get('max')
+
+    def validate_value(self, value):
+        super(NumberField, self).validate_value(value)
+
+        if value is not None:
+            if self.min is not None and value < self.min:
+                raise ValidationError(self.record, 'Field "{}" minimum value "{}", received "{}"'.format(
+                    self.name,
+                    self.min,
+                    value
+                ))
+
+            if self.max is not None and value > self.max:
+                raise ValidationError(self.record, 'Field "{}" maximum value "{}", received "{}"'.format(
+                    self.name,
+                    self.max,
+                    value
+                ))

package/lib/templates/swimlane/core/fields/reference.py

@@ -0,0 +1,169 @@
+import logging
+import six
+from sortedcontainers import SortedDict
+from swimlane.core.fields.base import CursorField, FieldCursor
+from swimlane.core.resources.record import Record
+from swimlane.exceptions import ValidationError, SwimlaneHTTP400Error
+
+logger = logging.getLogger(__name__)
+
+
+class ReferenceCursor(FieldCursor):
+    """Handles lazy retrieval of target records"""
+
+    def __init__(self, *args, **kwargs):
+        super(ReferenceCursor, self).__init__(*args, **kwargs)
+        self._elements = self._elements or SortedDict()
+
+    @property
+    def target_app(self):
+        """Make field's target_app available on cursor"""
+        return self._field.target_app
+
+    def __getitem__(self, item):
+        record_id, record = [kv for kv in self._elements.items()][item]
+        if record is self._field._unset:
+            try:
+                records_get = self.target_app.records.get(id=record_id)
+                self._elements[record_id] = records_get
+                return records_get
+            except SwimlaneHTTP400Error:
+                logger.debug('Received 400 response retrieving record "{}", ignoring assumed orphaned record')
+        else:
+            return record
+
+    def __iter__(self):
+        for record_id, record in six.iteritems(self._elements):
+            if record is self._field._unset:
+                try:
+                    records_get = self.target_app.records.get(id=record_id)
+                    self._elements[record_id] = records_get
+                    yield records_get
+                except SwimlaneHTTP400Error:
+                    logger.debug('Received 400 response retrieving record "{}", ignoring assumed orphaned record')
+            else:
+                yield record
+
+    def add(self, record):
+        """Add a reference to the provided record"""
+        self._field.validate_value(record)
+        self._elements[record.id] = record
+        self._sync_field()
+
+    def remove(self, record):
+        """Remove a reference to the provided record"""
+        self._field.validate_value(record)
+        del self._elements[record.id]
+        self._sync_field()
+
+
+class ReferenceField(CursorField):
+
+    field_type = 'Core.Models.Fields.Reference.ReferenceField, Core'
+    supported_types = (Record,)
+    cursor_class = ReferenceCursor
+
+    def __init__(self, *args, **kwargs):
+        super(ReferenceField, self).__init__(*args, **kwargs)
+        self.__target_app_id = self.field_definition['targetId']
+        self.__target_app = None
+
+    @property
+    def target_app(self):
+        """Defer target app retrieval until requested"""
+        if self.__target_app is None:
+            self.__target_app = self._swimlane.apps.get(id=self.__target_app_id)
+
+        return self.__target_app
+
+    def validate_value(self, value):
+        """Validate provided record is a part of the appropriate target app for the field"""
+        if value not in (None, self._unset):
+
+            if value.app != self.target_app:
+                raise ValidationError(
+                    self.record,
+                    'Reference field "{}" has target app "{}", cannot reference record "{}" from app "{}"'.format(
+                        self.name,
+                        self.target_app,
+                        value,
+                        value.app
+                    )
+                )
+
+    def _set(self, value):
+        self._cursor = None
+        self._value = value or None
+
+    def set_swimlane(self, value):
+        """Store record ids in separate location for later use, but ignore initial value"""
+
+        # Values come in as a list of record ids or None
+        value = value or []
+        if isinstance(value, dict):
+            value = value["_v"] if "_v" in value else []
+
+        records = SortedDict()
+
+        for record_id in value:
+            records[record_id] = self._unset
+
+        return super(ReferenceField, self).set_swimlane(records)
+
+    def set_python(self, value):
+        """With changes to Lazy instrumentation _evaluation returns SortedDictionary, unfortunately this
+        is still public method that can be accessed in the old way, therefore it was split in two.
+        """
+        if isinstance(value, SortedDict):
+            self.set_python_raw(value)
+        else:
+            self.set_python_old(value)
+
+    def set_python_old(self, value):
+        """Expect list of record instances, convert to a SortedDict for internal representation"""
+        if not self.multiselect:
+            if value and not isinstance(value, list):
+                value = [value]
+
+        value = value or []
+
+        records = SortedDict()
+
+        for record in value:
+            self.validate_value(record)
+            records[record.id] = record
+
+        self._set(records)
+        self.record._raw['values'][self.id] = self.get_swimlane()
+
+    def get_swimlane(self):
+        """Return list of record ids"""
+        value = super(ReferenceField, self).get_swimlane()
+        if value:
+            ids = list(value.keys())
+            return ids
+
+    def get_item(self):
+        """Return cursor if multi-select, direct value if single-select"""
+        cursor = super(ReferenceField, self).get_python()
+        if self.multiselect:
+            return cursor
+        else:
+            try:
+                return cursor[0]
+            except IndexError:
+                return None
+
+    def get_batch_representation(self):
+        """Return best batch process representation of field value"""
+        return self.get_swimlane()
+
+    def cast_to_report(self, value):
+        return value.id
+
+    def for_json(self):
+        return self.get_swimlane()
+
+    def set_python_raw(self, value):
+        self._set(value)
+        self.record._raw['values'][self.id] = self.get_swimlane()

package/lib/templates/swimlane/core/fields/text.py

@@ -0,0 +1,30 @@
+import six
+import json
+
+from .base import Field
+
+
+class TextField(Field):
+
+    field_type = (
+        'Core.Models.Fields.TextField, Core',
+        'Core.Models.Fields.Text.TextField, Core'
+    )
+
+    supported_types = six.string_types
+
+    def set_python(self, value):
+        """Set field internal value from the python representation of field value"""
+
+        # json field handling
+        if self.input_type == "json":
+            if value is not None and not isinstance(value, self.supported_types):
+                value = json.dumps(value, indent=4)
+        
+        # hook exists to stringify before validation
+
+        # set to string if not string or unicode
+        if value is not None and not isinstance(value, self.supported_types) or isinstance(value, int):
+            value = str(value)
+        return super(TextField, self).set_python(value)
+

package/lib/templates/swimlane/core/fields/tracking.py

@@ -0,0 +1,10 @@
+from .base import Field, ReadOnly
+
+
+class TrackingField(ReadOnly, Field):
+
+    field_type = (
+        'Core.Models.Fields.TrackingField, Core',
+        'Core.Models.Fields.Tracking.TrackingField, Core'
+    )
+    bulk_modify_support = False

package/lib/templates/swimlane/core/fields/usergroup.py

@@ -0,0 +1,137 @@
+from swimlane.core.resources.usergroup import UserGroup, User
+from swimlane.exceptions import ValidationError
+from .base import MultiSelectField
+
+
+class UserGroupField(MultiSelectField):
+    """Manages getting/setting users from record User/Group fields"""
+
+    field_type = (
+        'Core.Models.Fields.UserGroupField, Core',
+        'Core.Models.Fields.UserGroup.UserGroupField, Core'
+    )
+
+    supported_types = [UserGroup]
+
+    def __init__(self, *args, **kwargs):
+        super(UserGroupField, self).__init__(*args, **kwargs)
+
+        members = self.field_definition.get('members', [])
+
+        self._allowed_user_ids = set([r['id'] for r in members if r['selectionType'] == 'users'])
+        self._allowed_member_ids = set([r['id'] for r in members if r['selectionType'] == 'members'])
+
+        self._allowed_group_ids = set([r['id'] for r in members if r['selectionType'] == 'groups'])
+        self._allowed_subgroup_ids = set([r['id'] for r in members if r['selectionType'] == 'subGroups'])
+
+        self._show_all_users = self.field_definition['showAllUsers']
+        self._show_all_groups = self.field_definition['showAllGroups']
+
+    def validate_value(self, value):
+        """Validate new user/group value against any User/Group restrictions
+
+        Attempts to resolve generic UserGroup instances if necessary to respect special "Everyone" group, and
+        "All Users" + "All Groups" options
+        """
+        super(UserGroupField, self).validate_value(value)
+
+        if value is not None:
+            # Ignore validation if all users + groups are allowed
+            if self._show_all_groups and self._show_all_users:
+                return
+
+            # Try to directly check allowed ids against user/group id first to avoid having to resolve generic
+            # UserGroup with an additional request
+            if value.id in self._allowed_user_ids | self._allowed_group_ids:
+                return
+
+            # Resolve to check Users vs Groups separately
+            value = value.resolve()
+
+            if isinstance(value, User):
+                self._validate_user(value)
+            else:
+                self._validate_group(value)
+
+    def _validate_user(self, user):
+        """Validate a User instance against allowed user IDs or membership in a group"""
+        if user._raw['groups'] == []:
+           result = self._swimlane.request('get', "user/{0}".format(user.id))
+           user._raw['groups'] = result.json()['groups']
+
+        # All users allowed
+        if self._show_all_users:
+            return
+
+        # User specifically allowed
+        if user.id in self._allowed_user_ids:
+            return
+
+        # User allowed by group membership
+        user_member_group_ids = set([g['id'] for g in user._raw['groups']])
+        if user_member_group_ids & self._allowed_member_ids:
+            return
+
+        raise ValidationError(
+            self.record,
+            'User "{}" is not a valid selection for field "{}"'.format(
+                user,
+                self.name
+            )
+        )
+
+    def _validate_group(self, group):
+        """Validate a Group instance against allowed group IDs or subgroup of a parent group"""
+        # All groups allowed
+        if self._show_all_groups:
+            return
+
+        # Group specifically allowed
+        if group.id in self._allowed_group_ids:
+            return
+
+        # Group allowed by subgroup membership
+        for parent_group_id in self._allowed_subgroup_ids:
+            # Get each group, and check subgroup ids
+            parent_group = self._swimlane.groups.get(id=parent_group_id)
+            parent_group_child_ids = set([g['id'] for g in parent_group._raw['groups']])
+            if group.id in parent_group_child_ids:
+                return
+
+        raise ValidationError(
+            self.record,
+            'Group "{}" is not a valid selection for field "{}"'.format(
+                group,
+                self.name
+            )
+        )
+
+    def get_batch_representation(self):
+        """Return best batch process representation of field value"""
+        return self.get_swimlane()
+
+    def set_swimlane(self, value):
+        """Workaround for reports returning an empty usergroup field as a single element list with no id/name"""
+        if value == [{"$type": "Core.Models.Utilities.UserGroupSelection, Core"}]:
+            value = []
+
+        return super(UserGroupField, self).set_swimlane(value)
+
+    def cast_to_python(self, value):
+        """Convert JSON definition to UserGroup object"""
+        # v2.x does not provide a distinction between users and groups at the field selection level, can only return
+        # UserGroup instances instead of specific User or Group instances
+        if value is not None:
+            value = UserGroup(self._swimlane, value)
+
+        return value
+
+    def cast_to_swimlane(self, value):
+        """Dump UserGroup back to JSON representation"""
+        if value is not None:
+            if not isinstance(value, UserGroup):
+                    raise TypeError(
+                        'Expected UserGroup, received "{}" instead'.format(value))
+            value = value.as_usergroup_selection()
+
+        return value