Bamboo new methods (#392)

* [Jira] Consolidate the Jira8 module into main
* [Bamboo] Add reindex methods
* [Bamboo] Project related methods
* Add update setup.py

Author: gonchik

atlassian/VERSION

@@ -1 +1,2 @@
-1.14.3
+1.14.4
+

atlassian/bamboo.py

@@ -406,6 +406,25 @@ def delete_label(self, project_key, plan_key, build_number, label):
         resource = "result/{}-{}-{}/label/{}".format(project_key, plan_key, build_number, label)
         return self.delete(self.resource_url(resource))
 
+    def get_projects(self):
+        """Method used to list all projects defined in Bamboo.
+        Projects without any plan are not listed by default, unless showEmpty query param is set to true."""
+        resource = 'project?showEmpty'
+        for project in self.get(self.resource_url(resource)):
+            yield project
+
+    def get_project(self, project_key):
+        """Method used to retrieve information for project specified as project key.
+        Possible expand parameters: plans, list of plans for project. plans.plan, list of plans with plan details
+        (only plans visible - READ permission for user)"""
+        resource = 'project/{}?showEmpty'.format(project_key)
+        return self.get(self.resource_url(resource))
+
+    def delete_project(self, project_key):
+        """Marks project for deletion. Project will be deleted by a batch job."""
+        resource = 'project/{}'.format(project_key)
+        return self.delete(self.resource_url(resource))
+
     """ Deployments """
 
     def deployment_projects(self):
@@ -590,6 +609,20 @@ def chart(self, report_key, build_keys, group_by_period, date_filter=None, date_
             params['height'] = height
         return self.get(self.resource_url('chart'), params=params)
 
+    def reindex(self):
+        """
+        Returns status of the current indexing operation.
+        reindexInProgress - reindex is currently performed in background reindexPending - reindex is required
+        (i.e. it failed before or some upgrade task asked for it)
+        """
+        return self.get(self.resource_url('reindex'))
+
+    def stop_reindex(self):
+        """
+        Kicks off a reindex. Requires system admin permissions to perform this reindex.
+        """
+        return self.post(self.resource_url('reindex'))
+
     def health_check(self):
         """
         Get health status

atlassian/jira.py

@@ -2,7 +2,6 @@
 import logging
 
 from requests.exceptions import HTTPError
-
 from .rest_client import AtlassianRestAPI
 
 log = logging.getLogger(__name__)
@@ -62,7 +61,7 @@ def jql(self, jql, fields='*all', start=0, limit=None, expand=None):
         :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: expland the search result
+        :param expand: OPTIONAL: expand the search result
         :return:
         """
         params = {}
@@ -306,18 +305,18 @@ def user_find_by_user_string(self, username, start=0, limit=50, include_inactive
                   'maxResults': limit
                   }
         return self.get(url, params=params)
-    
+
     def is_user_in_application(self, username, applicationKey):
         """
         Utility function to test whether a user has an application role
         :param username: The username of the user to test.
         :param applicationKey: The application key of the application
         :return: True if the user has the application, else False
         """
-        user = self.user(username, 'applicationRoles') # Get applications roles of the user
+        user = self.user(username, 'applicationRoles')  # Get applications roles of the user
         if 'self' in user:
             for applicationRole in user.get('applicationRoles').get('items'):
-                if applicationRole.get('key')==applicationKey:
+                if applicationRole.get('key') == applicationKey:
                     return True
 
         return False
@@ -334,8 +333,28 @@ def add_user_to_application(self, username, applicationKey):
             'username': username,
             'applicationKey': applicationKey
         }
-        return self.post('rest/api/2/user/application', params=params)==None
-    
+        return self.post('rest/api/2/user/application', params=params) == None
+
+    # Application roles
+    def get_all_application_roles(self):
+        """
+        Returns all ApplicationRoles in the system
+        :return:
+        """
+        url = 'rest/api/2/applicationrole'
+
+        return self.get(url)
+
+    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)
+
     def projects(self, included_archived=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.
@@ -527,6 +546,31 @@ def create_issue_type(self, name, description='', type='standard'):
     def issue(self, key, fields='*all'):
         return self.get('rest/api/2/issue/{0}?fields={1}'.format(key, fields))
 
+    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:
+            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:
@@ -886,11 +930,54 @@ def issue_deleted(self, issue_key):
             log.info('Issue "{issue_key}" is deleted'.format(issue_key=issue_key))
             return True
 
+    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)
+
+    # @todo merge with edit_issue method
     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
@@ -915,9 +1002,38 @@ def assign_issue(self, issue, assignee=None):
 
         return self.put(url, data=data)
 
+    def create_issue(self, fields, update_history=False):
+        """
+        Creates an issue or a sub-task from a JSON representation
+        :param fields: JSON data
+        :param update_history: bool (if true then the user's project history is updated)
+        :return:
+        """
+        url = 'rest/api/2/issue'
+        data = {'fields': fields}
+        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)
+
+    # @todo refactor and merge with create_issue method
     def issue_create(self, fields):
         log.warning('Creating issue "{summary}"'.format(summary=fields['summary']))
-        url = 'rest/api/2/issue/'
+        url = 'rest/api/2/issue'
         return self.post(url, data={'fields': fields})
 
     def issue_create_or_update(self, fields):
@@ -950,20 +1066,49 @@ def issue_add_comment(self, issue_key, comment, visibility=None):
             data['visibility'] = visibility
         return self.post(url, data=data)
 
+    # Attachments
+    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 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...')
         headers = {'X-Atlassian-Token': 'no-check'}
-        with open(filename, 'rb') as file:
-            files = {'file': file}
-            url = 'rest/api/2/issue/{}/attachments'.format(issue_key)
-
-            return self.post(url, headers=headers, files=files)
+        url = 'rest/api/2/issue/{}/attachments'.format(issue_key)
+        with open(filename, 'rb') as attachment:
+            files = {'file': attachment}
+        return self.post(url, headers=headers, files=files)
 
     def get_issue_remotelinks(self, issue_key, global_id=None, internal_id=None):
         """
@@ -1345,11 +1490,38 @@ def check_plugin_manager_status(self):
         url = 'rest/plugins/latest/safe-mode'
         return self.request(method='GET', path=url, headers=headers)
 
+    # API/2 Get permissions
+    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)
+
+        :param project_id: str
+        :param project_key: str
+        :param issue_id: str
+        :param issue_key: str
+        :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:
+        :return: All permissions
         """
         url = 'rest/api/2/permissions'
         return self.get(url)
@@ -1455,6 +1627,43 @@ def get_project_issue_security_scheme(self, project_id_or_key, only_levels=False
         else:
             return self.get(url)
 
+    # 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):
+        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)
+
     """
     #######################################################################
     #                   Tempo Account REST API implements                 #