def update(self, fields=None, async_=None, jira=None, notify=True, **kwargs):
        """Update this resource on the server.

        Keyword arguments are marshalled into a dict before being sent. If this
        resource doesn't support ``PUT``, a :py:exc:`.JIRAError` will be raised; subclasses that specialize this method
        will only raise errors in case of user error.

        :param fields: Fields which should be updated for the object.
        :type fields: Optional[Dict[str, Any]]
        :param async_: If true the request will be added to the queue so it can be executed later using async_run()
        :type async_: bool
        :param jira: Instance of JIRA Client
        :type jira: jira.JIRA
        :param notify: Whether or not to notify users about the update. (Default: True)
        :type notify: bool
        :type kwargs: **Any
        """
        if async_ is None:
            async_ = self._options['async']

        data = {}
        if fields is not None:
            data.update(fields)
        data.update(kwargs)

        data = json.dumps(data)

        if not notify:
            querystring = "?notifyUsers=false"
        else:
            querystring = ""

        r = self._session.put(
            self.self + querystring, data=data)
        if 'autofix' in self._options and \
                r.status_code == 400:
            user = None
            error_list = get_error_list(r)
            logging.error(error_list)
            if "The reporter specified is not a user." in error_list:
                if 'reporter' not in data['fields']:
                    logging.warning(
                        "autofix: setting reporter to '%s' and retrying the update." % self._options['autofix'])
                    data['fields']['reporter'] = {
                        'name': self._options['autofix']}

            if "Issues must be assigned." in error_list:
                if 'assignee' not in data['fields']:
                    logging.warning("autofix: setting assignee to '%s' for %s and retrying the update." % (
                        self._options['autofix'], self.key))
                    data['fields']['assignee'] = {
                        'name': self._options['autofix']}
                    # for some reason the above approach fails on Jira 5.2.11
                    # so we need to change the assignee before

            if "Issue type is a sub-task but parent issue key or id not specified." in error_list:
                logging.warning(
                    "autofix: trying to fix sub-task without parent by converting to it to bug")
                data['fields']['issuetype'] = {"name": "Bug"}
            if "The summary is invalid because it contains newline characters." in error_list:
                logging.warning("autofix: trying to fix newline in summary")
                data['fields'][
                    'summary'] = self.fields.summary.replace("/n", "")
            for error in error_list:
                if re.search(r"^User '(.*)' was not found in the system\.", error, re.U):
                    m = re.search(
                        r"^User '(.*)' was not found in the system\.", error, re.U)
                    if m:
                        user = m.groups()[0]
                    else:
                        raise NotImplementedError()
                if re.search(r"^User '(.*)' does not exist\.", error):
                    m = re.search(r"^User '(.*)' does not exist\.", error)
                    if m:
                        user = m.groups()[0]
                    else:
                        raise NotImplementedError()

            if user:
                logging.warning(
                    "Trying to add missing orphan user '%s' in order to complete the previous failed operation." % user)
                jira.add_user(user, 'noreply@example.com', 10100, active=False)
                # if 'assignee' not in data['fields']:
                #    logging.warning("autofix: setting assignee to '%s' and retrying the update." % self._options['autofix'])
                #    data['fields']['assignee'] = {'name': self._options['autofix']}
            # EXPERIMENTAL --->
            if async_:
                if not hasattr(self._session, '_async_jobs'):
                    self._session._async_jobs = set()
                self._session._async_jobs.add(threaded_requests.put(
                    self.self, data=json.dumps(data)))
            else:
                r = self._session.put(
                    self.self, data=json.dumps(data))

        time.sleep(self._options['delay_reload'])
        self._load(self.self)