Get available transitions for a ticket.

@param string $issue_key Issue key should be "YOURPROJ-22".
@param array  $params    Params.

@return Result|false
501188
public function getTransitions($issue_key, array $params)
	{
		return $this->api(self::REQUEST_GET, sprintf('/rest/api/2/issue/%s/transitions', $issue_key), $params);
	}
213918
def call(issue)
      status = decode_status(issue)
      {
          key: issue.key,
          type: issue.issuetype.name,
          priority: issue.priority.name,
          status: status,
          #description: i.description,
          summary: issue.summary,
          created_date: issue.created,
          closed_date: issue.resolutiondate
      }
    end
758828
static function getWorkflowState($workflow_key) {
        $status = self::STATUS_COMPLETED;
        $created_after = "-20 years";
        $data = DataStore::retrieveMostCurrentWorkflowJobByAgeAndStatus($workflow_key, $status, $created_after);
        if ($data) {
            return $data["end_state"];
        } else {
            $workflow = DataStore::retrieveWorkflow($workflow_key);
            if (!$workflow) {
                throw new \Exception("Error retrieving workflow for key $workflow_key can't determine state.");
            }
            $data = $workflow->getData();
            return $data[self::CONF_INITIAL_STATE];
        }
    }
1094096
public function ask($routing_key, $message, $timeout = 10, $exchange = null)
    {
        return $this->amqp->ask($exchange ?: $this->exchange, $routing_key, $message, $timeout);
    }
1051514
def transitions(accountable):
    
    transitions = accountable.issue_transitions().get('transitions')
    headers = ['id', 'name']
    if transitions:
        rows = [[v for k, v in sorted(t.items()) if k in headers]
                for t in transitions]
        rows.insert(0, headers)
        print_table(SingleTable(rows))
    else:
        click.secho(
            'No transitions found for {}'.format(accountable.issue_key),
            fg='red'
        )
18324
def issue(self, issue_instance_id):
        
        with self.db.make_session() as session:
            selected_issue = (
                session.query(IssueInstance)
                .filter(IssueInstance.id == issue_instance_id)
                .scalar()
            )

            if selected_issue is None:
                self.warning(
                    f"Issue {issue_instance_id} doesn't exist. "
                    "Type 'issues' for available issues."
                )
                return

            self.sources = self._get_leaves_issue_instance(
                session, issue_instance_id, SharedTextKind.SOURCE
            )

            self.sinks = self._get_leaves_issue_instance(
                session, issue_instance_id, SharedTextKind.SINK
            )

        self.current_issue_instance_id = int(selected_issue.id)
        self.current_frame_id = -1
        self.current_trace_frame_index = 1  # first one after the source

        print(f"Set issue to {issue_instance_id}.")
        if int(selected_issue.run_id) != self.current_run_id:
            self.current_run_id = int(selected_issue.run_id)
            print(f"Set run to {self.current_run_id}.")
        print()

        self._generate_trace_from_issue()
        self.show()
489402
def confirm_reservation(reservation_key: '', payment_method: '', amount_paid: nil)

      # step 1: confirm
      path = "reservation/#{reservation_key}/confirm"
      body = {
        PaymentMethod: payment_method,
        AmountPaid: amount_paid
      }
      call(path, http_method: :post, body: body.to_json)

      # step 2: get tickets
      # GET /api/v1/reservation/{reservationKey}/tickets
      path = "reservation/#{reservation_key}/tickets"
      result = call(path, http_method: :get)

      # define new list
      list = []

      for ticket in result
        list << ShakeTheCounter::Ticket.new(ticket)
      end
      return list
    end
1093019
def get_sla_by_id(self, issue_id_or_key, sla_id):
        
        url = 'rest/servicedeskapi/request/{0}/sla/{1}'.format(issue_id_or_key, sla_id)

        return self.get(url)
1074127
public function setCustomErrorLevel($issue_key, $error_level)
    {
        $this->issue_handlers[$issue_key] = new IssueHandler();
        $this->issue_handlers[$issue_key]->setErrorLevel($error_level);
    }
1135548
public function issues()
    {
        if (is_null($this->issueRequests)) {
            $this->issueRequests = new IssueRequests($this->client);
        }

        return $this->issueRequests;
    }
1178117
def get_issue_remote_links(self, issue_key, global_id=None, internal_id=None):
        
        url = 'rest/api/2/issue/{issue_key}/remotelink'.format(issue_key=issue_key)
        params = {}
        if global_id:
            params['globalId'] = global_id
        if internal_id:
            url += '/' + internal_id
        return self.get(url, params=params)
217587
public function getIssues()
	{
		if ( isset($this->result['issues']) ) {
			$result = array();

			foreach ( $this->result['issues'] as $issue ) {
				$result[] = new Issue($issue);
			}

			return $result;
		}

		return array();
	}
543530
@RequestMapping(value = "configuration/{configuration:.*}/issue/{key}", method = RequestMethod.GET)
    public Resource<OntrackSVNIssueInfo> issueInfo(@PathVariable String configuration, @PathVariable String key) {
        return Resource.of(
                svnInfoService.getIssueInfo(configuration, key),
                uri(on(getClass()).issueInfo(configuration, key))
        ).withView(Build.class);
    }
382469
static public function jiraPostIssueTransition(array $configuration, $key, $transitionId)
    {
        return self::json(
            $configuration['host']
                . sprintf(
                    $configuration['endpoint']['transition'],
                    $key
                ),
            json_encode([
                'transition' => [
                    'id' => $transitionId,
                ],
            ]),
            self::HTTP_METHOD_POST,
            [
                'Authorization: Basic ' . $configuration['loginHash']
            ]
        );
    }
1013920
func (s *IssueService) GetTransitions(id string) ([]Transition, *Response, error) {
	apiEndpoint := fmt.Sprintf("rest/api/2/issue/%s/transitions?expand=transitions.fields", id)
	req, err := s.client.NewRequest("GET", apiEndpoint, nil)
	if err != nil {
		return nil, nil, err
	}

	result := new(transitionResult)
	resp, err := s.client.Do(req, result)
	if err != nil {
		err = NewJiraError(resp, err)
	}
	return result.Transitions, resp, err
}
398145
public function getReportingLevelForClass($issue_type, $fq_classlike_name)
    {
        if (isset($this->issue_handlers[$issue_type])) {
            return $this->issue_handlers[$issue_type]->getReportingLevelForClass($fq_classlike_name);
        }
    }
372358
def add_issue_status(self, name, **attrs):
        
        return IssueStatuses(self.requester).create(self.id, name, **attrs)