checks to see if there is a title set on the current workflow action
uses that or falls back to controller->Title
320821
public function Title()
    {
        if (!$this->Title) {
            if ($this->getContextObject()) {
                if ($workflow = $this->contextObj->getWorkflowInstance()) {
                    $this->Title = $workflow->currentAction()->BaseAction()->PageTitle
                        ? $workflow->currentAction()->BaseAction()->PageTitle
                        : $workflow->currentAction()->Title;
                }
            }
        }
        return $this->Title;
    }
1161676
public boolean matches( String resourceName , String action )
	{
		// Match rsource name first
		if (!StringTools.matches(resourceName, resourcePattern))
			return false;
		
		// Check action
		return actions.contains(action);
	}
431585
public function detectAction()
    {

        // If the path ends in one of the special actions, use that as the action
        // as long as the verb is a GET
        if (preg_match('#[a-z-]+$#i', $this->path, $matches)) {
            $action = $matches[0];

            // If posting to the create/edit route, treat as a 'post' route rather than
            // a 'create/edit' one.  This is a shorthand so the create forms can
            // post to themselves
            if ($action == 'create' && $this->verb == 'POST') {
                return 'store';
            } elseif ($action == 'edit' && $this->verb == 'POST') {
                return 'update';
            }

            // ... otherwise, use the route explicitly
            elseif (in_array($action, $this->actions)) {
                return $action;
            }
        }

        // If the path ends in a number, the verb defines what it is
        if (preg_match('#\d+$#', $this->path)) {
            switch ($this->verb) {
                case 'PUT':
                case 'POST':
                    return 'update';

                case 'DELETE':
                    return 'destroy';

                default:
                    return false;
            }
        }

        // Else, it must end with the controller name
        switch ($this->verb) {
            case 'POST':
                return 'store';

            case 'GET':
                return 'index';
        }

        // Must have been an erorr if we got here
        return false;
    }
333235
function(event, jsEvent, view) {
              if (view.name !== 'agendaDay') {
                $(jsEvent.target).attr('title', event.title);
               }
              }
384614
def get_action(self):
        
        action = self.request.get("workflow_action_id", None)
        action = self.request.get("workflow_action", action)
        if not action:
            return None

        # A condition in the form causes Plone to sometimes send two actions
        # This usually happens when the previous action was not managed properly
        # and the request was not able to complete, so the previous form value
        # is kept, together with the new one.
        if type(action) in (list, tuple):
            actions = list(set(action))
            if len(actions) > 0:
                logger.warn("Multiple actions in request: {}. Fallback to '{}'"
                            .format(repr(actions), actions[-1]))
            action = actions[-1]
        return action
693891
function WorkorderListController($scope, workorderService, workorderFlowService, $q, workorderStatusService) {
  var self = this;

  var _workorders = [];
  self.workorders = [];

  function refreshWorkorders() {
    // Needs $q.when to trigger angular's change detection
    workorderService.list().then(function(workorders) {
      _workorders = workorders;
      self.updateFilter();
    });
  }
  refreshWorkorders();

  self.selectWorkorder = function(event, workorder) {
    workorderFlowService.workorderSelected(workorder);

    event.preventDefault();
    event.stopPropagation();
  };

  self.isWorkorderShown = function(workorder) {
    return self.shownWorkorder === workorder;
  };

  self.applyFilter = function(term) {
    self.term = term;
    self.updateFilter();
  };

  self.updateFilter = _.debounce(function() {
    $scope.$apply(function() {
      if (!self.term) {
        return self.workorders = _workorders;
      }
      if (self.term.length > 3) {
        var term = self.term.toLowerCase();
        self.workorders = _workorders.filter(function(workflow) {
          return String(workflow.title).toLowerCase().indexOf(term) !== -1
            || String(workflow.id).indexOf(term) !== -1;
        });
      }
    });
  }, 300);

  self.getColorIcon = function(workorder) {
    if (!workorder || !workorder.status) {
      return workorderStatusService.getStatusIconColor('').statusColor;
    } else {
      return workorderStatusService.getStatusIconColor(workorder.status).statusColor;
    }
  };

  self.setupEventListenerHandlers = function() {
    workorderService.on('create', function(workorder) {
      _workorders.push(workorder);
      self.updateFilter();
    });

    workorderService.on('remove', function(workorder) {
      _.remove(_workorders, function(w) {
        return w.id === workorder.id;
      });
      self.updateFilter();
    });

    workorderService.on('update', function(workorder) {
      var idx = _.findIndex(_workorders, function(w) {
        return w.id === workorder.id;
      });

      _workorders.splice(idx, 1, workorder);
      self.updateFilter();
    });
  };

  if (workorderService.on) {
    self.setupEventListenerHandlers();
  } else if (workorderService.subscribeToDatasetUpdates) {
    // use the single method to update workorders via sync
    workorderService.subscribeToDatasetUpdates(refreshWorkorders);
  }
}
672725
function WorkflowProcessStepsController($scope, $state, wfmService, $timeout, $stateParams) {
  var self = this;
  var workorderId = $stateParams.workorderId;

  function updateWorkflowState(workorder) {
    //If the workflow is complete, then we can switch to the summary view.
    if (wfmService.isCompleted(workorder)) {
      return $state.go('app.workflowProcess.complete', {
        workorderId: workorder.id
      });
    }

    if (!wfmService.isOnStep(workorder)) {
      return $state.go('app.workflowProcess.begin', {
        workorderId: workorder.id
      });
    }

    $timeout(function() {
      self.workorder = workorder;
      self.workflow = workorder.workflow;
      self.result = workorder.results;
      self.stepIndex = wfmService.getCurrentStepIdx(workorder);
      self.stepCurrent = wfmService.getCurrentStep(workorder);
    });
  }

  self.back = function() {
    wfmService.previousStep(workorderId)
      .then(updateWorkflowState)
      .catch(console.error);
  };

  self.triggerCompleteStep = function(submission) {
    wfmService.completeStep(workorderId, submission)
      .then(updateWorkflowState)
      .catch(console.error);
  };

  self.triggerBackStep = function() {
    self.back();
  };

  wfmService.readWorkOrder(workorderId).then(updateWorkflowState);
}
481940
def has_completed(self):
        """"""
        objects_in_db = WorkflowObjectModel.query.filter(
            WorkflowObjectModel.id_workflow == self.uuid,
            WorkflowObjectModel.id_parent == None,  # noqa
        ).filter(WorkflowObjectModel.status.in_([
            workflow_object_class.known_statuses.COMPLETED
        ])).count()
        return objects_in_db == len(list(self.objects))
187320
def show_title(decorated)
      raise ::ArgumentError unless decorated.is_a? ResourceDecorator
      [
        to_model_label(decorated.model_class), decorated.to_label
      ].compact.join ': '
    end
631634
function findIssueByTitle (client, repo, title) {
  title = title.toLowerCase();
  return allIssues(client, repo).then(_.partialRight(_.find, function (issue) {
    return issue.title.toLowerCase() === title;
  }));
}
853442
def lookup_action #:nodoc:
      @lookup_action ||= begin
        action = template.controller && template.controller.action_name
        return unless action
        action = action.to_s
        ACTIONS[action] || action
      end
    end
641422
function(control) {
      return this._events.some(function (evt) {
         if (evt.eventType === "StartChildWorkflowExecutionInitiated") {
            if (evt.startChildWorkflowExecutionInitiatedEventAttributes.control === control) {
               return true;
            }
         }
      });
   }
667522
function title_true()
	{
		if(method_exists($this, 'title'))
			return $this->title();

		if(!empty($this->attr['title']))
			return $this->attr['title'];

		if(!empty($this->data['title']))
			return $this->data['title'];

		return NULL;
	}
740165
public function title()
    {
        if ($this->title === null) {
            $title = null;

            $translator = $this->translator();

            try {
                $config = $this->dashboardConfig();
            } catch (Exception $e) {
                $this->logger->error($e->getMessage());
                $config = [];
            }

            if (isset($config['title'])) {
                $title = $translator->translation($config['title']);
            } else {
                $obj      = $this->obj();
                $objId    = $this->objId();
                $objType  = $this->objType();
                $metadata = $obj->metadata();

                if (!$title && isset($metadata['admin']['forms'])) {
                    $adminMetadata = $metadata['admin'];

                    $formIdent = filter_input(INPUT_GET, 'form_ident', FILTER_SANITIZE_STRING);
                    if (!$formIdent) {
                        $formIdent = (isset($adminMetadata['default_form']) ? $adminMetadata['default_form'] : '');
                    }

                    if (isset($adminMetadata['forms'][$formIdent]['label'])) {
                        $title = $translator->translation($adminMetadata['forms'][$formIdent]['label']);
                    }
                }

                if ($objId) {
                    if (!$title && isset($metadata['labels']['edit_item'])) {
                        $title = $translator->translation($metadata['labels']['edit_item']);
                    }

                    if (!$title && isset($metadata['labels']['edit_model'])) {
                        $title = $translator->translation($metadata['labels']['edit_model']);
                    }
                } else {
                    if (!$title && isset($metadata['labels']['new_item'])) {
                        $title = $translator->translation($metadata['labels']['new_item']);
                    }

                    if (!$title && isset($metadata['labels']['new_model'])) {
                        $title = $translator->translation($metadata['labels']['new_model']);
                    }
                }

                if (!$title) {
                    $objType = (isset($metadata['labels']['singular_name'])
                                ? $translator->translation($metadata['labels']['singular_name'])
                                : null);

                    if ($objId) {
                        $title = $translator->translation('Edit: {{ objType }} #{{ id }}');
                    } elseif (!empty($_GET['clone_id'])) {
                        $title = sprintf(
                            $translator->translation('Create: {{ objType }} from ID ""%s""'),
                            $_GET['clone_id']
                        );
                    } else {
                        $title = $translator->translation('Create: {{ objType }}');
                    }

                    if ($objType) {
                        $title = strtr($title, [
                            '{{ objType }}' => $objType
                        ]);
                    }
                }
            }

            $this->title = $this->renderTitle($title);
        }

        return $this->title;
    }
1022180
private boolean checkEventsControllers(EventModel event) {
        List<CompletableFuture<Boolean>> collect = eventsControllers.stream()
                .map(controller -> submit(() -> controller.controlEventDispatcher(event)).thenApply(result -> {
                    if (!result)
                        debug("Event: " + event + " is canceled by " + controller.getID());
                    return result;
                }))
                .collect(Collectors.toList());
        try {
            collect = timeOut(collect, 1000);
        } catch (InterruptedException e) {
            debug("interrupted");
        }
        return collect.stream()
                .map(future -> {
                    try {
                        return future.get();
                    } catch (InterruptedException | ExecutionException e) {
                        return null;
                    }
                })
                .filter(Objects::nonNull)
                .noneMatch(bool -> !bool);
    }
1177231
def full_title(self):
        """"""
        cancelled_str = " (Cancelled)" if self.cancelled else ""
        act_name = self.activity.name + cancelled_str
        if self.special and not self.activity.special:
            act_name = "Special: " + act_name
        return act_name if not self.title else "{} - {}".format(act_name, self.title)
867834
function() {
			return {
				title: this.input.val().trim(),
				order: window.app.Todos.nextOrder(),
				completed: false
			};
		}