Snippets

ftrack Action - Create notes on multiple entities

You are viewing an old version of this snippet. View the current version.
Revised by Lucas Correia cfe91af
README.rst
Raw

Note on multiple entities action

The action Note on multiple entities will go through your selection and create a note for each of the items.

Using the action

Navigate to a project in the web interface and select a few items in the spreadsheet and select Actions from the context menu. Click on Write notes and add your text and optionally select a note category.

Notes created are copies, and any replies will only show up on one of the notes.

Available on

  • Projects
  • Tasks (including encapsulating folders)
  • Versions

Running the action

Start the listener from the terminal using the following command:

python note_on_multiple_entities_action.py

If you wish to see debugging information, set the verbosity level by appending -v debug to the command.

For more information, see the documentation on using actions.

note_on_multiple_entities_action.py
Raw 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# :coding: utf-8
# :copyright: Copyright (c) 2015 ftrack
import sys
import argparse
import logging
import threading

import ftrack


def async(fn):
    '''Run *fn* asynchronously.'''
    def wrapper(*args, **kwargs):
        thread = threading.Thread(target=fn, args=args, kwargs=kwargs)
        thread.start()
    return wrapper


class NoteOnMultipleEntitiesAction(ftrack.Action):
    '''Action to write note on multiple entities.'''

    #: Action identifier.
    identifier = 'note-on-multiple-entities'

    #: Action label.
    label = 'Write notes'

    @async
    def createNotes(self, selection, text, category):
        entityCount = len(selection)
        logging.info('Creating notes on {0} entities'.format(entityCount))

        job = ftrack.createJob(
            'Creating notes ({0} of {1})'.format(1, entityCount), 'running'
        )
        try:
            for index, item in enumerate(selection, start=1):
                entityType = item['entityType']
                entityId = item['entityId']
                entity = None

                if index != 1:
                    job.setDescription('Creating notes ({0} of {1})'.format(index, entityCount))

                if entityType == 'show':
                    entity = ftrack.Project(entityId)
                elif entityType == 'task':
                    entity = ftrack.Task(entityId)
                elif entityType == 'assetversion':
                    entity = ftrack.AssetVersion(entityId)

                if not entity:
                    logging.warning(
                        u'Entity ({0}, {1}) not a valid type, skipping..'
                        .format(entityId, entityType)
                    )

                entity.createNote(text, category)
        except Exception:
            job.setStatus('failed')

        logging.info('Note creation completed.')
        job.setStatus('done')

    def launch(self, event):
        '''Callback method for action.'''
        data = event['data']
        logging.info(u'Launching action with data: {0}'.format(data))

        selection = data.get('selection', [])
        if not selection:
            return {'success': False}

        if 'values' in data:
            text = data['values'].get('note_text')
            category = data['values'].get('note_category', 'auto')
            self.createNotes(selection, text, category)

            return {
                'success': True,
                'message': 'Started creating notes'
            }

        options = [
            {'label': category.getName(), 'value': category.getId()}
            for category in ftrack.getNoteCategories()
        ]
        options.insert(0, {'label': 'Default', 'value': 'auto'})


        return {
            'items': [
                {
                    'value': '## Writing note on **{0}** items. ##'.format(len(selection)),
                    'type': 'label'
                }, {
                    'label': 'Content',
                    'name': 'note_text',
                    'value': '',
                    'type': 'textarea'
                }, {
                    'label': 'Note category',
                    'type': 'enumerator',
                    'name': 'note_category',
                    'value': 'auto',
                    'data': options
                }
            ]
        }


def main(arguments=None):
    '''Set up logging and register action.'''
    if arguments is None:
        arguments = []

    parser = argparse.ArgumentParser()
    # Allow setting of logging level from arguments.
    loggingLevels = {}
    for level in (
        logging.NOTSET, logging.DEBUG, logging.INFO, logging.WARNING,
        logging.ERROR, logging.CRITICAL
    ):
        loggingLevels[logging.getLevelName(level).lower()] = level

    parser.add_argument(
        '-v', '--verbosity',
        help='Set the logging output verbosity.',
        choices=loggingLevels.keys(),
        default='info'
    )
    namespace = parser.parse_args(arguments)

    # Set up basic logging
    logging.basicConfig(level=loggingLevels[namespace.verbosity])

    # Subscribe to action.
    ftrack.setup()
    action = NoteOnMultipleEntitiesAction()
    action.register()

    # Wait for events
    ftrack.EVENT_HUB.wait()


if __name__ == '__main__':
    raise SystemExit(main(sys.argv[1:]))
HTTPS SSH

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