Created by Björn Rydahl 2017-02-07

manage_roles_listener.py

      import logging

import ftrack_api


class RoleManager(object):
    '''Event listener that manages roles.'''

    def __init__(self, session):
        '''Initialise action.'''
        super(RoleManager, self).__init__()
        self.session = session
        self.logger = logging.getLogger(
            __name__ + '.' + self.__class__.__name__
        )

    def register(self):
        '''Register listeners.'''
        self.session.event_hub.subscribe(
            'topic=ftrack.update',
            self._handle_update
        )

    def get_entity_type(self, entity):
        '''Return translated entity type tht can be used with API.'''
        entity_type = entity.get('entityType')
        entity_id = entity.get('entityId')
        object_typeid = entity.get('objectTypeId')

        for schema in self.session.schemas:
            alias_for = schema.get('alias_for')

            if (
                alias_for and isinstance(alias_for, dict) and
                alias_for['id'].lower() == entity_type and
                object_typeid == alias_for.get('classifiers', {}).get('object_typeid')
            ):
                return schema['id']

        for schema in self.session.schemas:
            alias_for = schema.get('alias_for')

            if (
                alias_for and isinstance(alias_for, basestring) and
                alias_for.lower() == entity_type
            ):
                return schema['id']

        for schema in self.session.schemas:
            alias_for = schema.get('alias_for')

            if schema['id'].lower() == entity_type:
                    return schema['id']

        raise ValueError('Unable to translate entity type.')


    def _handle_update(self, event):
        '''Handle update events.'''
        data = event.get('data', {})
        entities = data.get('entities', [])
        source = event['source']

        for entity in entities:
            action = entity.get('action')
            entity_type = self.get_entity_type(entity)
            entity_id = entity.get('entityId')

            self.logger.info(
                '{0}: {1}'.format(
                    entity.get('action'),
                    entity_type
                )
            )

            if entity_type == 'Project' and action == 'add':
                self._handle_create_project(entity_id, source)

            if entity_type == 'Appointment' and action == 'add':
                self._handle_create_appointment(entity_id, source)

    def _handle_create_project(self, project_id, source):
        '''Handle creation of projects.'''
        self.logger.info('New project created, adding roles.')

        # TODO: Add logic here for what should happen when a new project is
        # created.

        # Send a message to the user who created the project.
        event = ftrack_api.event.base.Event(
            topic='ftrack.action.trigger-user-interface',
            data={
                'type': 'message',
                'success': True,
                'message': 'Roles have been updated for the new project!'
            },
            target=(
                'applicationId=ftrack.client.web and user.id={0}'.format(
                    source['user']['id']
                )
            )
        )
        self.session.event_hub.publish(event)


    def _handle_create_appointment(self, appointment_id, source):
        '''Handle creation of appointments.'''
        self.logger.info('New appointment created, adding roles.')

        # TODO: Add logic here for what should happen when a new appointment is
        # created.

        # Send a message to the user who created the project.
        event = ftrack_api.event.base.Event(
            topic='ftrack.action.trigger-user-interface',
            data={
                'type': 'message',
                'success': True,
                'message': 'Updated roles for appointment!'
            },
            target=(
                'applicationId=ftrack.client.web and user.id={0}'.format(
                    source['user']['id']
                )
            )
        )
        self.session.event_hub.publish(event)


def register(session, **kw):
    '''Register plugin.'''

    # Validate that session is an instance of ftrack_api.Session. If not,
    # assume that register is being called from an incompatible API
    # and return without doing anything.
    if not isinstance(session, ftrack_api.Session):
        # Exit to avoid registering this plugin again.
        return

    action = RoleManager(session)
    action.register()


if __name__ == '__main__':
    logging.basicConfig(level=logging.INFO)
    session = ftrack_api.Session()
    register(session)

    # Wait for events.
    session.event_hub.wait()

    

Comments (4)

HTTPS

SSH

You can clone a snippet to your computer for local editing. Learn more.