| |
| import logging |
| import re |
|
|
| from requests import HTTPError |
|
|
| from .errors import ApiNotFoundError, ApiPermissionError |
| from .rest_client import AtlassianRestAPI |
|
|
| log = logging.getLogger(__name__) |
|
|
|
|
| class Jira(AtlassianRestAPI): |
| """ |
| Provide permission information for the current user. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2 |
| """ |
|
|
| def get_permissions(self, project_id=None, project_key=None, issue_id=None, issue_key=None): |
| """ |
| Returns all permissions in the system and whether the currently logged in user has them. |
| You can optionally provide a specific context |
| to get permissions for (projectKey OR projectId OR issueKey OR issueId) |
| When no context supplied the project related permissions will return true |
| if the user has that permission in ANY project |
| If a project context is provided, project related permissions will return true |
| if the user has the permissions in the specified project. |
| For permissions that are determined using issue data (e.g Current Assignee), true will be returned |
| if the user meets the permission criteria in ANY issue in that project If an issue context is provided, |
| it will return whether or not the user has each permission in that specific issue |
| NB: The above means that for issue-level permissions (EDIT_ISSUE for example), |
| hasPermission may be true when no context is provided, or when a project context is provided, |
| but may be false for any given (or all) issues. This would occur (for example) |
| if Reporters were given the EDIT_ISSUE permission. |
| This is because any user could be a reporter, |
| except in the context of a concrete issue, where the reporter is known. |
| |
| Global permissions will still be returned for all scopes. |
| |
| Prior to version 6.4 this service returned project permissions with keys corresponding to |
| com.atlassian.jira.security.Permissions.Permission constants. |
| Since 6.4 those keys are considered deprecated and this service returns system project permission keys |
| corresponding to constants defined in com.atlassian.jira.permission.ProjectPermissions. |
| Permissions with legacy keys are still also returned for backwards compatibility, |
| they are marked with an attribute deprecatedKey=true. |
| The attribute is missing for project permissions with the current keys. |
| |
| :param project_id: (str) id of project to scope returned permissions for. |
| :param project_key: (str) key of project to scope returned permissions for. |
| :param issue_id: (str) key of the issue to scope returned permissions for. |
| :param issue_key: (str) id of the issue to scope returned permissions for. |
| :return: |
| """ |
| url = "rest/api/2/mypermissions" |
| params = {} |
|
|
| if project_id: |
| params["projectId"] = project_id |
| if project_key: |
| params["projectKey"] = project_key |
| if issue_id: |
| params["issueId"] = issue_id |
| if issue_key: |
| params["issueKey"] = issue_key |
|
|
| return self.get(url, params=params) |
|
|
| def get_all_permissions(self): |
| """ |
| Returns all permissions that are present in the Jira instance - |
| Global, Project and the global ones added by plugins |
| :return: All permissions |
| """ |
| url = "rest/api/2/permissions" |
| return self.get(url) |
|
|
| """ |
| Application properties |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/application-properties |
| """ |
|
|
| def get_property(self, key=None, permission_level=None, key_filter=None): |
| """ |
| Returns an application property |
| :param key: str |
| :param permission_level: str |
| :param key_filter: str |
| :return: list or item |
| """ |
| url = "rest/api/2/application-properties" |
| params = {} |
|
|
| if key: |
| params["key"] = key |
| if permission_level: |
| params["permissionLevel"] = permission_level |
| if key_filter: |
| params["keyFilter"] = key_filter |
|
|
| return self.get(url, params=params) |
|
|
| def set_property(self, property_id, value): |
| """ |
| Modify an application property via PUT. The "value" field present in the PUT will override the existing value. |
| :param property_id: |
| :param value: |
| :return: |
| """ |
| url = "rest/api/2/application-properties/{}".format(property_id) |
| data = {"id": property_id, "value": value} |
|
|
| return self.put(url, data=data) |
|
|
| def get_advanced_settings(self): |
| """ |
| Returns the properties that are displayed on the "General Configuration > Advanced Settings" page |
| :return: |
| """ |
| url = "rest/api/2/application-properties/advanced-settings" |
|
|
| return self.get(url) |
|
|
| """ |
| Application roles. Provides REST access to JIRA's Application Roles. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/applicationrole |
| """ |
|
|
| def get_all_application_roles(self): |
| """ |
| Returns all ApplicationRoles in the system |
| :return: |
| """ |
| url = "rest/api/2/applicationrole" |
| return self.get(url) or {} |
|
|
| def get_application_role(self, role_key): |
| """ |
| Returns the ApplicationRole with passed key if it exists |
| :param role_key: str |
| :return: |
| """ |
| url = "rest/api/2/applicationrole/{}".format(role_key) |
| return self.get(url) or {} |
|
|
| """ |
| Attachments |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/attachment |
| """ |
|
|
| def get_attachment(self, attachment_id): |
| """ |
| Returns the meta-data for an attachment, including the URI of the actual attached file |
| :param attachment_id: int |
| :return: |
| """ |
| url = "rest/api/2/attachment/{}".format(attachment_id) |
| return self.get(url) |
|
|
| def remove_attachment(self, attachment_id): |
| """ |
| Remove an attachment from an issue |
| :param attachment_id: int |
| :return: if success, return None |
| """ |
| url = "rest/api/2/attachment/{}".format(attachment_id) |
| return self.delete(url) |
|
|
| def get_attachment_meta(self): |
| """ |
| Returns the meta information for an attachments, |
| specifically if they are enabled and the maximum upload size allowed |
| :return: |
| """ |
| url = "rest/api/2/attachment/meta" |
| return self.get(url) |
|
|
| def get_attachment_expand_human(self, attachment_id): |
| """ |
| Returns the information for an expandable attachment in human-readable format |
| :param attachment_id: int |
| :return: |
| """ |
| url = "rest/api/2/attachment/{}/expand/human".format(attachment_id) |
| return self.get(url) |
|
|
| def get_attachment_expand_raw(self, attachment_id): |
| """ |
| Returns the information for an expandable attachment in raw format |
| :param attachment_id: int |
| :return: |
| """ |
| url = "rest/api/2/attachment/{}/expand/raw".format(attachment_id) |
| return self.get(url) |
|
|
| """ |
| Audit Records. Resource representing the auditing records |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/auditing |
| """ |
|
|
| def get_audit_records(self, offset=None, limit=None, filter=None, from_date=None, to_date=None): |
| """ |
| Returns auditing records filtered using provided parameters |
| :param offset: the number of record from which search starts |
| :param limit: maximum number of returned results (if is limit is <= 0 or > 1000, |
| it will be set do default value: 1000) |
| :param str filter: text query; each record that will be returned must contain |
| the provided text in one of it's fields. |
| :param str from_date: timestamp in past; 'from' must be less or equal 'to', |
| otherwise the result set will be empty only records that where created in the same moment or after |
| the 'from' timestamp will be provided in response |
| :param str to_date: timestamp in past; 'from' must be less or equal 'to', |
| otherwise the result set will be empty only records that where created in the same moment or earlier than |
| the 'to' timestamp will be provided in response |
| :return: |
| """ |
| params = {} |
| if offset: |
| params["offset"] = offset |
| if limit: |
| params["limit"] = limit |
| if filter: |
| params["filter"] = filter |
| if from_date: |
| params["from"] = from_date |
| if to_date: |
| params["to"] = to_date |
| url = "rest/api/2/auditing/record" |
| return self.get(url, params=params) or {} |
|
|
| def post_audit_record(self, audit_record): |
| """ |
| Store a record in Audit Log |
| :param audit_record: json with compat https://docs.atlassian.com/jira/REST/schema/audit-record# |
| :return: |
| """ |
| url = "rest/api/2/auditing/record" |
| return self.post(url, data=audit_record) |
|
|
| """ |
| Avatar |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/avatar |
| """ |
|
|
| def get_all_system_avatars(self, avatar_type="user"): |
| """ |
| Returns all system avatars of the given type. |
| :param avatar_type: |
| :return: Returns a map containing a list of system avatars. |
| A map is returned to be consistent with the shape of the project/KEY/avatars REST end point. |
| """ |
| url = "rest/api/2/avatar/{type}/system".format(type=avatar_type) |
| return self.get(url) |
|
|
| """ |
| Cluster. (Available for DC) It gives possibility to manage old node in cluster. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/cluster |
| """ |
|
|
| def get_cluster_all_nodes(self): |
| url = "rest/api/2/cluster/nodes" |
| return self.get(url) |
|
|
| def delete_cluster_node(self, node_id): |
| """ |
| Delete the node from the cluster if state of node is OFFLINE |
| :param node_id: str |
| :return: |
| """ |
| url = "rest/api/2/cluster/node/{}".format(node_id) |
| return self.delete(url) |
|
|
| def set_node_to_offline(self, node_id): |
| """ |
| Change the node's state to offline if the node is reporting as active, but is not alive |
| :param node_id: str |
| :return: |
| """ |
| url = "rest/api/2/cluster/node/{}/offline".format(node_id) |
| return self.put(url) |
|
|
| def get_cluster_alive_nodes(self): |
| """ |
| Get cluster nodes where alive = True |
| :return: list of node dicts |
| """ |
| return [_ for _ in self.get_cluster_all_nodes() if _["alive"]] |
|
|
| """ |
| Troubleshooting. (Available for DC) It gives the posibility to download support zips. |
| Reference: https://confluence.atlassian.com/support/create-a-support-zip-using-the-rest-api-in-data-center-applications-952054641.html |
| """ |
|
|
| def generate_support_zip_on_nodes(self, node_ids): |
| """ |
| Generate a support zip on targeted nodes of a cluster |
| :param node_ids: list |
| :return: dict representing cluster task created |
| """ |
| data = {"nodeIds": node_ids} |
| url = "/rest/troubleshooting/latest/support-zip/cluster" |
| return self.post(url, data=data) |
|
|
| def check_support_zip_status(self, cluster_task_id): |
| """ |
| Check status of support zip creation task |
| :param cluster_task_id: str |
| :return: |
| """ |
| url = "/rest/troubleshooting/latest/support-zip/status/cluster/{}".format(cluster_task_id) |
| return self.get(url) |
|
|
| def download_support_zip(self, file_name): |
| """ |
| Download created support zip file |
| :param file_name: str |
| :return: bytes of zip file |
| """ |
| url = "/rest/troubleshooting/latest/support-zip/download/{}".format(file_name) |
| return self.get(url, advanced_mode=True).content |
|
|
| """ |
| ZDU (Zero Downtime upgrade) module. (Available for DC) |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/cluster/zdu |
| """ |
|
|
| def get_cluster_zdu_state(self): |
| url = "rest/api/2/cluster/zdu/state" |
| return self.get(url) |
|
|
| """ |
| Comments properties |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/comment/{commentId}/properties |
| """ |
|
|
| def get_comment_properties_keys(self, comment_id): |
| """ |
| Returns the keys of all properties for the comment identified by the key or by the id. |
| :param comment_id: |
| :return: |
| """ |
| url = "rest/api/2/comment/{commentId}/properties".format(commentId=comment_id) |
| return self.get(url) |
|
|
| def get_comment_property(self, comment_id, property_key): |
| """ |
| Returns the value a property for a comment |
| :param comment_id: int |
| :param property_key: str |
| :return: |
| """ |
| url = "rest/api/2/comment/{commentId}/properties/{propertyKey}".format( |
| commentId=comment_id, propertyKey=property_key |
| ) |
| return self.get(url) |
|
|
| def set_comment_property(self, comment_id, property_key, value_property): |
| """ |
| Returns the keys of all properties for the comment identified by the key or by the id. |
| :param comment_id: int |
| :param property_key: str |
| :param value_property: object |
| :return: |
| """ |
| url = "rest/api/2/comment/{commentId}/properties/{propertyKey}".format( |
| commentId=comment_id, propertyKey=property_key |
| ) |
| data = {"value": value_property} |
| return self.put(url, data=data) |
|
|
| def delete_comment_property(self, comment_id, property_key): |
| """ |
| Deletes a property for a comment |
| :param comment_id: int |
| :param property_key: str |
| :return: |
| """ |
| url = "rest/api/2/comment/{commentId}/properties/{propertyKey}".format( |
| commentId=comment_id, propertyKey=property_key |
| ) |
| return self.delete(url) |
|
|
| """ |
| Component |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/component |
| """ |
|
|
| def component(self, component_id): |
| return self.get("rest/api/2/component/{component_id}".format(component_id=component_id)) |
|
|
| def get_component_related_issues(self, component_id): |
| """ |
| Returns counts of issues related to this component. |
| :param component_id: |
| :return: |
| """ |
| url = "rest/api/2/component/{component_id}/relatedIssueCounts".format(component_id=component_id) |
| return self.get(url) |
|
|
| def create_component(self, component): |
| log.warning('Creating component "{name}"'.format(name=component["name"])) |
| url = "rest/api/2/component/" |
| return self.post(url, data=component) |
|
|
| def delete_component(self, component_id): |
| log.warning('Deleting component "{component_id}"'.format(component_id=component_id)) |
| return self.delete("rest/api/2/component/{component_id}".format(component_id=component_id)) |
|
|
| def update_component_lead(self, component_id, lead): |
| data = {"id": component_id, "leadUserName": lead} |
| return self.put( |
| "rest/api/2/component/{component_id}".format(component_id=component_id), |
| data=data, |
| ) |
|
|
| """ |
| Configurations of Jira |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/configuration |
| """ |
|
|
| def get_configurations_of_jira(self): |
| """ |
| Returns the information if the optional features in JIRA are enabled or disabled. |
| If the time tracking is enabled, it also returns the detailed information about time tracking configuration. |
| :return: |
| """ |
| url = "rest/api/2/configuration" |
| return self.get(url) |
|
|
| """ |
| Custom Field |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/customFieldOption |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/customFields |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/field |
| """ |
|
|
| def get_custom_field_option(self, option_id): |
| """ |
| Returns a full representation of the Custom Field Option that has the given id. |
| :param option_id: |
| :return: |
| """ |
| url = "rest/api/2/customFieldOption/{id}".format(id=option_id) |
| return self.get(url) |
|
|
| def get_custom_fields(self, search=None, start=1, limit=50): |
| """ |
| Get custom fields. Evaluated on 7.12 |
| :param search: str |
| :param start: long Default: 1 |
| :param limit: int Default: 50 |
| :return: |
| """ |
| url = "rest/api/2/customFields" |
| params = {} |
| if search: |
| params["search"] = search |
| if start: |
| params["startAt"] = start |
| if limit: |
| params["maxResults"] = limit |
| return self.get(url, params=params) |
|
|
| def get_all_fields(self): |
| """ |
| Returns a list of all fields, both System and Custom |
| :return: application/jsonContains a full representation of all visible fields in JSON. |
| """ |
| url = "rest/api/2/field" |
| return self.get(url) |
|
|
| def create_custom_field(self, name, type, search_key=None, description=None): |
| """ |
| Creates a custom field with the given name and type |
| :param name: str |
| :param type: str, like 'com.atlassian.jira.plugin.system.customfieldtypes:textfield' |
| :param search_key: str, like above |
| :param description: str |
| """ |
| url = "rest/api/2/field" |
| data = {"name": name, "type": type} |
| if search_key: |
| data["search_key"] = search_key |
| if description: |
| data["description"] = description |
| return self.post(url, data=data) |
|
|
| """ |
| Dashboards |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/dashboard |
| """ |
|
|
| def get_dashboards(self, filter="", start=0, limit=10): |
| """ |
| Returns a list of all dashboards, optionally filtering them. |
| :param filter: OPTIONAL: an optional filter that is applied to the list of dashboards. |
| Valid values include "favourite" for returning only favourite dashboards, |
| and "my" for returning dashboards that are owned by the calling user. |
| :param start: the index of the first dashboard to return (0-based). must be 0 or a multiple of maxResults |
| :param limit: a hint as to the the maximum number of dashboards to return in each call. |
| Note that the JIRA server reserves the right to impose a maxResults limit that is lower |
| than the value that a client provides, dues to lack or resources or any other condition. |
| When this happens, your results will be truncated. |
| Callers should always check the returned maxResults to determine |
| the value that is effectively being used. |
| :return: |
| """ |
| params = {} |
| if filter: |
| params["filter"] = filter |
| if start: |
| params["startAt"] = start |
| if limit: |
| params["maxResults"] = limit |
| url = "rest/api/2/dashboard" |
| return self.get(url, params=params) |
|
|
| """ |
| Filters. Resource for searches |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/filter |
| """ |
|
|
| def create_filter(self, name, jql, description=None, favourite=False): |
| """ |
| :param name: str |
| :param jql: str |
| :param description: str, Optional. Empty string by default |
| :param favourite: bool, Optional. False by default |
| """ |
| data = { |
| "jql": jql, |
| "name": name, |
| "description": description if description else "", |
| "favourite": "true" if favourite else "false", |
| } |
| url = "rest/api/2/filter" |
| return self.post(url, data=data) |
|
|
| def get_filter(self, filter_id): |
| """ |
| Returns a full representation of a filter that has the given id. |
| :param filter_id: |
| :return: |
| """ |
| url = "rest/api/2/filter/{id}".format(id=filter_id) |
| return self.get(url) |
|
|
| def delete_filter(self, filter_id): |
| """ |
| Deletes a filter that has the given id. |
| :param filter_id: |
| :return: |
| """ |
| url = "rest/api/2/filter/{id}".format(id=filter_id) |
| return self.delete(url) |
|
|
| """ |
| Group. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/group |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/groups |
| """ |
|
|
| def get_groups(self, query=None, exclude=None, limit=20): |
| """ |
| REST endpoint for searching groups in a group picker |
| Returns groups with substrings matching a given query. This is mainly for use with the group picker, |
| so the returned groups contain html to be used as picker suggestions. The groups are also wrapped |
| in a single response object that also contains a header for use in the picker, |
| specifically Showing X of Y matching groups. |
| The number of groups returned is limited by the system property "jira.ajax.autocomplete.limit" |
| The groups will be unique and sorted. |
| :param query: str |
| :param exclude: str |
| :param limit: int |
| :return: Returned even if no groups match the given substring |
| """ |
| url = "rest/api/2/groups/picker" |
| params = {} |
| if query: |
| params["query"] = query |
| else: |
| params["query"] = "" |
| if exclude: |
| params["exclude"] = exclude |
| if limit: |
| params["maxResults"] = limit |
| return self.get(url, params=params) |
|
|
| def create_group(self, name): |
| """ |
| Create a group by given group parameter |
| |
| :param name: str |
| :return: New group params |
| """ |
| url = "rest/api/2/group" |
| data = {"name": name} |
|
|
| return self.post(url, data=data) |
|
|
| def remove_group(self, name, swap_group=None): |
| """ |
| Delete a group by given group parameter |
| If you delete a group and content is restricted to that group, the content will be hidden from all users |
| To prevent this, use this parameter to specify a different group to transfer the restrictions |
| (comments and worklogs only) to |
| |
| :param name: str |
| :param swap_group: str |
| :return: |
| """ |
| log.warning("Removing group...") |
| url = "rest/api/2/group" |
| if swap_group is not None: |
| params = {"groupname": name, "swapGroup": swap_group} |
| else: |
| params = {"groupname": name} |
|
|
| return self.delete(url, params=params) |
|
|
| def get_all_users_from_group(self, group, include_inactive_users=False, start=0, limit=50): |
| """ |
| Just wrapping method user group members |
| :param group: |
| :param include_inactive_users: |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of users to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :return: |
| """ |
| url = "rest/api/2/group/member" |
| params = {} |
| if group: |
| params["groupname"] = group |
| params["includeInactiveUsers"] = include_inactive_users |
| params["startAt"] = start |
| params["maxResults"] = limit |
| return self.get(url, params=params) |
|
|
| def add_user_to_group(self, username, group_name): |
| """ |
| Add given user to a group |
| |
| :param username: str |
| :param group_name: str |
| :return: Current state of the group |
| """ |
| url = "rest/api/2/group/user" |
| params = {"groupname": group_name} |
| data = {"name": username} |
|
|
| return self.post(url, params=params, data=data) |
|
|
| def remove_user_from_group(self, username, group_name): |
| """ |
| Remove given user from a group |
| |
| :param username: str |
| :param group_name: str |
| :return: |
| """ |
| log.warning("Removing user from a group...") |
| url = "rest/api/2/group/user" |
| params = {"groupname": group_name, "username": username} |
|
|
| return self.delete(url, params=params) |
|
|
| """ |
| Issue |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/issue |
| """ |
|
|
| def issue(self, key, fields="*all", expand=None): |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get("rest/api/2/issue/{0}?fields={1}".format(key, fields), params=params) |
|
|
| def get_issue(self, issue_id_or_key, fields=None, properties=None, update_history=True): |
| """ |
| Returns a full representation of the issue for the given issue key |
| By default, all fields are returned in this get-issue resource |
| |
| :param issue_id_or_key: str |
| :param fields: str |
| :param properties: str |
| :param update_history: bool |
| :return: issue |
| """ |
| url = "rest/api/2/issue/{}".format(issue_id_or_key) |
| params = {} |
|
|
| if fields is not None: |
| if isinstance(fields, (list, tuple, set)): |
| fields = ",".join(fields) |
| params["fields"] = fields |
| if properties is not None: |
| params["properties"] = properties |
| if update_history is True: |
| params["updateHistory"] = "true" |
| if update_history is False: |
| params["updateHistory"] = "false" |
|
|
| return self.get(url, params=params) |
|
|
| def bulk_issue(self, issue_list, fields="*all"): |
| """ |
| :param fields: |
| :param list issue_list: |
| :return: |
| """ |
| jira_issue_regex = re.compile(r"[A-Z]{1,10}-\d+") |
| missing_issues = list() |
| matched_issue_keys = list() |
| for key in issue_list: |
| if re.match(jira_issue_regex, key): |
| matched_issue_keys.append(key) |
| jql = "key in ({})".format(", ".join(set(matched_issue_keys))) |
| query_result = self.jql(jql, fields=fields) |
| if "errorMessages" in query_result.keys(): |
| for message in query_result["errorMessages"]: |
| for key in issue_list: |
| if key in message: |
| missing_issues.append(key) |
| issue_list.remove(key) |
| query_result, missing_issues = self.bulk_issue(issue_list, fields) |
| return query_result, missing_issues |
|
|
| def issue_createmeta(self, project, expand="projects.issuetypes.fields"): |
| params = {} |
| if expand: |
| params["expand"] = expand |
| url = "rest/api/2/issue/createmeta?projectKeys={}".format(project) |
| return self.get(url, params=params) |
|
|
| def get_issue_changelog(self, issue_key): |
| """ |
| Get issue related change log |
| :param issue_key: |
| :return: |
| """ |
| url = "rest/api/2/issue/{}?expand=changelog".format(issue_key) |
| return (self.get(url) or {}).get("changelog") |
|
|
| def issue_add_json_worklog(self, key, worklog): |
| """ |
| |
| :param key: |
| :param worklog: |
| :return: |
| """ |
| url = "rest/api/2/issue/{}/worklog".format(key) |
| return self.post(url, data=worklog) |
|
|
| def issue_worklog(self, key, started, time_sec, comment=None): |
| """ |
| :param key: |
| :param time_sec: int: second |
| :param started: str: format ``%Y-%m-%dT%H:%M:%S.000+0000%z`` |
| :param comment: |
| :return: |
| """ |
| data = {"started": started, "timeSpentSeconds": time_sec} |
| if comment: |
| data["comment"] = comment |
| return self.issue_add_json_worklog(key=key, worklog=data) |
|
|
| def issue_get_worklog(self, issue_id_or_key): |
| """ |
| Returns all work logs for an issue. |
| Note: Work logs won't be returned if the Log work field is hidden for the project. |
| :param issue_id_or_key: |
| :return: |
| """ |
| url = "rest/api/2/issue/{issueIdOrKey}/worklog".format(issueIdOrKey=issue_id_or_key) |
|
|
| return self.get(url) |
|
|
| def issue_archive(self, issue_id_or_key, notify_users=False): |
| """ |
| Archives an issue. |
| :param issue_id_or_key: Issue id or issue key |
| :param notify_users: send the email with notification that the issue was updated to users that watch it. |
| Admin or project admin permissions are required to disable the notification. |
| :return: |
| """ |
| params = {} |
| if notify_users: |
| params["notifyUsers"] = "true" |
| else: |
| params["notifyUsers"] = "false" |
| url = "rest/api/2/issue/{issueIdOrKey}/archive".format(issueIdOrKey=issue_id_or_key) |
| return self.get(url) |
|
|
| def issue_field_value(self, key, field, expand=None): |
| params = {} |
| if expand: |
| params["expand"] = expand |
| issue = self.get("rest/api/2/issue/{0}?fields={1}".format(key, field), params=params) |
| return issue["fields"][field] |
|
|
| def issue_fields(self, key): |
| issue = self.get("rest/api/2/issue/{0}".format(key)) |
| return issue["fields"] |
|
|
| def update_issue_field(self, key, fields="*all"): |
| return self.put("rest/api/2/issue/{0}".format(key), data={"fields": fields}) |
|
|
| def bulk_update_issue_field(self, key_list, fields="*all"): |
| """ |
| :param key_list=list of issues with common filed to be updated |
| :param fields: common fields to be updated |
| return Boolean True/False |
| """ |
| try: |
| for key in key_list: |
| self.put("rest/api/2/issue/{0}".format(key), data={"fields": fields}) |
| except Exception: |
| return False |
| return True |
|
|
| def get_issue_labels(self, issue_key): |
| """ |
| Get issue labels. |
| :param issue_key: |
| :return: |
| """ |
| url = "rest/api/2/issue/{issue_key}?fields=labels".format(issue_key=issue_key) |
| if self.advanced_mode: |
| return self.get(url) |
| return (self.get(url) or {}).get("fields").get("labels") |
|
|
| def add_attachment(self, issue_key, filename): |
| """ |
| Add attachment to Issue |
| :param issue_key: str |
| :param filename: str, name, if file in current directory or full path to file |
| """ |
| log.warning("Adding attachment...") |
| url = "rest/api/2/issue/{}/attachments".format(issue_key) |
| with open(filename, "rb") as attachment: |
| files = {"file": attachment} |
| return self.post(url, headers=self.no_check_headers, files=files) |
|
|
| def issue_exists(self, issue_key): |
| original_value = self.advanced_mode |
| self.advanced_mode = True |
| try: |
| resp = self.issue(issue_key, fields="*none") |
| if resp.status_code == 404: |
| log.info('Issue "{issue_key}" does not exists'.format(issue_key=issue_key)) |
| return False |
| resp.raise_for_status() |
| log.info('Issue "{issue_key}" exists'.format(issue_key=issue_key)) |
| return True |
| finally: |
| self.advanced_mode = original_value |
|
|
| def issue_deleted(self, issue_key): |
| exists = self.issue_exists(issue_key) |
| if exists: |
| log.info('Issue "{issue_key}" is not deleted'.format(issue_key=issue_key)) |
| else: |
| log.info('Issue "{issue_key}" is deleted'.format(issue_key=issue_key)) |
| return not exists |
|
|
| def delete_issue(self, issue_id_or_key, delete_subtasks=True): |
| """ |
| Delete an issue |
| If the issue has subtasks you must set the parameter delete_subtasks = True to delete the issue |
| You cannot delete an issue without its subtasks also being deleted |
| :param issue_id_or_key: |
| :param delete_subtasks: |
| :return: |
| """ |
| url = "rest/api/2/issue/{}".format(issue_id_or_key) |
| params = {} |
|
|
| if delete_subtasks is True: |
| params["deleteSubtasks"] = "true" |
| else: |
| params["deleteSubtasks"] = "false" |
|
|
| log.warning("Removing issue {}...".format(issue_id_or_key)) |
|
|
| return self.delete(url, params=params) |
|
|
| |
| def issue_update(self, issue_key, fields): |
| log.warning('Updating issue "{issue_key}" with "{fields}"'.format(issue_key=issue_key, fields=fields)) |
| url = "rest/api/2/issue/{0}".format(issue_key) |
| return self.put(url, data={"fields": fields}) |
|
|
| def edit_issue(self, issue_id_or_key, fields, notify_users=True): |
| """ |
| Edits an issue from a JSON representation |
| The issue can either be updated by setting explicit the field |
| value(s) or by using an operation to change the field value |
| |
| :param issue_id_or_key: str |
| :param fields: JSON |
| :param notify_users: bool |
| :return: |
| """ |
| url = "rest/api/2/issue/{}".format(issue_id_or_key) |
| params = {} |
| data = {"update": fields} |
|
|
| if notify_users is True: |
| params["notifyUsers"] = "true" |
| else: |
| params["notifyUsers"] = "false" |
| return self.put(url, data=data, params=params) |
|
|
| def issue_add_watcher(self, issue_key, user): |
| """ |
| Start watching issue |
| :param issue_key: |
| :param user: |
| :return: |
| """ |
| log.warning('Adding user {user} to "{issue_key}" watchers'.format(issue_key=issue_key, user=user)) |
| data = user |
| return self.post( |
| "rest/api/2/issue/{issue_key}/watchers".format(issue_key=issue_key), |
| data=data, |
| ) |
|
|
| def assign_issue(self, issue, assignee=None): |
| """Assign an issue to a user. None will set it to unassigned. -1 will set it to Automatic. |
| :param issue: the issue ID or key to assign |
| :type issue: int or str |
| :param assignee: the user to assign the issue to |
| :type assignee: str |
| :rtype: bool |
| """ |
| url = "rest/api/2/issue/{issue}/assignee".format(issue=issue) |
| data = {"name": assignee} |
|
|
| return self.put(url, data=data) |
|
|
| def create_issue(self, fields, update_history=False, update=None): |
| """ |
| Creates an issue or a sub-task from a JSON representation |
| :param fields: JSON data |
| mandatory keys are issuetype, summary and project |
| :param update: JSON data |
| Use it to link issues or update worklog |
| :param update_history: bool (if true then the user's project history is updated) |
| :return: |
| example: |
| fields = dict(summary='Into The Night', |
| project = dict(key='APA'), |
| issuetype = dict(name='Story') |
| ) |
| update = dict(issuelinks={ |
| "add": { |
| "type": { |
| "name": "Child-Issue" |
| }, |
| "inwardIssue": { |
| "key": "ISSUE-KEY" |
| } |
| } |
| } |
| ) |
| jira.create_issue(fields=fields, update=update) |
| """ |
| url = "rest/api/2/issue" |
| data = {"fields": fields} |
| if update: |
| data["update"] = update |
| params = {} |
|
|
| if update_history is True: |
| params["updateHistory"] = "true" |
| else: |
| params["updateHistory"] = "false" |
| return self.post(url, params=params, data=data) |
|
|
| def create_issues(self, list_of_issues_data): |
| """ |
| Creates issues or sub-tasks from a JSON representation |
| Creates many issues in one bulk operation |
| :param list_of_issues_data: list of JSON data |
| :return: |
| """ |
| url = "rest/api/2/issue/bulk" |
| data = {"issueUpdates": list_of_issues_data} |
| return self.post(url, data=data) |
|
|
| |
| def issue_create(self, fields): |
| log.warning('Creating issue "{summary}"'.format(summary=fields["summary"])) |
| url = "rest/api/2/issue" |
| return self.post(url, data={"fields": fields}) |
|
|
| def issue_create_or_update(self, fields): |
| issue_key = fields.get("issuekey", None) |
|
|
| if not issue_key or not self.issue_exists(issue_key): |
| log.info("IssueKey is not provided or does not exists in destination. Will attempt to create an issue") |
| fields.pop("issuekey", None) |
| return self.issue_create(fields) |
|
|
| if self.issue_deleted(issue_key): |
| log.warning('Issue "{issue_key}" deleted, skipping'.format(issue_key=issue_key)) |
| return None |
|
|
| log.info('Issue "{issue_key}" exists, will update'.format(issue_key=issue_key)) |
| fields.pop("issuekey", None) |
| return self.issue_update(issue_key, fields) |
|
|
| def issue_add_comment(self, issue_key, comment, visibility=None): |
| """ |
| Add comment into Jira issue |
| :param issue_key: |
| :param comment: |
| :param visibility: OPTIONAL |
| :return: |
| """ |
| url = "rest/api/2/issue/{issueIdOrKey}/comment".format(issueIdOrKey=issue_key) |
| data = {"body": comment} |
| if visibility: |
| data["visibility"] = visibility |
| return self.post(url, data=data) |
|
|
| def issue_edit_comment(self, issue_key, comment_id, comment, visibility=None): |
| """ |
| Updates an existing comment |
| :param issue_key: str |
| :param comment_id: int |
| :param comment: str |
| :param visibility: OPTIONAL |
| :return: |
| """ |
| url = "rest/api/2/issue/{}/comment/{}".format(issue_key, comment_id) |
| data = {"body": comment} |
| if visibility: |
| data["visibility"] = visibility |
| return self.put(url, data=data) |
|
|
| def get_issue_remotelinks(self, issue_key, global_id=None, internal_id=None): |
| """ |
| Compatibility naming method with get_issue_remote_links() |
| """ |
| return self.get_issue_remote_links(issue_key, global_id, internal_id) |
|
|
| def get_issue_remote_links(self, issue_key, global_id=None, internal_id=None): |
| """ |
| Finding all Remote Links on an issue, also with filtering by Global ID and internal ID |
| :param issue_key: |
| :param global_id: str |
| :param internal_id: str |
| :return: |
| """ |
| 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) |
|
|
| def create_or_update_issue_remote_links(self, issue_key, link_url, title, global_id=None, relationship=None): |
| """ |
| Add Remote Link to Issue, update url if global_id is passed |
| :param issue_key: str |
| :param link_url: str |
| :param title: str |
| :param global_id: str, OPTIONAL: |
| :param relationship: str, OPTIONAL: Default by built-in method: 'Web Link' |
| """ |
| url = "rest/api/2/issue/{issue_key}/remotelink".format(issue_key=issue_key) |
| data = {"object": {"url": link_url, "title": title}} |
| if global_id: |
| data["globalId"] = global_id |
| if relationship: |
| data["relationship"] = relationship |
| return self.post(url, data=data) |
|
|
| def get_issue_remote_link_by_id(self, issue_key, link_id): |
| url = "rest/api/2/issue/{issue_key}/remotelink/{link_id}".format(issue_key=issue_key, link_id=link_id) |
| return self.get(url) |
|
|
| def update_issue_remote_link_by_id(self, issue_key, link_id, url, title, global_id=None, relationship=None): |
| """ |
| Update existing Remote Link on Issue |
| :param issue_key: str |
| :param link_id: str |
| :param url: str |
| :param title: str |
| :param global_id: str, OPTIONAL: |
| :param relationship: str, Optional. Default by built-in method: 'Web Link' |
| |
| """ |
| data = {"object": {"url": url, "title": title}} |
| if global_id: |
| data["globalId"] = global_id |
| if relationship: |
| data["relationship"] = relationship |
| url = "rest/api/2/issue/{issue_key}/remotelink/{link_id}".format(issue_key=issue_key, link_id=link_id) |
| return self.put(url, data=data) |
|
|
| def delete_issue_remote_link_by_id(self, issue_key, link_id): |
| """ |
| Deletes Remote Link on Issue |
| :param issue_key: str |
| :param link_id: str |
| """ |
| url = "rest/api/2/issue/{issue_key}/remotelink/{link_id}".format(issue_key=issue_key, link_id=link_id) |
| return self.delete(url) |
|
|
| def get_issue_transitions(self, issue_key): |
| if self.advanced_mode: |
| return [ |
| { |
| "name": transition["name"], |
| "id": int(transition["id"]), |
| "to": transition["to"]["name"], |
| } |
| for transition in (self.get_issue_transitions_full(issue_key).json() or {}).get("transitions") |
| ] |
| else: |
| return [ |
| { |
| "name": transition["name"], |
| "id": int(transition["id"]), |
| "to": transition["to"]["name"], |
| } |
| for transition in (self.get_issue_transitions_full(issue_key) or {}).get("transitions") |
| ] |
|
|
| def issue_transition(self, issue_key, status): |
| return self.set_issue_status(issue_key, status) |
|
|
| def set_issue_status(self, issue_key, status_name, fields=None, update=None): |
| """ |
| Setting status by status_name. fields defaults to None for transitions without mandatory fields. |
| If there are mandatory fields for the transition, these can be set using a dict in 'fields'. |
| For updating screen properties that cannot be set/updated via the fields properties, |
| they can set using a dict through 'update' |
| Example: |
| jira.set_issue_status('MY-123','Resolved',{'myfield': 'myvalue'}, |
| {"comment": [{"add": { "body": "Issue Comments"}}]}) |
| :param issue_key: str |
| :param status_name: str |
| :param fields: dict, optional |
| :param update: dict, optional |
| """ |
| url = "rest/api/2/issue/{issue_key}/transitions".format(issue_key=issue_key) |
| transition_id = self.get_transition_id_to_status_name(issue_key, status_name) |
| data = {"transition": {"id": transition_id}} |
| if fields is not None: |
| data["fields"] = fields |
| if update is not None: |
| data["update"] = update |
| return self.post(url, data=data) |
|
|
| def set_issue_status_by_transition_id(self, issue_key, transition_id): |
| """ |
| Setting status by transition_id |
| :param issue_key: str |
| :param transition_id: int |
| """ |
| url = "rest/api/2/issue/{issue_key}/transitions".format(issue_key=issue_key) |
| return self.post(url, data={"transition": {"id": transition_id}}) |
|
|
| def get_issue_status(self, issue_key): |
| url = "rest/api/2/issue/{issue_key}?fields=status".format(issue_key=issue_key) |
| return (((self.get(url) or {}).get("fields") or {}).get("status") or {}).get("name") or {} |
|
|
| def get_issue_status_id(self, issue_key): |
| url = "rest/api/2/issue/{issue_key}?fields=status".format(issue_key=issue_key) |
| return (self.get(url) or {}).get("fields").get("status").get("id") |
|
|
| def get_issue_transitions_full(self, issue_key, transition_id=None, expand=None): |
| """ |
| Get a list of the transitions possible for this issue by the current user, |
| along with fields that are required and their types. |
| Fields will only be returned if expand = 'transitions.fields'. |
| The fields in the metadata correspond to the fields in the transition screen for that transition. |
| Fields not in the screen will not be in the metadata. |
| :param issue_key: str |
| :param transition_id: str |
| :param expand: str |
| :return: |
| """ |
| url = "rest/api/2/issue/{issue_key}/transitions".format(issue_key=issue_key) |
| params = {} |
| if transition_id: |
| params["transitionId"] = transition_id |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| def get_updated_worklogs(self, since, expand=None): |
| """ |
| Returns a list of IDs and update timestamps for worklogs updated after a date and time. |
| :param since: The date and time, as a UNIX timestamp in milliseconds, after which updated worklogs are returned. |
| :param expand: Use expand to include additional information about worklogs in the response. |
| This parameter accepts properties that returns the properties of each worklog. |
| """ |
| url = "rest/api/3/worklog/updated" |
| params = {} |
| if since: |
| params["since"] = str(int(since * 1000)) |
| if expand: |
| params["expand"] = expand |
|
|
| return self.get(url, params=params) |
|
|
| def get_worklogs(self, ids, expand=None): |
| """ |
| Returns worklog details for a list of worklog IDs. |
| :param expand: Use expand to include additional information about worklogs in the response. |
| This parameter accepts properties that returns the properties of each worklog. |
| :param ids: REQUIRED A list of worklog IDs. |
| """ |
|
|
| url = "rest/api/3/worklog/list" |
| params = {} |
| if expand: |
| params["expand"] = expand |
| data = {"ids": ids} |
| return self.post(url, params=params, data=data) |
|
|
| """ |
| User |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/user |
| """ |
|
|
| def user(self, username=None, key=None, account_id=None, expand=None): |
| """ |
| Returns a user. This resource cannot be accessed anonymously. |
| You can use only one parameter: username or key |
| |
| :param username: |
| :param key: if username and key are different |
| :param account_id: |
| :param expand: Can be 'groups,applicationRoles' |
| :return: |
| """ |
| params = {} |
| major_parameter_enabled = False |
| if account_id: |
| params = {"accountId": account_id} |
| major_parameter_enabled = True |
|
|
| if not major_parameter_enabled and username and not key: |
| params = {"username": username} |
| elif not major_parameter_enabled and not username and key: |
| params = {"key": key} |
| elif not major_parameter_enabled and username and key: |
| return "You cannot specify both the username and the key parameters" |
| elif not account_id and not key and not username: |
| return "You must specify at least one parameter: username or key or account_id" |
| if expand: |
| params["expand"] = expand |
|
|
| return self.get("rest/api/2/user", params=params) |
|
|
| def is_active_user(self, username): |
| """ |
| Check status of user |
| :param username: |
| :return: |
| """ |
| return self.user(username).get("active") |
|
|
| def user_remove(self, username=None, account_id=None, key=None): |
| """ |
| Remove user from Jira if this user does not have any activity |
| :param key: |
| :param account_id: |
| :param username: |
| :return: |
| """ |
| params = {} |
| if username: |
| params["username"] = username |
| if account_id: |
| params["accountId"] = account_id |
| if key: |
| params["key"] = key |
| return self.delete("rest/api/2/user", params=params) |
|
|
| def user_update(self, username, data): |
| """ |
| Update user attributes based on json |
| :param username: |
| :param data: |
| :return: |
| """ |
| url = "rest/api/2/user?username={0}".format(username) |
| return self.put(url, data=data) |
|
|
| def user_update_username(self, old_username, new_username): |
| """ |
| Update username |
| :param old_username: |
| :param new_username: |
| :return: |
| """ |
| data = {"name": new_username} |
| return self.user_update(old_username, data=data) |
|
|
| def user_update_email(self, username, email): |
| """ |
| Update user email for new domain changes |
| :param username: |
| :param email: |
| :return: |
| """ |
| data = {"name": username, "emailAddress": email} |
| return self.user_update(username, data=data) |
|
|
| def user_create(self, username, email, display_name, password=None, notification=None): |
| """ |
| Create a user in Jira |
| :param username: |
| :param email: |
| :param display_name: |
| :param password: OPTIONAL: If a password is not set, a random password is generated. |
| :param notification: OPTIONAL: Sends the user an email confirmation that they have been added to Jira. |
| Default:false. |
| :return: |
| """ |
| log.warning("Creating user {}".format(display_name)) |
| data = {"name": username, "emailAddress": email, "displayName": display_name} |
| if password is not None: |
| data["password"] = password |
| else: |
| data["notification"] = True |
| if notification is not None: |
| data["notification"] = True |
| if notification is False: |
| data["notification"] = False |
| return self.post("rest/api/2/user", data=data) |
|
|
| def user_properties(self, username): |
| """ |
| Get user property |
| :param username: |
| :return: |
| """ |
| return self.get("rest/api/2/user/properties?username={}".format(username)) |
|
|
| def user_property(self, username, key_property): |
| """ |
| Get user property |
| :param key_property: |
| :param username: |
| :return: |
| """ |
| params = {"username": username} |
| return self.get("rest/api/2/user/properties/{}".format(key_property), params=params) |
|
|
| def user_set_property(self, username, key_property, value_property): |
| """ |
| Set property for user |
| :param username: |
| :param key_property: |
| :param value_property: |
| :return: |
| """ |
| url = "rest/api/2/user/properties/{key_property}?username={user_name}".format( |
| key_property=key_property, user_name=username |
| ) |
| data = {"value": value_property} |
| return self.put(url, data=data) |
|
|
| def user_delete_property(self, username, key_property): |
| """ |
| Delete property for user |
| :param username: |
| :param key_property: |
| :return: |
| """ |
| url = "rest/api/2/user/properties/{}".format(key_property) |
| params = {"username": username} |
| return self.delete(url, params=params) |
|
|
| def user_update_or_create_property_through_rest_point(self, username, key, value): |
| """ |
| ATTENTION! |
| This method used after configuration of rest endpoint on Jira side |
| :param username: |
| :param key: |
| :param value: |
| :return: |
| """ |
| url = "rest/scriptrunner/latest/custom/updateUserProperty" |
| params = {"username": username, "property": key, "value": value} |
| return self.get(url, params=params) |
|
|
| def user_deactivate(self, username): |
| """ |
| Disable user. Works from 8.3.0 Release |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.3.0/#api/2/user-updateUser |
| :param username: |
| :return: |
| """ |
| data = {"active": "false", "name": username} |
| return self.user_update(username=username, data=data) |
|
|
| def user_disable(self, username): |
| """Override the disable method""" |
| return self.user_deactivate(username) |
|
|
| def user_disable_throw_rest_endpoint( |
| self, |
| username, |
| url="rest/scriptrunner/latest/custom/disableUser", |
| param="userName", |
| ): |
| """The disable method throw own rest endpoint""" |
| url = "{}?{}={}".format(url, param, username) |
| return self.get(path=url) |
|
|
| def user_get_websudo(self): |
| """ Get web sudo cookies using normal http request""" |
| url = "secure/admin/WebSudoAuthenticate.jspa" |
| data = { |
| "webSudoPassword": self.password, |
| "webSudoIsPost": "false", |
| } |
| answer = self.get("secure/admin/WebSudoAuthenticate.jspa", self.form_token_headers) |
| atl_token = None |
| if answer: |
| atl_token = ( |
| answer.split('<meta id="atlassian-token" name="atlassian-token" content="')[1] |
| .split("\n")[0] |
| .split('"')[0] |
| ) |
| if atl_token: |
| data["atl_token"] = atl_token |
|
|
| return self.post(path=url, data=data, headers=self.form_token_headers) |
|
|
| def invalidate_websudo(self): |
| """ |
| This method invalidates the any current WebSudo session. |
| """ |
| return self.delete("rest/auth/1/websudo") |
|
|
| def user_find_by_user_string( |
| self, |
| username=None, |
| query=None, |
| account_id=None, |
| property_key=None, |
| start=0, |
| limit=50, |
| include_inactive_users=False, |
| include_active_users=True, |
| ): |
| """ |
| Fuzzy search using display name, emailAddress or property, or an exact search for accountId or username |
| |
| On Jira Cloud, you can use only one of query or account_id params. You may not specify username. |
| On Jira Server, you must specify a username. You may not use query, account_id or property_key. |
| |
| :param username: OPTIONAL: Required for Jira Server, cannot be used on Jira Cloud. |
| Use '.' to find all users. |
| :param query: OPTIONAL: String matched against "displayName" and "emailAddress" user attributes |
| :param account_id: OPTIONAL: String matched exactly against a user "accountId". |
| Required unless "query" or "property" parameters are specified. |
| :param property_key: OPTIONAL: String used to search properties by key. Required unless |
| "account_id" or "query" is specified. |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of users to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :param include_inactive_users: OPTIONAL: Return users with "active: False" |
| :param include_active_users: OPTIONAL: Return users with "active: True". |
| :return: |
| """ |
| url = "rest/api/2/user/search" |
| params = { |
| "includeActive": include_active_users, |
| "includeInactive": include_inactive_users, |
| "startAt": start, |
| "maxResults": limit, |
| } |
|
|
| if self.cloud: |
| if username: |
| return "Jira Cloud no longer supports a username parameter, use account_id, query or property_key" |
| elif account_id and query: |
| return "You cannot specify both the query and account_id parameters" |
| elif not any([account_id, query, property_key]): |
| return "You must specify at least one parameter: query or account_id or property_key" |
| elif account_id: |
| params["accountId"] = account_id |
|
|
| if query: |
| params["query"] = query |
| if property_key: |
| params["property"] = property_key |
| elif not username: |
| return "Username parameter is required for user search on Jira Server" |
| elif any([account_id, query, property_key]): |
| return "Jira Server does not support account_id, query or property_key parameters" |
| else: |
| params["username"] = username |
|
|
| return self.get(url, params=params) |
|
|
| def is_user_in_application(self, username, application_key): |
| """ |
| Utility function to test whether a user has an application role |
| :param username: The username of the user to test. |
| :param application_key: The application key of the application |
| :return: True if the user has the application, else False |
| """ |
| user = self.user(username, "applicationRoles") |
| if "self" in user: |
| for application_role in user.get("applicationRoles").get("items"): |
| if application_role.get("key") == application_key: |
| return True |
| return False |
|
|
| def add_user_to_application(self, username, application_key): |
| """ |
| Add a user to an application |
| :param username: The username of the user to add. |
| :param application_key: The application key of the application |
| :return: True if the user was added to the application, else False |
| :see: https://docs.atlassian.com/software/jira/docs/api/REST/7.5.3/#api/2/user-addUserToApplication |
| """ |
| params = {"username": username, "applicationKey": application_key} |
| return self.post("rest/api/2/user/application", params=params) is None |
|
|
| """ |
| Projects |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project |
| """ |
|
|
| def get_all_projects(self, included_archived=None, expand=None): |
| return self.projects(included_archived, expand) |
|
|
| def projects(self, included_archived=None, expand=None): |
| """Returns all projects which are visible for the currently logged in user. |
| If no user is logged in, it returns the list of projects that are visible when using anonymous access. |
| :param included_archived: boolean whether to include archived projects in response, default: false |
| :return: |
| """ |
| params = {} |
| if included_archived: |
| params["includeArchived"] = included_archived |
| if expand: |
| params["expand"] = expand |
| return self.get("rest/api/2/project", params=params) |
|
|
| def create_project_from_raw_json(self, json): |
| """ |
| Creates a new project. |
| { |
| "key": "EX", |
| "name": "Example", |
| "projectTypeKey": "business", |
| "projectTemplateKey": "com.atlassian.jira-core-project-templates:jira-core-project-management", |
| "description": "Example Project description", |
| "lead": "Charlie", |
| "url": "http://atlassian.com", |
| "assigneeType": "PROJECT_LEAD", |
| "avatarId": 10200, |
| "issueSecurityScheme": 10001, |
| "permissionScheme": 10011, |
| "notificationScheme": 10021, |
| "categoryId": 10120 |
| } |
| :param json: |
| :return: |
| """ |
| return self.post("rest/api/2/project", json=json) |
|
|
| def create_project_from_shared_template(self, project_id, key, name, lead): |
| """ |
| Creates a new project based on an existing project. |
| :param str project_id: The numeric ID of the project to clone |
| :param str key: The KEY to use for the new project, e.g. KEY-10000 |
| :param str name: The name of the new project |
| :param str lead: The username of the project lead |
| :return: |
| """ |
| json = {"key": key, "name": name, "lead": lead} |
|
|
| return self.post("rest/project-templates/1.0/createshared/{}".format(project_id), json=json) |
|
|
| def delete_project(self, key): |
| """ |
| DELETE /rest/api/2/project/<project_key> |
| :param key: str |
| :return: |
| """ |
| return self.delete("rest/api/2/project/{0}".format(key)) |
|
|
| def project(self, key, expand=None): |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get("rest/api/2/project/{0}".format(key), params=params) |
|
|
| def get_project(self, key, expand=None): |
| """ |
| Contains a full representation of a project in JSON format. |
| All project keys associated with the project will only be returned if expand=projectKeys. |
| :param key: |
| :param expand: |
| :return: |
| """ |
| return self.project(key=key, expand=expand) |
|
|
| def get_project_components(self, key): |
| """ |
| Get project components using project key |
| :param key: str |
| :return: |
| """ |
| return self.get("rest/api/2/project/{0}/components".format(key)) |
|
|
| def get_project_versions(self, key, expand=None): |
| """ |
| Contains a full representation of a the specified project's versions. |
| :param key: |
| :param expand: the parameters to expand |
| :return: |
| """ |
| params = {} |
| if expand is not None: |
| params["expand"] = expand |
| return self.get("rest/api/2/project/{}/versions".format(key), params=params) |
|
|
| def get_project_versions_paginated( |
| self, |
| key, |
| start=None, |
| limit=None, |
| order_by=None, |
| expand=None, |
| query=None, |
| status=None, |
| ): |
| """ |
| Returns all versions for the specified project. Results are paginated. |
| Results can be ordered by the following fields: |
| sequence |
| name |
| startDate |
| releaseDate |
| :param key: the project key or id |
| :param start: the page offset, if not specified then defaults to 0 |
| :param limit: how many results on the page should be included. Defaults to 50. |
| :param order_by: ordering of the results. |
| :param expand: the parameters to expand |
| :param query: Filter the results using a literal string. Versions with matching name or description |
| are returned (case insensitive). |
| :param status: A list of status values used to filter the results by version status. |
| This parameter accepts a comma-separated list. The status values are released, unreleased, and archived. |
| :return: |
| """ |
| params = {} |
| if start is not None: |
| params["startAt"] = int(start) |
| if limit is not None: |
| params["maxResults"] = int(limit) |
| if order_by is not None: |
| params["orderBy"] = order_by |
| if expand is not None: |
| params["expand"] = expand |
| if query is not None: |
| params["query"] = query |
| if status in ["released", "unreleased", "archived"]: |
| params["status"] = status |
| return self.get("rest/api/2/project/{}/version".format(key), params=params) |
|
|
| def add_version(self, project_key, project_id, version, is_archived=False, is_released=False): |
| """ |
| Add missing version to project |
| :param project_key: the project key |
| :param project_id: the project id |
| :param version: the new project version to add |
| :param is_archived: |
| :param is_released: |
| :return: |
| """ |
| payload = { |
| "name": version, |
| "archived": is_archived, |
| "released": is_released, |
| "project": project_key, |
| "projectId": project_id, |
| } |
| return self.post("rest/api/2/version", data=payload) |
|
|
| def delete_version(self, version, moved_fixed=None, move_affected=None): |
| """ |
| Delete version from the project |
| :param int version: the version id to delete |
| :param int moved_fixed: The version to set fixVersion to on issues where the deleted version is the fix version. |
| If null then the fixVersion is removed. |
| :param int move_affected: The version to set affectedVersion to on issues where the deleted version is |
| the affected version, If null then the affectedVersion is removed. |
| :return: |
| """ |
| payload = {"moveFixIssuesTo": moved_fixed, "moveAffectedIssuesTo": move_affected} |
| return self.delete("rest/api/2/version/{}".format(version), data=payload) |
|
|
| def get_project_roles(self, project_key): |
| """ |
| Provide associated project roles |
| :param project_key: |
| :return: |
| """ |
| return self.get("rest/api/2/project/{0}/role".format(project_key)) |
|
|
| def get_project_actors_for_role_project(self, project_key, role_id): |
| """ |
| Returns the details for a given project role in a project. |
| :param project_key: |
| :param role_id: |
| :return: |
| """ |
| url = "rest/api/2/project/{projectIdOrKey}/role/{id}".format(projectIdOrKey=project_key, id=role_id) |
| return (self.get(url) or {}).get("actors") |
|
|
| def delete_project_actors(self, project_key, role_id, actor, actor_type=None): |
| """ |
| Deletes actors (users or groups) from a project role. |
| Delete a user from the role: /rest/api/2/project/{projectIdOrKey}/role/{roleId}?user={username} |
| Delete a group from the role: /rest/api/2/project/{projectIdOrKey}/role/{roleId}?group={groupname} |
| :param project_key: |
| :param role_id: |
| :param actor: |
| :param actor_type: str : group or user string |
| :return: |
| """ |
| url = "rest/api/2/project/{projectIdOrKey}/role/{roleId}".format(projectIdOrKey=project_key, roleId=role_id) |
| params = {} |
| if actor_type is not None and actor_type in ["group", "user"]: |
| params[actor_type] = actor |
| return self.delete(url, params=params) |
|
|
| def add_user_into_project_role(self, project_key, role_id, user_name): |
| """ |
| |
| :param project_key: |
| :param role_id: |
| :param user_name: |
| :return: |
| """ |
| return self.add_project_actor_in_role(project_key, role_id, user_name, "atlassian-user-role-actor") |
|
|
| def add_project_actor_in_role(self, project_key, role_id, actor, actor_type): |
| """ |
| |
| :param project_key: |
| :param role_id: |
| :param actor: |
| :param actor_type: |
| :return: |
| """ |
| url = "rest/api/2/project/{projectIdOrKey}/role/{roleId}".format(projectIdOrKey=project_key, roleId=role_id) |
| data = {} |
| if actor_type in ["group", "atlassian-group-role-actor"]: |
| data["group"] = [actor] |
| elif actor_type in ["user", "atlassian-user-role-actor"]: |
| data["user"] = [actor] |
|
|
| return self.post(url, data=data) |
|
|
| def update_project(self, project_key, data, expand=None): |
| """ |
| Updates a project. |
| Only non null values sent in JSON will be updated in the project. |
| Values available for the assigneeType field are: "PROJECT_LEAD" and "UNASSIGNED". |
| Update project: /rest/api/2/project/{projectIdOrKey} |
| |
| :param project_key: project key of project that needs to be updated |
| :param data: dictionary containing the data to be updated |
| :param expand: the parameters to expand |
| """ |
| url = "rest/api/2/project/{projectIdOrKey}".format(projectIdOrKey=project_key) |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.put(url, data, params=params) |
|
|
| def update_project_category_for_project(self, project_key, new_project_category_id, expand=None): |
| """ |
| Updates a project. |
| Update project: /rest/api/2/project/{projectIdOrKey} |
| |
| :param project_key: project key of project that needs to be updated |
| :param new_project_category_id: |
| :param expand: the parameters to expand |
| """ |
| data = {"categoryId": new_project_category_id} |
| return self.update_project(project_key, data, expand=expand) |
|
|
| """ |
| Resource for associating notification schemes and projects |
| Reference: |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project/{projectKeyOrId}/notificationscheme |
| """ |
|
|
| def get_notification_scheme_for_project(self, project_id_or_key): |
| """ |
| Gets a notification scheme associated with the project. |
| Follow the documentation of /notificationscheme/{id} resource for all details about returned value. |
| :param project_id_or_key: |
| :return: |
| """ |
| url = "rest/api/2/project/{}/notificationscheme".format(project_id_or_key) |
| return self.get(url) |
|
|
| def assign_project_notification_scheme(self, project_key, new_notification_scheme=""): |
| """ |
| Updates a project. |
| Update project: /rest/api/2/project/{projectIdOrKey} |
| |
| :param project_key: project key of project that needs to be updated |
| :param new_notification_scheme: |
| """ |
| data = {"notificationScheme": new_notification_scheme} |
| return self.update_project(project_key, data) |
|
|
| def get_notification_schemes(self): |
| """ |
| Returns a paginated list of notification schemes |
| """ |
| url = "rest/api/2/notificationscheme" |
| return self.get(url) |
|
|
| def get_all_notification_schemes(self): |
| """ |
| Returns a paginated list of notification schemes |
| """ |
| return self.get_notification_schemes().get("values") or [] |
|
|
| def get_notification_scheme(self, notification_scheme_id, expand=None): |
| """ |
| Returns a full representation of the notification scheme for the given id. |
| Use 'expand' to get details |
| Returns a full representation of the notification scheme for the given id. This resource will return a |
| notification scheme containing a list of events and recipient configured to receive notifications for these |
| events. Consumer should allow events without recipients to appear in response. User accessing the data is |
| required to have permissions to administer at least one project associated with the requested notification |
| scheme. |
| Notification recipients can be: |
| |
| current assignee - the value of the notificationType is CurrentAssignee |
| issue reporter - the value of the notificationType is Reporter |
| current user - the value of the notificationType is CurrentUser |
| project lead - the value of the notificationType is ProjectLead |
| component lead - the value of the notificationType is ComponentLead |
| all watchers - the value of the notification type is AllWatchers |
| configured user - the value of the notification type is User. Parameter will contain key of the user. |
| Information about the user will be provided if user expand parameter is used. |
| configured group - the value of the notification type is Group. Parameter will contain name of the group. |
| Information about the group will be provided if group expand parameter is used. |
| configured email address - the value of the notification type is EmailAddress, additionally |
| information about the email will be provided. |
| users or users in groups in the configured custom fields - the value of the notification type |
| is UserCustomField or GroupCustomField. Parameter will contain id of the custom field. |
| Information about the field will be provided if field expand parameter is used. |
| configured project role - the value of the notification type is ProjectRole. |
| Parameter will contain project role id. |
| Information about the project role will be provided if projectRole expand parameter is used. |
| Please see the example for reference. |
| The events can be JIRA system events or events configured by administrator. |
| In case of the system events, data about theirs ids, names and descriptions is provided. |
| In case of custom events, the template event is included as well. |
| :param notification_scheme_id: Id of scheme u wanna work with |
| :param expand: str |
| :return: full representation of the notification scheme for the given id |
| """ |
| url = "rest/api/2/notificationscheme/{}".format(notification_scheme_id) |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| """ |
| Resource for associating permission schemes and projects. |
| Reference: |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project/{projectKeyOrId}/permissionscheme |
| """ |
|
|
| def assign_project_permission_scheme(self, project_id_or_key, permission_scheme_id): |
| """ |
| Assigns a permission scheme with a project. |
| :param project_id_or_key: |
| :param permission_scheme_id: |
| :return: |
| """ |
| url = "rest/api/2/project/{}/permissionscheme".format(project_id_or_key) |
| data = {"id": permission_scheme_id} |
| return self.put(url, data=data) |
|
|
| def get_project_permission_scheme(self, project_id_or_key, expand=None): |
| """ |
| Gets a permission scheme assigned with a project |
| Use 'expand' to get details |
| |
| :param project_id_or_key: str |
| :param expand: str |
| :return: data of project permission scheme |
| """ |
| url = "rest/api/2/project/{}/permissionscheme".format(project_id_or_key) |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| def get_issue_types(self): |
| """ |
| Return all issue types |
| """ |
| return self.get("rest/api/2/issuetype") |
|
|
| def create_issue_type(self, name, description="", type="standard"): |
| """ |
| Create a new issue type |
| :param name: |
| :param description: |
| :param type: standard or sub-task |
| :return: |
| """ |
| data = {"name": name, "description": description, "type": type} |
| return self.post("rest/api/2/issuetype", data=data) |
|
|
| def get_all_custom_fields(self): |
| """ |
| Returns a list of all custom fields |
| That method just filtering all fields method |
| :return: application/jsonContains a full representation of all visible fields in JSON. |
| """ |
| fields = self.get_all_fields() |
| custom_fields = [] |
| for field in fields: |
| if field["custom"]: |
| custom_fields.append(field) |
| return custom_fields |
|
|
| def project_leaders(self): |
| for project in self.projects(): |
| key = project["key"] |
| project_data = self.project(key) |
| lead = self.user(project_data["lead"]["name"]) |
| yield { |
| "project_key": key, |
| "project_name": project["name"], |
| "lead_name": lead["displayName"], |
| "lead_key": lead["name"], |
| "lead_email": lead["emailAddress"], |
| } |
|
|
| def get_project_issuekey_last(self, project): |
| jql = "project = {project} ORDER BY issuekey DESC".format(project=project) |
| return (self.jql(jql).get("issues") or {})[0]["key"] |
|
|
| def get_project_issuekey_all(self, project): |
| jql = "project = {project} ORDER BY issuekey ASC".format(project=project) |
| return [issue["key"] for issue in self.jql(jql)["issues"]] |
|
|
| def get_project_issues_count(self, project): |
| jql = 'project = "{project}" '.format(project=project) |
| return self.jql(jql, fields="*none")["total"] |
|
|
| def get_all_project_issues(self, project, fields="*all", start=0, limit=None): |
| jql = "project = {project} ORDER BY key".format(project=project) |
| return self.jql(jql, fields=fields, start=start, limit=limit)["issues"] |
|
|
| def get_all_assignable_users_for_project(self, project_key, start=0, limit=50): |
| """ |
| Provide assignable users for project |
| :param project_key: |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of users to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :return: |
| """ |
| params = {"project": project_key, "startAt": start, "maxResults": limit} |
| url = "rest/api/2/user/assignable/search" |
| return self.get(url, params=params) |
|
|
| def get_assignable_users_for_issue(self, issue_key, username=None, start=0, limit=50): |
| """ |
| Provide assignable users for issue |
| :param issue_key: |
| :param username: OPTIONAL: Can be used to chaeck if user can be assigned |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of users to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :return: |
| """ |
| params = {"issueKey": issue_key, "startAt": start, "maxResults": limit} |
| if username: |
| params["username"] = username |
| url = "rest/api/2/user/assignable/search" |
| return self.get(url) |
|
|
| def get_status_id_from_name(self, status_name): |
| url = "rest/api/2/status/{name}".format(name=status_name) |
| return int((self.get(url) or {}).get("id")) |
|
|
| def get_status_for_project(self, project_key): |
| url = "rest/api/2/project/{name}/statuses".format(name=project_key) |
| return self.get(url) |
|
|
| def get_all_time_tracking_providers(self): |
| """ |
| Returns all time tracking providers. By default, Jira only has one time tracking provider: JIRA provided time |
| tracking. However, you can install other time tracking providers via apps from the Atlassian Marketplace. |
| """ |
| url = "rest/api/3/configuration/timetracking/list" |
| return self.get(url) |
|
|
| def get_selected_time_tracking_provider(self): |
| """ |
| Returns the time tracking provider that is currently selected. Note that if time tracking is disabled, |
| then a successful but empty response is returned. |
| """ |
| url = "rest/api/3/configuration/timetracking" |
| return self.get(url) |
|
|
| def get_time_tracking_settings(self): |
| """ |
| Returns the time tracking settings. This includes settings such as the time format, default time unit, |
| and others. |
| """ |
|
|
| url = "rest/api/3/configuration/timetracking/options" |
| return self.get(url) |
|
|
| def get_transition_id_to_status_name(self, issue_key, status_name): |
| for transition in self.get_issue_transitions(issue_key): |
| if status_name.lower() == transition["to"].lower(): |
| return int(transition["id"]) |
|
|
| """ |
| The Link Issue Resource provides functionality to manage issue links. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/issueLink |
| """ |
|
|
| def create_issue_link(self, data): |
| """ |
| Creates an issue link between two issues. |
| The user requires the link issue permission for the issue which will be linked to another issue. |
| The specified link type in the request is used to create the link and will create a link from |
| the first issue to the second issue using the outward description. It also create a link from |
| the second issue to the first issue using the inward description of the issue link type. |
| It will add the supplied comment to the first issue. The comment can have a restriction who can view it. |
| If group is specified, only users of this group can view this comment, if roleLevel is specified only users |
| who have the specified role can view this comment. |
| The user who creates the issue link needs to belong to the specified group or have the specified role. |
| :param data: i.e. |
| { |
| "type": {"name": "Duplicate" }, |
| "inwardIssue": { "key": "HSP-1"}, |
| "outwardIssue": {"key": "MKY-1"}, |
| "comment": { "body": "Linked related issue!", |
| "visibility": { "type": "group", "value": "jira-software-users" } |
| } |
| } |
| :return: |
| """ |
| log.info( |
| "Linking issue {inward} and {outward}".format(inward=data["inwardIssue"], outward=data["outwardIssue"]) |
| ) |
| url = "rest/api/2/issueLink" |
| return self.post(url, data=data) |
|
|
| def get_issue_link(self, link_id): |
| """ |
| Returns an issue link with the specified id. |
| :param link_id: the issue link id. |
| :return: |
| """ |
| url = "rest/api/2/issueLink/{}".format(link_id) |
| return self.get(url) |
|
|
| def remove_issue_link(self, link_id): |
| """ |
| Deletes an issue link with the specified id. |
| To be able to delete an issue link you must be able to view both issues |
| and must have the link issue permission for at least one of the issues. |
| :param link_id: the issue link id. |
| :return: |
| """ |
| url = "rest/api/2/issueLink/{}".format(link_id) |
| return self.delete(url) |
|
|
| """ |
| Rest resource to retrieve a list of issue link types. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/issueLinkType |
| """ |
|
|
| def get_issue_link_types(self): |
| """Returns a list of available issue link types, |
| if issue linking is enabled. |
| Each issue link type has an id, |
| a name and a label for the outward and inward link relationship. |
| """ |
| url = "rest/api/2/issueLinkType" |
| return (self.get(url) or {}).get("issueLinkTypes") |
|
|
| def get_issue_link_types_names(self): |
| """ |
| Provide issue link type names |
| :return: |
| """ |
| return [link_type["name"] for link_type in self.get_issue_link_types()] |
|
|
| def create_issue_link_type_by_json(self, data): |
| """Create a new issue link type. |
| :param data: |
| { |
| "name": "Duplicate", |
| "inward": "Duplicated by", |
| "outward": "Duplicates" |
| } |
| :return: |
| """ |
| url = "rest/api/2/issueLinkType" |
| return self.post(url, data=data) |
|
|
| def create_issue_link_type(self, link_type_name, inward, outward): |
| """Create a new issue link type. |
| :param outward: |
| :param inward: |
| :param link_type_name: |
| :return: |
| """ |
| if link_type_name.lower() in [x.lower() for x in self.get_issue_link_types_names()]: |
| log.error("Link type name already exists") |
| return "Link type name already exists" |
| data = {"name": link_type_name, "inward": inward, "outward": outward} |
| return self.create_issue_link_type_by_json(data=data) |
|
|
| def get_issue_link_type(self, issue_link_type_id): |
| """Returns for a given issue link type id all information about this issue link type.""" |
| url = "rest/api/2/issueLinkType/{issueLinkTypeId}".format(issueLinkTypeId=issue_link_type_id) |
| return self.get(url) |
|
|
| def delete_issue_link_type(self, issue_link_type_id): |
| """Delete the specified issue link type.""" |
| url = "rest/api/2/issueLinkType/{issueLinkTypeId}".format(issueLinkTypeId=issue_link_type_id) |
| return self.delete(url) |
|
|
| def update_issue_link_type(self, issue_link_type_id, data): |
| """ |
| Update the specified issue link type. |
| :param issue_link_type_id: |
| :param data: { |
| "name": "Duplicate", |
| "inward": "Duplicated by", |
| "outward": "Duplicates" |
| } |
| :return: |
| """ |
| url = "rest/api/2/issueLinkType/{issueLinkTypeId}".format(issueLinkTypeId=issue_link_type_id) |
| return self.put(url, data=data) |
|
|
| """ |
| Resolution |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/resolution |
| """ |
|
|
| def get_all_resolutions(self): |
| """ |
| Returns a list of all resolutions. |
| :return: |
| """ |
| url = "rest/api/2/resolution" |
| return self.get(url) |
|
|
| def get_resolution_by_id(self, resolution_id): |
| """ |
| Get Resolution info by id |
| :param resolution_id: |
| :return: |
| """ |
| url = "rest/api/2/resolution/{}".format(resolution_id) |
| return self.get(url) |
|
|
| """ |
| Role |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/role |
| """ |
|
|
| def get_all_global_project_roles(self): |
| """ |
| Get all the ProjectRoles available in Jira. Currently this list is global. |
| :return: |
| """ |
| url = "rest/api/2/role" |
| return self.get(url) |
|
|
| """ |
| Screens |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/screens |
| """ |
|
|
| def get_all_screens(self): |
| """ |
| Get all available screens from Jira |
| :return: list of json elements of screen with field id, name. description |
| """ |
| url = "rest/api/2/screens" |
| return self.get(url) |
|
|
| def get_all_available_screen_fields(self, screen_id): |
| """ |
| Get all available fields by screen id |
| :param screen_id: |
| :return: |
| """ |
| url = "rest/api/2/screens/{}/availableFields".format(screen_id) |
| return self.get(url) |
|
|
| def get_screen_tabs(self, screen_id): |
| """ |
| Get tabs for the screen id |
| :param screen_id: |
| :return: |
| """ |
| url = "rest/api/2/screens/{}/tabs".format(screen_id) |
| return self.get(url) |
|
|
| def get_screen_tab_fields(self, screen_id, tab_id): |
| """ |
| Get fields by the tab id and the screen id |
| :param tab_id: |
| :param screen_id: |
| :return: |
| """ |
| url = "rest/api/2/screens/{}/tabs/{}/fields".format(screen_id, tab_id) |
| return self.get(url) |
|
|
| def get_all_screen_fields(self, screen_id): |
| """ |
| Get all fields by screen id |
| :param screen_id: |
| :return: |
| """ |
| screen_tabs = self.get_screen_tabs(screen_id) |
| fields = [] |
| for screen_tab in screen_tabs: |
| tab_id = screen_tab["id"] |
| if tab_id: |
| tab_fields = self.get_screen_tab_fields(screen_id=screen_id, tab_id=tab_id) |
| fields = fields + tab_fields |
| return fields |
|
|
| """ |
| Search |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/search |
| """ |
|
|
| def jql(self, jql, fields="*all", start=0, limit=None, expand=None, validate_query=None): |
| """ |
| Get issues from jql search result with all related fields |
| :param jql: |
| :param fields: list of fields, for example: ['priority', 'summary', 'customfield_10007'] |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of issues to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :param expand: OPTIONAL: expand the search result |
| :param validate_query: Whether to validate the JQL query |
| :return: |
| """ |
| params = {} |
| if start is not None: |
| params["startAt"] = int(start) |
| if limit is not None: |
| params["maxResults"] = int(limit) |
| if fields is not None: |
| if isinstance(fields, (list, tuple, set)): |
| fields = ",".join(fields) |
| params["fields"] = fields |
| if jql is not None: |
| params["jql"] = jql |
| if expand is not None: |
| params["expand"] = expand |
| if validate_query is not None: |
| params["validateQuery"] = validate_query |
| return self.get("rest/api/2/search", params=params) |
|
|
| def csv(self, jql, limit=1000, all_fields=True, start=None, delimiter=None): |
| """ |
| Get issues from jql search result with ALL or CURRENT fields |
| default will be to return all fields |
| :param jql: JQL query |
| :param limit: max results in the output file |
| :param all_fields: To return all fields or current fields only |
| :param start: index value |
| :param delimiter: |
| :return: CSV file |
| """ |
|
|
| params = {"jqlQuery": jql} |
| if limit: |
| params["tempMax"] = limit |
| if start: |
| params["pager/start"] = start |
| if delimiter: |
| params["delimiter"] = delimiter |
| |
| if all_fields: |
| url = "sr/jira.issueviews:searchrequest-csv-all-fields/temp/SearchRequest.csv" |
| else: |
| url = "sr/jira.issueviews:searchrequest-csv-current-fields/temp/SearchRequest.csv" |
| |
| return self.get( |
| url, |
| params=params, |
| not_json_response=True, |
| headers={"Accept": "application/csv"}, |
| ) |
|
|
| def excel(self, jql, limit=1000, all_fields=True, start=None): |
| """ |
| Get issues from jql search result with ALL or CURRENT fields |
| default will be to return all fields |
| :param jql: JQL query |
| :param limit: max results in the output file |
| :param all_fields: To return all fields or current fields only |
| :param start: index value |
| :return: CSV file |
| """ |
|
|
| params = {"jqlQuery": jql} |
| if limit: |
| params["tempMax"] = limit |
| if start: |
| params["pager/start"] = start |
| |
| if all_fields: |
| url = "sr/jira.issueviews:searchrequest-excel-all-fields/temp/SearchRequest.xls" |
| else: |
| url = "sr/jira.issueviews:searchrequest-excel-current-fields/temp/SearchRequest.xls" |
| |
| return self.get( |
| url, |
| params=params, |
| not_json_response=True, |
| headers={"Accept": "application/vnd.ms-excel"}, |
| ) |
|
|
| def export_html(self, jql, limit=None, all_fields=True, start=None): |
| """ |
| Get issues from jql search result with ALL or CURRENT fields |
| default will be to return all fields |
| :param jql: JQL query |
| :param limit: max results in the output file |
| :param all_fields: To return all fields or current fields only |
| :param start: index value |
| :return: HTML file |
| """ |
|
|
| params = {"jqlQuery": jql} |
| if limit: |
| params["tempMax"] = limit |
| if start: |
| params["pager/start"] = start |
| |
| if all_fields: |
| url = "sr/jira.issueviews:searchrequest-html-all-fields/temp/SearchRequest.html" |
| else: |
| url = "sr/jira.issueviews:searchrequest-html-current-fields/temp/SearchRequest.html" |
| |
| return self.get( |
| url, |
| params=params, |
| not_json_response=True, |
| headers={"Accept": "application/xhtml+xml"}, |
| ) |
|
|
| def get_all_priorities(self): |
| """ |
| Returns a list of all priorities. |
| :return: |
| """ |
| url = "rest/api/2/priority" |
| return self.get(url) |
|
|
| def get_priority_by_id(self, priority_id): |
| """ |
| Get Priority info by id |
| :param priority_id: |
| :return: |
| """ |
| url = "rest/api/2/priority/{}".format(priority_id) |
| return self.get(url) |
|
|
| """ |
| Workflow |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/workflow |
| """ |
|
|
| def get_all_workflows(self): |
| """ |
| Provide all workflows for application admin |
| :return: |
| """ |
| url = "rest/api/2/workflow" |
| return self.get(url) |
|
|
| def get_workflows_paginated(self, startAt=None, maxResults=None, workflowName=None, expand=None): |
| """ |
| Provide all workflows paginated (see https://developer.atlassian.com/cloud/jira/platform/rest/v2/\ |
| api-group-workflows/#api-rest-api-2-workflow-search-get) |
| :param expand: |
| :param startAt: OPTIONAL The index of the first item to return in a page of results (page offset). |
| :param maxResults: OPTIONAL The maximum number of items to return per page. |
| :param workflowName: OPTIONAL The name of a workflow to return. |
| :param: expand: OPTIONAL Use expand to include additional information in the response. This parameter accepts a |
| comma-separated list. Expand options include: transitions, transitions.rules, statuses, statuses.properties |
| :return: |
| """ |
| url = "rest/api/2/workflow/search" |
|
|
| params = {} |
| if startAt: |
| params["startAt"] = startAt |
| if maxResults: |
| params["maxResults"] = maxResults |
| if workflowName: |
| params["workflowName"] = workflowName |
| if expand: |
| params["expand"] = expand |
|
|
| return self.get(url, params=params) |
|
|
| def get_all_statuses(self): |
| """ |
| Returns a list of all statuses |
| :return: |
| """ |
| url = "rest/api/2/status" |
| return self.get(url) |
|
|
| def get_plugins_info(self): |
| """ |
| Provide plugins info |
| :return a json of installed plugins |
| """ |
| url = "rest/plugins/1.0/" |
| return self.get(url, headers=self.no_check_headers, trailing=True) |
|
|
| def upload_plugin(self, plugin_path): |
| """ |
| Provide plugin path for upload into Jira e.g. useful for auto deploy |
| :param plugin_path: |
| :return: |
| """ |
| files = {"plugin": open(plugin_path, "rb")} |
| upm_token = self.request( |
| method="GET", |
| path="rest/plugins/1.0/", |
| headers=self.no_check_headers, |
| trailing=True, |
| ).headers["upm-token"] |
| url = "rest/plugins/1.0/?token={upm_token}".format(upm_token=upm_token) |
| return self.post(url, files=files, headers=self.no_check_headers) |
|
|
| def delete_plugin(self, plugin_key): |
| """ |
| Delete plugin |
| :param plugin_key: |
| :return: |
| """ |
| url = "rest/plugins/1.0/{}-key".format(plugin_key) |
| return self.delete(url) |
|
|
| def check_plugin_manager_status(self): |
| url = "rest/plugins/latest/safe-mode" |
| return self.request(method="GET", path=url, headers=self.safe_mode_headers) |
|
|
| def get_all_permissionschemes(self, expand=None): |
| """ |
| Returns a list of all permission schemes. |
| By default only shortened beans are returned. |
| If you want to include permissions of all the schemes, |
| then specify the permissions expand parameter. |
| Permissions will be included also if you specify any other expand parameter. |
| :param expand : permissions,user,group,projectRole,field,all |
| :return: |
| """ |
| url = "rest/api/2/permissionscheme" |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return (self.get(url, params=params) or {}).get("permissionSchemes") |
|
|
| def get_permissionscheme(self, permission_id, expand=None): |
| """ |
| Returns a list of all permission schemes. |
| By default only shortened beans are returned. |
| If you want to include permissions of all the schemes, |
| then specify the permissions expand parameter. |
| Permissions will be included also if you specify any other expand parameter. |
| :param permission_id |
| :param expand : permissions,user,group,projectRole,field,all |
| :return: |
| """ |
| url = "rest/api/2/permissionscheme/{schemeID}".format(schemeID=permission_id) |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| def set_permissionscheme_grant(self, permission_id, new_permission): |
| """ |
| Creates a permission grant in a permission scheme. |
| Example: |
| |
| { |
| "holder": { |
| "type": "group", |
| "parameter": "jira-developers" |
| }, |
| "permission": "ADMINISTER_PROJECTS" |
| } |
| |
| :param permission_id |
| :param new_permission |
| :return: |
| """ |
| url = "rest/api/2/permissionscheme/{schemeID}/permission".format(schemeID=permission_id) |
|
|
| return self.post(url, data=new_permission) |
|
|
| """ |
| REST resource that allows to view security schemes defined in the product. |
| Resource for managing priority schemes. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/issuesecurityschemes |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/priorityschemes |
| """ |
|
|
| def get_issue_security_schemes(self): |
| """ |
| Returns all issue security schemes that are defined |
| Administrator permission required |
| |
| :return: list |
| """ |
| url = "rest/api/2/issuesecurityschemes" |
|
|
| return self.get(url).get("issueSecuritySchemes") |
|
|
| def get_issue_security_scheme(self, scheme_id, only_levels=False): |
| """ |
| Returns the issue security scheme along with that are defined |
| |
| Returned if the user has the administrator permission or if the scheme is used in a project in which the |
| user has the administrative permission |
| |
| :param scheme_id: int |
| :param only_levels: bool |
| :return: list |
| """ |
| url = "rest/api/2/issuesecurityschemes/{}".format(scheme_id) |
|
|
| if only_levels is True: |
| return self.get(url).get("levels") |
| else: |
| return self.get(url) |
|
|
| def get_project_issue_security_scheme(self, project_id_or_key, only_levels=False): |
| """ |
| Returns the issue security scheme for project |
| |
| Returned if the user has the administrator permission or if the scheme is used in a project in which the |
| user has the administrative permission |
| |
| :param project_id_or_key: int |
| :param only_levels: bool |
| :return: list |
| """ |
| url = "rest/api/2/project/{}/issuesecuritylevelscheme".format(project_id_or_key) |
| try: |
| response = self.get(url) |
| except HTTPError as e: |
| if e.response.status_code == 401: |
| raise ApiPermissionError("Returned if the user is not logged in.", reason=e) |
| elif e.response.status_code == 403: |
| raise ApiPermissionError("User doesn't have administrative permissions", reason=e) |
| elif e.response.status_code == 404: |
| raise ApiNotFoundError( |
| "Returned if the project does not exist, or is not visible to the calling user", |
| reason=e, |
| ) |
| raise |
| if only_levels is True and response: |
| return response.get("levels") or None |
| return response |
|
|
| def get_all_priority_schemes(self, start=0, limit=100, expand=None): |
| """ |
| Returns all priority schemes. |
| All project keys associated with the priority scheme will only be returned |
| if additional query parameter is provided expand=schemes.projectKeys. |
| :param start: the page offset, if not specified then defaults to 0 |
| :param limit: how many results on the page should be included. Defaults to 100, maximum is 1000. |
| :param expand: can be 'schemes.projectKeys' |
| :return: |
| """ |
| url = "rest/api/2/priorityschemes" |
| params = {} |
| if start: |
| params["startAt"] = int(start) |
| if limit: |
| params["maxResults"] = int(limit) |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| def create_priority_scheme(self, data): |
| """ |
| Creates new priority scheme. |
| :param data: |
| {"name": "New priority scheme", |
| "description": "Priority scheme for very important projects", |
| "defaultOptionId": "3", |
| "optionIds": [ |
| "1", |
| "2", |
| "3", |
| "4", |
| "5" |
| ]} |
| :return: Returned if the priority scheme was created. |
| """ |
| return self.post(path="rest/api/2/priorityschemes", data=data) |
|
|
| """ |
| Resource for associating priority schemes and projects. |
| Reference: |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project/{projectKeyOrId}/priorityscheme |
| """ |
|
|
| def get_priority_scheme_of_project(self, project_key_or_id, expand=None): |
| """ |
| Gets a full representation of a priority scheme in JSON format used by specified project. |
| Resource for associating priority scheme schemes and projects. |
| User must be global administrator or project administrator. |
| :param project_key_or_id: |
| :param expand: notificationSchemeEvents,user,group,projectRole,field,all |
| :return: |
| """ |
| params = {} |
| if expand: |
| params["expand"] = expand |
| url = "rest/api/2/project/{}/priorityscheme".format(project_key_or_id) |
| return self.get(url, params=params) |
|
|
| def assign_priority_scheme_for_project(self, project_key_or_id, priority_scheme_id): |
| """ |
| Assigns project with priority scheme. Priority scheme assign with migration is possible from the UI. |
| Operation will fail if migration is needed as a result of operation |
| eg. there are issues with priorities invalid in the destination scheme. |
| All project keys associated with the priority scheme will only be returned |
| if additional query parameter is provided expand=projectKeys. |
| :param project_key_or_id: |
| :param priority_scheme_id: |
| :return: |
| """ |
| url = "rest/api/2/project/{projectKeyOrId}/priorityscheme".format(projectKeyOrId=project_key_or_id) |
| data = {"id": priority_scheme_id} |
| return self.put(url, data=data) |
|
|
| """ |
| Provide security level information of the given project for the current user. |
| Reference: |
| https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project/{projectKeyOrId}/securitylevel |
| """ |
|
|
| def get_security_level_for_project(self, project_key_or_id): |
| """ |
| Returns all security levels for the project that the current logged in user has access to. |
| If the user does not have the Set Issue Security permission, the list will be empty. |
| :param project_key_or_id: |
| :return: Returns a list of all security levels in a project for which the current user has access. |
| """ |
| url = "rest/api/2/project/{projectKeyOrId}/securitylevel".format(projectKeyOrId=project_key_or_id) |
| return self.get(url) |
|
|
| """ |
| Provide project type |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/project/type |
| """ |
|
|
| def get_all_project_types(self): |
| """ |
| Returns all the project types defined on the Jira instance, |
| not taking into account whether the license to use those project types is valid or not. |
| :return: Returns a list with all the project types defined on the Jira instance. |
| """ |
| url = "rest/api/2/project/type" |
| return self.get(url) |
|
|
| """ |
| Provide project categories |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/projectCategory |
| """ |
|
|
| def get_all_project_categories(self): |
| """ |
| Returns all project categories |
| :return: Returns a list of project categories. |
| """ |
| url = "rest/api/2/projectCategory" |
| return self.get(url) |
|
|
| """ |
| Project validates |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/projectvalidate |
| """ |
|
|
| def get_project_validated_key(self, key): |
| """ |
| Validates a project key. |
| :param key: the project key |
| :return: |
| """ |
| params = {"key": key} |
| url = "rest/api/2/projectvalidate/key" |
| return self.get(url, params=params) |
|
|
| """ |
| REST resource for starting/stopping/querying indexing. |
| Reference: https://docs.atlassian.com/software/jira/docs/api/REST/8.5.0/#api/2/reindex |
| """ |
|
|
| def reindex( |
| self, |
| comments=True, |
| change_history=True, |
| worklogs=True, |
| indexing_type="BACKGROUND_PREFERRED", |
| ): |
| """ |
| Reindex the Jira instance |
| Kicks off a reindex. Need Admin permissions to perform this reindex. |
| Type of re-indexing available: |
| FOREGROUND - runs a lock/full reindexing |
| BACKGROUND - runs a background reindexing. |
| If Jira fails to finish the background reindexing, respond with 409 Conflict (error message). |
| BACKGROUND_PREFERRED - If possible do a background reindexing. |
| If it's not possible (due to an inconsistent index), do a foreground reindexing. |
| :param comments: Indicates that comments should also be reindexed. Not relevant for foreground reindex, |
| where comments are always reindexed. |
| :param change_history: Indicates that changeHistory should also be reindexed. |
| Not relevant for foreground reindex, where changeHistory is always reindexed. |
| :param worklogs: Indicates that changeHistory should also be reindexed. |
| Not relevant for foreground reindex, where changeHistory is always reindexed. |
| :param indexing_type: OPTIONAL: The default value for the type is BACKGROUND_PREFERRED |
| :return: |
| """ |
| params = {} |
| if not comments: |
| params["indexComments"] = comments |
| if not change_history: |
| params["indexChangeHistory"] = change_history |
| if not worklogs: |
| params["indexWorklogs"] = worklogs |
| if not indexing_type: |
| params["type"] = indexing_type |
| return self.post("rest/api/2/reindex", params=params) |
|
|
| def reindex_with_type(self, indexing_type="BACKGROUND_PREFERRED"): |
| """ |
| Reindex the Jira instance |
| Type of re-indexing available: |
| FOREGROUND - runs a lock/full reindexing |
| BACKGROUND - runs a background reindexing. |
| If Jira fails to finish the background reindexing, respond with 409 Conflict (error message). |
| BACKGROUND_PREFERRED - If possible do a background reindexing. |
| If it's not possible (due to an inconsistent index), do a foreground reindexing. |
| :param indexing_type: OPTIONAL: The default value for the type is BACKGROUND_PREFERRED |
| :return: |
| """ |
| return self.reindex(indexing_type=indexing_type) |
|
|
| def reindex_status(self): |
| """ |
| Returns information on the system reindexes. |
| If a reindex is currently taking place then information about this reindex is returned. |
| If there is no active index task, then returns information about the latest reindex task run, |
| otherwise returns a 404 indicating that no reindex has taken place. |
| :return: |
| """ |
| return self.get("rest/api/2/reindex") |
|
|
| def reindex_project(self, project_key): |
| return self.post( |
| "secure/admin/IndexProject.jspa", |
| data="confirmed=true&key={}".format(project_key), |
| headers=self.form_token_headers, |
| ) |
|
|
| def reindex_issue(self, list_of_): |
| pass |
|
|
| def get_server_info(self, do_health_check=False): |
| """ |
| Returns general information about the current Jira server. |
| with health checks or not. |
| """ |
| if do_health_check: |
| check = True |
| else: |
| check = False |
| return self.get("rest/api/2/serverInfo", params={"doHealthCheck": check}) |
|
|
| |
| |
| |
| def tempo_account_get_accounts(self, skip_archived=None, expand=None): |
| """ |
| Get all Accounts that the logged in user has permission to browse. |
| :param skip_archived: bool OPTIONAL: skip archived Accounts, either true or false, default value true. |
| :param expand: bool OPTIONAL: With expanded data or not |
| :return: |
| """ |
| params = {} |
| if skip_archived is not None: |
| params["skipArchived"] = skip_archived |
| if expand is not None: |
| params["expand"] = expand |
| url = "rest/tempo-accounts/1/account" |
| return self.get(url, params=params) |
|
|
| def tempo_account_get_accounts_by_jira_project(self, project_id): |
| """ |
| Get Accounts by JIRA Project. The Caller must have the Browse Account permission for Account. |
| This will return Accounts for which the Caller has Browse Account Permission for. |
| :param project_id: str the project id. |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/account/project/{}".format(project_id) |
| return self.get(url) |
|
|
| def tempo_account_associate_with_jira_project( |
| self, account_id, project_id, default_account=False, link_type="MANUAL" |
| ): |
| """ |
| The AccountLinkBean for associate Account with project |
| Adds a link to an Account. |
| { |
| scopeType:PROJECT |
| defaultAccount:boolean |
| linkType:IMPORTED | MANUAL |
| name:string |
| key:string |
| accountId:number |
| scope:number |
| id:number |
| } |
| :param project_id: |
| :param account_id |
| :param default_account |
| :param link_type |
| :return: |
| """ |
| data = {} |
| if account_id: |
| data["accountId"] = account_id |
| if default_account: |
| data["defaultAccount"] = default_account |
| if link_type: |
| data["linkType"] = link_type |
| if project_id: |
| data["scope"] = project_id |
| data["scopeType"] = "PROJECT" |
|
|
| url = "rest/tempo-accounts/1/link/" |
| return self.post(url, data=data) |
|
|
| def tempo_account_add_account(self, data=None): |
| """ |
| Creates Account, adding new Account requires the Manage Accounts Permission. |
| :param data: String then it will convert to json |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/account/" |
| if data is None: |
| return """Please, provide data e.g. |
| {name: "12312312321", |
| key: "1231231232", |
| lead: {name: "myusername"}, |
| } |
| detail info: http://developer.tempo.io/doc/accounts/api/rest/latest/#-700314780 |
| """ |
| return self.post(url, data=data) |
|
|
| def tempo_account_delete_account_by_id(self, account_id): |
| """ |
| Delete an Account by id. Caller must have the Manage Account Permission for the Account. |
| The Account can not be deleted if it has an AccountLinkBean. |
| :param account_id: the id of the Account to be deleted. |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/account/{id}/".format(id=account_id) |
| return self.delete(url) |
|
|
| def tempo_account_get_rate_table_by_account_id(self, account_id): |
| """ |
| Returns a rate table for the specified account. |
| :param account_id: the account id. |
| :return: |
| """ |
| params = {"scopeType": "ACCOUNT", "scopeId": account_id} |
| url = "rest/tempo-accounts/1/ratetable" |
| return self.get(url, params=params) |
|
|
| def tempo_account_get_all_account_by_customer_id(self, customer_id): |
| """ |
| Get un-archived Accounts by customer. The Caller must have the Browse Account permission for the Account. |
| :param customer_id: the Customer id. |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/account/customer/{customerId}/".format(customerId=customer_id) |
| return self.get(url) |
|
|
| def tempo_account_get_customers(self, query=None, count_accounts=None): |
| """ |
| Gets all or some Attribute whose key or name contain a specific substring. |
| Attributes can be a Category or Customer. |
| :param query: OPTIONAL: query for search |
| :param count_accounts: bool OPTIONAL: provide how many associated Accounts with Customer |
| :return: list of customers |
| """ |
| params = {} |
| if query is not None: |
| params["query"] = query |
| if count_accounts is not None: |
| params["countAccounts"] = count_accounts |
| url = "rest/tempo-accounts/1/customer" |
| return self.get(url, params=params) |
|
|
| def tempo_account_add_new_customer(self, key, name): |
| """ |
| Gets all or some Attribute whose key or name contain a specific substring. |
| Attributes can be a Category or Customer. |
| :param key: |
| :param name: |
| :return: if error will show in error log, like validation unsuccessful. If success will good. |
| """ |
| data = {"name": name, "key": key} |
| url = "rest/tempo-accounts/1/customer" |
| return self.post(url, data=data) |
|
|
| def tempo_account_add_customer(self, data=None): |
| """ |
| Gets all or some Attribute whose key or name contain a specific substring. |
| Attributes can be a Category or Customer. |
| :param data: |
| :return: if error will show in error log, like validation unsuccessful. If success will good. |
| """ |
| if data is None: |
| return """Please, set the data as { isNew:boolean |
| name:string |
| key:string |
| id:number } or you can put only name and key parameters""" |
| url = "rest/tempo-accounts/1/customer" |
| return self.post(url, data=data) |
|
|
| def tempo_account_get_customer_by_id(self, customer_id=1): |
| """ |
| Get Account Attribute whose key or name contain a specific substring. Attribute can be a Category or Customer. |
| :param customer_id: id of Customer record |
| :return: Customer info |
| """ |
| url = "rest/tempo-accounts/1/customer/{id}".format(id=customer_id) |
| return self.get(url) |
|
|
| def tempo_account_update_customer_by_id(self, customer_id=1, data=None): |
| """ |
| Updates an Attribute. Caller must have Manage Account Permission. Attribute can be a Category or Customer. |
| :param customer_id: id of Customer record |
| :param data: format is |
| { |
| isNew:boolean |
| name:string |
| key:string |
| id:number |
| } |
| :return: json with parameters name, key and id. |
| """ |
| if data is None: |
| return """Please, set the data as { isNew:boolean |
| name:string |
| key:string |
| id:number }""" |
| url = "rest/tempo-accounts/1/customer/{id}".format(id=customer_id) |
| return self.put(url, data=data) |
|
|
| def tempo_account_delete_customer_by_id(self, customer_id=1): |
| """ |
| Delete an Attribute. Caller must have Manage Account Permission. Attribute can be a Category or Customer. |
| :param customer_id: id of Customer record |
| :return: Customer info |
| """ |
| url = "rest/tempo-accounts/1/customer/{id}".format(id=customer_id) |
| return self.delete(url) |
|
|
| def tempo_account_export_accounts(self): |
| """ |
| Get csv export file of Accounts from Tempo |
| :return: csv file |
| """ |
| headers = self.form_token_headers |
| url = "rest/tempo-accounts/1/export" |
| return self.get(url, headers=headers, not_json_response=True) |
|
|
| def tempo_holiday_get_schemes(self): |
| """ |
| Provide a holiday schemes |
| :return: |
| """ |
| url = "rest/tempo-core/2/holidayschemes/" |
| return self.get(url) |
|
|
| def tempo_holiday_get_scheme_info(self, scheme_id): |
| """ |
| Provide a holiday scheme |
| :return: |
| """ |
| url = "rest/tempo-core/2/holidayschemes/{}".format(scheme_id) |
| return self.get(url) |
|
|
| def tempo_holiday_get_scheme_members(self, scheme_id): |
| """ |
| Provide a holiday scheme members |
| :return: |
| """ |
| url = "rest/tempo-core/2/holidayschemes/{}/members".format(scheme_id) |
| return self.get(url) |
|
|
| def tempo_holiday_put_into_scheme_member(self, scheme_id, username): |
| """ |
| Provide a holiday scheme |
| :return: |
| """ |
| url = "rest/tempo-core/2/holidayschemes/{}/member/{}/".format(scheme_id, username) |
| data = {"id": scheme_id} |
| return self.put(url, data=data) |
|
|
| def tempo_holiday_scheme_set_default(self, scheme_id): |
| """ |
| Set as default the holiday scheme |
| :param scheme_id: |
| :return: |
| """ |
| |
| |
|
|
| url = "rest/tempo-core/2/holidayscheme/setDefault/{}".format(scheme_id) |
| data = {"id": scheme_id} |
| return self.post(url, data=data) |
|
|
| def tempo_workload_scheme_get_members(self, scheme_id): |
| """ |
| Provide a workload scheme members |
| :param scheme_id: |
| :return: |
| """ |
| url = "rest/tempo-core/1/workloadscheme/users/{}".format(scheme_id) |
| return self.get(url) |
|
|
| def tempo_workload_scheme_set_member(self, scheme_id, member): |
| """ |
| Provide a workload scheme members |
| :param member: user name of user |
| :param scheme_id: |
| :return: |
| """ |
| url = "rest/tempo-core/1/workloadscheme/user/{}".format(member) |
| data = {"id": scheme_id} |
| return self.put(url, data=data) |
|
|
| def tempo_timesheets_get_configuration(self): |
| """ |
| Provide the configs of timesheets |
| :return: |
| """ |
| url = "rest/tempo-timesheets/3/private/config/" |
| return self.get(url) |
|
|
| def tempo_timesheets_get_team_utilization(self, team_id, date_from, date_to=None, group_by=None): |
| """ |
| Get team utilization. Response in json |
| :param team_id: |
| :param date_from: |
| :param date_to: |
| :param group_by: |
| :return: |
| """ |
| url = "rest/tempo-timesheets/3/report/team/{}/utilization".format(team_id) |
| params = {"dateFrom": date_from, "dateTo": date_to} |
|
|
| if group_by: |
| params["groupBy"] = group_by |
| return self.get(url, params=params) |
|
|
| def tempo_timesheets_get_worklogs( |
| self, |
| date_from=None, |
| date_to=None, |
| username=None, |
| project_key=None, |
| account_key=None, |
| team_id=None, |
| ): |
| """ |
| |
| :param date_from: yyyy-MM-dd |
| :param date_to: yyyy-MM-dd |
| :param username: name of the user you wish to get the worklogs for |
| :param project_key: key of a project you wish to get the worklogs for |
| :param account_key: key of an account you wish to get the worklogs for |
| :param team_id: id of the Team you wish to get the worklogs for |
| :return: |
| """ |
| params = {} |
| if date_from: |
| params["dateFrom"] = date_from |
| if date_to: |
| params["dateTo"] = date_to |
| if username: |
| params["username"] = username |
| if project_key: |
| params["projectKey"] = project_key |
| if account_key: |
| params["accountKey"] = account_key |
| if team_id: |
| params["teamId"] = team_id |
| url = "rest/tempo-timesheets/3/worklogs/" |
| return self.get(url, params=params) |
|
|
| def tempo_4_timesheets_find_worklogs(self, **params): |
| """ |
| Find existing worklogs with searching parameters. |
| NOTE: check if you are using correct types for the parameters! |
| :param from: string From Date |
| :param to: string To Date |
| :param worker: Array of strings |
| :param taskId: Array of integers |
| :param taskKey: Array of strings |
| :param projectId: Array of integers |
| :param projectKey: Array of strings |
| :param teamId: Array of integers |
| :param roleId: Array of integers |
| :param accountId: Array of integers |
| :param accountKey: Array of strings |
| :param filterId: Array of integers |
| :param customerId: Array of integers |
| :param categoryId: Array of integers |
| :param categoryTypeId: Array of integers |
| :param epicKey: Array of strings |
| :param updatedFrom: string |
| :param includeSubtasks: boolean |
| :param pageNo: integer |
| :param maxResults: integer |
| :param offset: integer |
| """ |
|
|
| url = "rest/tempo-timesheets/4/worklogs/search" |
| return self.post(url, data=params) |
|
|
| def tempo_timesheets_get_worklogs_by_issue(self, issue): |
| """ |
| Get Tempo timesheet worklog by issue key or id. |
| :param issue: Issue key or Id |
| :return: |
| """ |
| url = "rest/tempo-timesheets/4/worklogs/jira/issue/{issue}".format(issue=issue) |
| return self.get(url) |
|
|
| def tempo_timesheets_write_worklog(self, worker, started, time_spend_in_seconds, issue_id, comment=None): |
| """ |
| Log work for user |
| :param worker: |
| :param started: |
| :param time_spend_in_seconds: |
| :param issue_id: |
| :param comment: |
| :return: |
| """ |
| data = { |
| "worker": worker, |
| "started": started, |
| "timeSpentSeconds": time_spend_in_seconds, |
| "originTaskId": str(issue_id), |
| } |
| if comment: |
| data["comment"] = comment |
| url = "rest/tempo-timesheets/4/worklogs/" |
| return self.post(url, data=data) |
|
|
| def tempo_timesheets_approval_worklog_report(self, user_key, period_start_date): |
| """ |
| Return timesheets for approval |
| :param user_key: |
| :param period_start_date: |
| :return: |
| """ |
| url = "rest/tempo-timesheets/4/timesheet-approval/current" |
| params = {} |
| if period_start_date: |
| params["periodStartDate"] = period_start_date |
| if user_key: |
| params["userKey"] = user_key |
| return self.get(url, params=params) |
|
|
| def tempo_timesheets_get_required_times(self, from_date, to_date, user_name): |
| """ |
| Provide time how much should work |
| :param from_date: |
| :param to_date: |
| :param user_name: |
| :return: |
| """ |
| url = "rest/tempo-timesheets/3/private/days" |
| params = {} |
| if from_date: |
| params["from"] = from_date |
| if to_date: |
| params["to"] = to_date |
| if user_name: |
| params["user"] = user_name |
| return self.get(url, params=params) |
|
|
| def tempo_timesheets_approval_status(self, period_start_date, user_name): |
| url = "rest/tempo-timesheets/4/timesheet-approval/approval-statuses" |
| params = {} |
| if user_name: |
| params["userKey"] = user_name |
| if period_start_date: |
| params["periodStartDate"] = period_start_date |
| return self.get(url, params=params) |
|
|
| def tempo_get_links_to_project(self, project_id): |
| """ |
| Gets all links to a specific project |
| :param project_id: |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/link/project/{}/".format(project_id) |
| return self.get(url) |
|
|
| def tempo_get_default_link_to_project(self, project_id): |
| """ |
| Gets the default link to a specific project |
| :param project_id: |
| :return: |
| """ |
| url = "rest/tempo-accounts/1/link/project/{}/default/".format(project_id) |
| return self.get(url) |
|
|
| def tempo_teams_get_all_teams(self, expand=None): |
| url = "rest/tempo-teams/2/team" |
| params = {} |
| if expand: |
| params["expand"] = expand |
| return self.get(url, params=params) |
|
|
| def tempo_teams_add_member(self, team_id, member_key): |
| """ |
| Add team member |
| :param team_id: |
| :param member_key: user_name or user_key of Jira |
| :return: |
| """ |
| data = { |
| "member": {"key": str(member_key), "type": "USER"}, |
| "membership": {"availability": "100", "role": {"id": 1}}, |
| } |
| return self.tempo_teams_add_member_raw(team_id, member_data=data) |
|
|
| def tempo_teams_add_membership(self, team_id, member_id): |
| """ |
| Add team member |
| :param team_id: |
| :param member_id: |
| :return: |
| """ |
| data = { |
| "teamMemberId": member_id, |
| "teamId": team_id, |
| "availability": "100", |
| "role": {"id": 1}, |
| } |
| url = "rest/tempo-teams/2/team/{}/member/{}/membership".format(team_id, member_id) |
| return self.post(url, data=data) |
|
|
| def tempo_teams_add_member_raw(self, team_id, member_data): |
| """ |
| Add team member |
| :param team_id: |
| :param member_data: |
| :return: |
| """ |
| url = "rest/tempo-teams/2/team/{}/member/".format(team_id) |
| data = member_data |
| return self.post(url, data=data) |
|
|
| def tempo_teams_get_members(self, team_id): |
| """ |
| Get members from team |
| :param team_id: |
| :return: |
| """ |
| url = "rest/tempo-teams/2/team/{}/member/".format(team_id) |
| return self.get(url) |
|
|
| def tempo_teams_remove_member(self, team_id, member_id, membership_id): |
| """ |
| Remove team membership |
| :param team_id: |
| :param member_id: |
| :param membership_id: |
| :return: |
| """ |
| url = "rest/tempo-teams/2/team/{}/member/{}/membership/{}".format(team_id, member_id, membership_id) |
| return self.delete(url) |
|
|
| def tempo_teams_update_member_information(self, team_id, member_id, membership_id, data): |
| """ |
| Update team membership attribute info |
| :param team_id: |
| :param member_id: |
| :param membership_id: |
| :param data: |
| :return: |
| """ |
| url = "rest/tempo-teams/2/team/{}/member/{}/membership/{}".format(team_id, member_id, membership_id) |
| return self.put(url, data=data) |
|
|
| def tempo_timesheets_get_period_configuration(self): |
| return self.get("rest/tempo-timesheets/3/period-configuration") |
|
|
| def tempo_timesheets_get_private_configuration(self): |
| return self.get("rest/tempo-timesheets/3/private/config") |
|
|
| def tempo_teams_get_memberships_for_member(self, username): |
| return self.get("rest/tempo-teams/2/user/{}/memberships".format(username)) |
|
|
| |
| |
| |
| |
| def get_all_agile_boards(self, board_name=None, project_key=None, board_type=None, start=0, limit=50): |
| """ |
| Returns all boards. This only includes boards that the user has permission to view. |
| :param board_name: |
| :param project_key: |
| :param board_type: |
| :param start: |
| :param limit: |
| :return: |
| """ |
| url = "rest/agile/1.0/board" |
| params = {} |
| if board_name: |
| params["name"] = board_name |
| if project_key: |
| params["projectKeyOrId"] = project_key |
| if board_type: |
| params["type"] = board_type |
| if start: |
| params["startAt"] = int(start) |
| if limit: |
| params["maxResults"] = int(limit) |
|
|
| return self.get(url, params=params) |
|
|
| def get_agile_board(self, board_id): |
| """ |
| Get agile board info by id |
| :param board_id: |
| :return: |
| """ |
| url = "rest/agile/1.0/board/{}".format(str(board_id)) |
| return self.get(url) |
|
|
| def create_agile_board(self, name, type, filter_id, location=None): |
| """ |
| Create an agile board |
| :param name: str |
| :param type: str, scrum or kanban |
| :param filter_id: int |
| :param location: dict, Optional. Only specify this for Jira Cloud! |
| """ |
| data = {"name": name, "type": type, "filterId": filter_id} |
| if location: |
| data["location"] = location |
| url = "rest/agile/1.0/board" |
| return self.post(url, data=data) |
|
|
| def get_agile_board_by_filter_id(self, filter_id): |
| """ |
| Gets an agile board by the filter id |
| :param filter_id: int, str |
| """ |
| url = "rest/agile/1.0/board/filter/{filter_id}".format(filter_id=filter_id) |
| return self.get(url) |
|
|
| def get_agile_board_configuration(self, board_id): |
| """ |
| Get the board configuration. The response contains the following fields: |
| id - Id of the board. |
| name - Name of the board. |
| filter - Reference to the filter used by the given board. |
| subQuery (Kanban only) - JQL subquery used by the given board. |
| columnConfig - The column configuration lists the columns for the board, |
| in the order defined in the column configuration. For each column, |
| it shows the issue status mapping as well as the constraint type |
| (Valid values: none, issueCount, issueCountExclSubs) for |
| the min/max number of issues. Note, the last column with statuses |
| mapped to it is treated as the "Done" column, which means that issues |
| in that column will be marked as already completed. |
| estimation (Scrum only) - Contains information about type of estimation used for the board. |
| Valid values: none, issueCount, field. If the estimation type is "field", |
| the Id and display name of the field used for estimation is also returned. |
| Note, estimates for an issue can be updated by a PUT /rest/api/2/issue/{issueIdOrKey} |
| request, however the fields must be on the screen. "timeoriginalestimate" field will never be |
| on the screen, so in order to update it "originalEstimate" in "timetracking" field should be updated. |
| ranking - Contains information about custom field used for ranking in the given board. |
| :param board_id: |
| :return: |
| """ |
| url = "rest/agile/1.0/board/{}/configuration".format(str(board_id)) |
| return self.get(url) |
|
|
| def get_issues_for_backlog(self, board_id): |
| """ |
| :param board_id: int, str |
| """ |
| url = "rest/agile/1.0/{board_id}/backlog".format(board_id=board_id) |
| return self.get(url) |
|
|
| def get_issues_for_board(self, board_id, jql, fields="*all", start=0, limit=None, expand=None): |
| """ |
| Get issues for board |
| :param board_id: int, str |
| :param jql: |
| :param fields: list of fields, for example: ['priority', 'summary', 'customfield_10007'] |
| :param start: OPTIONAL: The start point of the collection to return. Default: 0. |
| :param limit: OPTIONAL: The limit of the number of issues to return, this may be restricted by |
| fixed system limits. Default by built-in method: 50 |
| :param expand: OPTIONAL: expand the search result |
| :return: |
| """ |
| params = {} |
| if start is not None: |
| params["startAt"] = int(start) |
| if limit is not None: |
| params["maxResults"] = int(limit) |
| if fields is not None: |
| if isinstance(fields, (list, tuple, set)): |
| fields = ",".join(fields) |
| params["fields"] = fields |
| if jql is not None: |
| params["jql"] = jql |
| if expand is not None: |
| params["expand"] = expand |
|
|
| url = "rest/agile/1.0/board/{board_id}/issue".format(board_id=board_id) |
| return self.get(url, params=params) |
|
|
| def delete_agile_board(self, board_id): |
| """ |
| Delete agile board by id |
| :param board_id: |
| :return: |
| """ |
| url = "rest/agile/1.0/board/{}".format(str(board_id)) |
| return self.delete(url) |
|
|
| def get_agile_board_properties(self, board_id): |
| """ |
| Gets a list of all the board properties |
| :param board_id: int, str |
| """ |
| url = "rest/agile/1.0/board/{board_id}/properties".format(board_id=board_id) |
| return self.get(url) |
|
|
| def create_sprint(self, name, board_id, start_date=None, end_date=None, goal=None): |
| """ |
| Create a sprint within a board. |
| ! User requires `Manage Sprints` permission for relevant boards. |
| |
| :param name: str: Name for the Sprint to be created |
| :param board_id: int: The ID for the Board in which the Sprint will be created |
| :param start_date: str: The Start Date for Sprint in isoformat |
| example value is "2015-04-11T15:22:00.000+10:00" |
| :param end_date: str: The End Date for Sprint in isoformat |
| example value is "2015-04-20T01:22:00.000+10:00" |
| :param goal: str: Goal Text for setting for the Sprint |
| :return: Dictionary of response received from the API |
| |
| https://docs.atlassian.com/jira-software/REST/8.9.0/#agile/1.0/sprint |
| isoformat can be created with datetime.datetime.isoformat() |
| """ |
| url = "/rest/agile/1.0/sprint" |
| data = dict(name=name, originBoardId=board_id) |
| if start_date: |
| data["startDate"] = start_date |
| if end_date: |
| data["endDate"] = end_date |
| if goal: |
| data["goal"] = goal |
| return self.post(url, data=data) |
|
|
| def add_issues_to_sprint(self, sprint_id, issues): |
| """ |
| Adding Issue(s) to Sprint |
| :param sprint_id: int/str: The ID for the Sprint. |
| Sprint to be Active or Open only. |
| eg. 104 |
| :param issues: list: List of Issue Keys |
| eg. ['APA-1', 'APA-2'] |
| :return: Dictionary of response received from the API |
| |
| https://docs.atlassian.com/jira-software/REST/8.9.0/#agile/1.0/sprint-moveIssuesToSprint |
| """ |
| if not isinstance(issues, list): |
| raise ValueError("`issues` param should be List of Issue Keys") |
| url = "/rest/agile/1.0/sprint/{sprint_id}/issue".format(sprint_id=sprint_id) |
| data = dict(issues=issues) |
| return self.post(url, data=data) |
|
|
| def get_all_sprint(self, board_id, state=None, start=0, limit=50): |
| """ |
| Returns all sprints from a board, for a given board Id. |
| This only includes sprints that the user has permission to view. |
| :param board_id: |
| :param state: Filters results to sprints in specified states. |
| Valid values: future, active, closed. |
| You can define multiple states separated by commas, e.g. state=active,closed |
| :param start: The starting index of the returned sprints. |
| Base index: 0. |
| See the 'Pagination' section at the top of this page for more details. |
| :param limit: The maximum number of sprints to return per page. |
| Default: 50. |
| See the 'Pagination' section at the top of this page for more details. |
| :return: |
| """ |
| params = {} |
| if start: |
| params["startAt"] = start |
| if limit: |
| params["maxResults"] = limit |
| if state: |
| params["state"] = state |
| url = "rest/agile/1.0/board/{boardId}/sprint".format(boardId=board_id) |
| return self.get(url, params=params) |
|
|
| def get_sprint(self, sprint_id): |
| """ |
| Returns the sprint for a given sprint Id. |
| The sprint will only be returned if the user can view the board that the sprint was created on, |
| or view at least one of the issues in the sprint. |
| :param sprint_id: |
| :return: |
| """ |
| url = "rest/agile/1.0/sprint/{sprintId}".format(sprintId=sprint_id) |
| return self.get(url) |
|
|
| def rename_sprint(self, sprint_id, name, start_date, end_date): |
| """ |
| |
| :param sprint_id: |
| :param name: |
| :param start_date: |
| :param end_date: |
| :return: |
| """ |
| return self.put( |
| "rest/greenhopper/1.0/sprint/{0}".format(sprint_id), |
| data={"name": name, "startDate": start_date, "endDate": end_date}, |
| ) |
|
|
| def delete_sprint(self, sprint_id): |
| """ |
| Deletes a sprint. |
| Once a sprint is deleted, all issues in the sprint will be moved to the backlog. |
| Note, only future sprints can be deleted. |
| :param sprint_id: |
| :return: |
| """ |
| return self.delete("rest/agile/1.0/sprint/{sprintId}".format(sprintId=sprint_id)) |
|
|
| def update_partially_sprint(self, sprint_id, data): |
| """ |
| Performs a partial update of a sprint. |
| A partial update means that fields not present in the request JSON will not be updated. |
| Notes: |
| |
| Sprints that are in a closed state cannot be updated. |
| A sprint can be started by updating the state to 'active'. |
| This requires the sprint to be in the 'future' state and have a startDate and endDate set. |
| A sprint can be completed by updating the state to 'closed'. |
| This action requires the sprint to be in the 'active' state. |
| This sets the completeDate to the time of the request. |
| Other changes to state are not allowed. |
| The completeDate field cannot be updated manually. |
| :param sprint_id: |
| :param data: { "name": "new name"} |
| :return: |
| """ |
| return self.post("rest/agile/1.0/sprint/{}".format(sprint_id), data=data) |
|
|
| def get_sprint_issues(self, sprint_id, start, limit): |
| """ |
| Returns all issues in a sprint, for a given sprint Id. |
| This only includes issues that the user has permission to view. |
| By default, the returned issues are ordered by rank. |
| :param sprint_id: |
| :param start: The starting index of the returned issues. |
| Base index: 0. |
| See the 'Pagination' section at the top of this page for more details. |
| :param limit: The maximum number of issues to return per page. |
| Default: 50. |
| See the 'Pagination' section at the top of this page for more details. |
| Note, the total number of issues returned is limited by the property |
| 'jira.search.views.default.max' in your Jira instance. |
| If you exceed this limit, your results will be truncated. |
| :return: |
| """ |
| params = {} |
| if start: |
| params["startAt"] = start |
| if limit: |
| params["maxResults"] = limit |
| url = "rest/agile/1.0/sprint/{sprintId}/issue".format(sprintId=sprint_id) |
| return self.get(url, params=params) |
|
|
| def update_rank(self, issues_to_rank, rank_before, customfield_number): |
| """ |
| Updates the rank of issues (max 50), placing them before a given issue. |
| :param issues_to_rank: List of issues to rank (max 50) |
| :param rank_before: Issue that the issues will be put over |
| :param customfield_number: The number of the custom field Rank |
| :return: |
| """ |
| return self.put( |
| "rest/agile/1.0/issue/rank", |
| data={ |
| "issues": issues_to_rank, |
| "rankBeforeIssue": rank_before, |
| "rankCustomFieldId": customfield_number, |
| }, |
| ) |
|
|
| def dvcs_get_linked_repos(self): |
| """ |
| Get DVCS linked repos |
| :return: |
| """ |
| url = "rest/bitbucket/1.0/repositories" |
| return self.get(url) |
|
|
| def dvcs_update_linked_repo_with_remote(self, repository_id): |
| """ |
| Resync delayed sync repo |
| https://confluence.atlassian.com/jirakb/delays-for-commits-to-display-in-development-panel-in-jira-server-779160823.html |
| :param repository_id: |
| :return: |
| """ |
| url = "rest/bitbucket/1.0/repositories/{}/sync".format(repository_id) |
| return self.post(url) |
|
|
| def health_check(self): |
| """ |
| Get health status |
| https://confluence.atlassian.com/jirakb/how-to-retrieve-health-check-results-using-rest-api-867195158.html |
| :return: |
| """ |
| |
| response = self.get("rest/troubleshooting/1.0/check/") |
| if not response: |
| |
| response = self.get("rest/supportHealthCheck/1.0/check/") |
| return response |
|
|
