def __str__(self):
     try:
         return super(Contact, self).__str__()
     except ResourceAttrError:
         if not getattr(self, 'last_name', False):
             return '{0}'.format(to_string(self.first_name))
         else:
             return '{0} {1}'.format(to_string(self.first_name), to_string(self.last_name))
示例#2
0
 def __str__(self):
     try:
         return super(Contact, self).__str__()
     except ResourceAttrError:
         if not getattr(self, 'last_name', False):
             return '{0}'.format(to_string(self.first_name))
         else:
             return '{0} {1}'.format(to_string(self.first_name),
                                     to_string(self.last_name))
示例#3
0
 def __repr__(self):
     try:
         return super(User, self).__repr__()
     except ResourceAttrError:
         return '<{0}.{1} #{2} "{3} {4}">'.format(self.__class__.__module__,
                                                  self.__class__.__name__,
                                                  self.id,
                                                  to_string(self.firstname),
                                                  to_string(self.lastname))
示例#4
0
 def __repr__(self):
     try:
         return super(User, self).__repr__()
     except ResourceAttrError:
         return '<{0}.{1} #{2} "{3} {4}">'.format(
             self.__class__.__module__,
             self.__class__.__name__,
             self.id,
             to_string(self.firstname),
             to_string(self.lastname)
         )
示例#5
0
 def __repr__(self):
     return '<{0}.{1} #{2} "{3}">'.format(
         self.__class__.__module__,
         self.__class__.__name__,
         self.id,
         to_string(self.title)
     )
示例#6
0
 def __repr__(self):
     try:
         return super(Contact, self).__repr__()
     except ResourceAttrError:
         if not getattr(self, 'last_name', False):
             return '<{0}.{1} #{2} "{3}">'.format(
                 self.__class__.__module__,
                 self.__class__.__name__,
                 self.id,
                 to_string(self.first_name),
             )
         else:
             return '<{0}.{1} #{2} "{3} {4}">'.format(
                 self.__class__.__module__, self.__class__.__name__,
                 self.id, to_string(self.first_name),
                 to_string(self.last_name))
示例#7
0
    def request(self, method, url, headers=None, params=None, data=None,
                raw_response=False):
        """Make requests to Redmine and returns result in json format."""
        kwargs = dict(self.requests, **{
            'headers': headers or {},
            'params': params or {},
            'data': data or {},
        })

        if ('Content-Type' not in kwargs['headers'] and
                method in ('post', 'put')):
            kwargs['data'] = json.dumps(data)
            kwargs['headers']['Content-Type'] = 'application/json'

        if self.impersonate is not None:
            kwargs['headers']['X-Redmine-Switch-User'] = self.impersonate

        # We would like to be authenticated by API key by default
        if 'key' not in kwargs['params'] and self.key is not None:
            kwargs['params']['key'] = self.key
        else:
            kwargs['auth'] = (self.username, self.password)

        api_url = join(self.url, url + '.json')
        response = yield from aiohttp.request(method, api_url, **kwargs)

        if response.status in (200, 201):
            if raw_response:
                return response
            text = yield from response.text()
            if not text.strip():
                return True
            else:
                try:
                    return json.loads(text)
                except (ValueError, TypeError):
                    raise JSONDecodeError
        elif response.status == 401:
            raise AuthError
        elif response.status == 403:
            raise ForbiddenError
        elif response.status == 404:
            raise ResourceNotFoundError
        elif response.status == 409:
            raise ConflictError
        elif response.status == 412 and self.impersonate is not None:
            raise ImpersonateError
        elif response.status == 413:
            raise RequestEntityTooLargeError
        elif response.status == 422:
            response_json = yield from response.json()
            errors = json_response(response_json)['errors']
            raise ValidationError(to_string(', '.join(e if is_string(e)
                                            else ': '.join(e)
                                            for e in errors)))
        elif response.status == 500:
            raise ServerError

        raise UnknownError(response.status)
示例#8
0
 def __repr__(self):
     """Official representation of the Redmine resource object"""
     return '<{0}.{1} #{2} "{3}">'.format(
         self.__class__.__module__,
         self.__class__.__name__,
         self.id,
         to_string(self.name)
     )
示例#9
0
 def __repr__(self):
     try:
         return '<{0}.{1} #{2} "{3}">'.format(self.__class__.__module__,
                                              self.__class__.__name__,
                                              self.id,
                                              to_string(self.subject))
     except ResourceAttrError:
         return '<{0}.{1} #{2}>'.format(self.__class__.__module__,
                                        self.__class__.__name__, self.id)
示例#10
0
    def request(self,
                method,
                url,
                headers=None,
                params=None,
                data=None,
                raw_response=False):
        """Makes requests to Redmine and returns result in json format"""
        kwargs = dict(
            self.requests, **{
                'headers': headers or {},
                'params': params or {},
                'data': data or {},
            })

        if 'Content-Type' not in kwargs['headers'] and method in ('post',
                                                                  'put'):
            kwargs['data'] = json.dumps(data)
            kwargs['headers']['Content-Type'] = 'application/json'

        if self.impersonate is not None:
            kwargs['headers']['X-Redmine-Switch-User'] = self.impersonate

        # We would like to be authenticated by API key by default
        if 'key' not in kwargs['params'] and self.key is not None:
            kwargs['params']['key'] = self.key
        else:
            kwargs['auth'] = (self.username, self.password)

        response = getattr(requests, method)(url, **kwargs)

        if response.status_code in (200, 201):
            if raw_response:
                return response
            elif not response.content.strip():
                return True
            else:
                return json_response(response.json)
        elif response.status_code == 401:
            raise AuthError
        elif response.status_code == 404:
            raise ResourceNotFoundError
        elif response.status_code == 409:
            raise ConflictError
        elif response.status_code == 412 and self.impersonate is not None:
            raise ImpersonateError
        elif response.status_code == 413:
            raise RequestEntityTooLargeError
        elif response.status_code == 422:
            errors = json_response(response.json)['errors']
            raise ValidationError(
                to_string(', '.join(e if is_string(e) else ': '.join(e)
                                    for e in errors)))
        elif response.status_code == 500:
            raise ServerError

        raise UnknownError(response.status_code)
示例#11
0
 def __repr__(self):
     try:
         return super(Contact, self).__repr__()
     except ResourceAttrError:
         if not getattr(self, 'last_name', False):
             return '<{0}.{1} #{2} "{3}">'.format(
                 self.__class__.__module__,
                 self.__class__.__name__,
                 self.id,
                 to_string(self.first_name),
             )
         else:
             return '<{0}.{1} #{2} "{3} {4}">'.format(
                 self.__class__.__module__,
                 self.__class__.__name__,
                 self.id,
                 to_string(self.first_name),
                 to_string(self.last_name)
             )
示例#12
0
    def request(self, method, url, headers=None, params=None,
                data=None, raw_response=False):
        """Makes requests to Redmine and returns result in json format"""
        kwargs = dict(self.requests, **{
            'headers': headers or {},
            'params': params or {},
            'data': data or {},
        })

        if 'Content-Type' not in kwargs['headers'] and method in ('post',
                                                                  'put'):
            kwargs['data'] = json.dumps(data)
            kwargs['headers']['Content-Type'] = 'application/json'

        if self.impersonate is not None:
            kwargs['headers']['X-Redmine-Switch-User'] = self.impersonate

        # We would like to be authenticated by API key by default
        if self.key is not None:
            kwargs['params']['key'] = self.key
        if self.username and self.password:
            kwargs['auth'] = (self.username, self.password)
        if self.auth_cookie:
            kwargs['cookies'] = dict(auth_pubtkt=self.auth_cookie)

        response = getattr(requests, method)(url, **kwargs)

        if response.status_code in (200, 201):
            if raw_response:
                return response
            elif not response.content.strip():
                return True
            else:
                return response.json()
        elif response.status_code == 401:
            raise AuthError
        elif response.status_code == 404:
            raise ResourceNotFoundError
        elif response.status_code == 409:
            raise ConflictError
        elif response.status_code == 412 and self.impersonate is not None:
            raise ImpersonateError
        elif response.status_code == 413:
            raise RequestEntityTooLargeError
        elif response.status_code == 422:
            raise ValidationError(to_string(', '.join(
                response.json()['errors'])))
        elif response.status_code == 500:
            raise ServerError

        raise UnknownError(response.status_code)
示例#13
0
 def __repr__(self):
     try:
         return '<{0}.{1} #{2} "{3}">'.format(
             self.__class__.__module__,
             self.__class__.__name__,
             self.id,
             to_string(self.subject)
         )
     except ResourceAttrError:
         return '<{0}.{1} #{2}>'.format(
             self.__class__.__module__,
             self.__class__.__name__,
             self.id
         )
示例#14
0
    def request(self, method, url, headers=None, params=None, data=None):
        """Makes requests to Redmine and returns result in json format"""
        kwargs = dict(self.requests, **{
            'headers': headers or {},
            'params': params or {},
            'data': data or {},
        })

        if not 'Content-Type' in kwargs['headers'] and method in ('post', 'put'):
            kwargs['data'] = json.dumps(data)
            kwargs['headers']['Content-Type'] = 'application/json'

        if self.impersonate is not None:
            kwargs['headers']['X-Redmine-Switch-User'] = self.impersonate

        # We would like to be authenticated by API key by default
        if 'key' not in kwargs['params'] and self.key is not None:
            kwargs['params']['key'] = self.key
        else:
            kwargs['auth'] = (self.username, self.password)
        if 'from_date' in kwargs['params']:
            kwargs['params']['from'] = kwargs['params'].pop('from_date')
        if 'to_date' in kwargs['params']:
            kwargs['params']['to'] = kwargs['params'].pop('to_date')
        response = getattr(requests, method)(url, **kwargs)

        if response.status_code in (200, 201):
            if response.status_code == 200:
                if method == 'put':
                    return response.text
                elif method == 'delete':
                    return True
            return response.json()
        elif response.status_code == 401:
            raise AuthError()
        elif response.status_code == 404:
            raise ResourceNotFoundError
        elif response.status_code == 412 and self.impersonate is not None:
            raise ImpersonateError()
        elif response.status_code == 422:
            raise ValidationError(to_string(', '.join(response.json()['errors'])))
        elif response.status_code == 500:
            raise ServerError()

        return None
示例#15
0
 def __repr__(self):
     """Official representation of the Redmine resource object"""
     return '<{0}.{1} #{2} "{3}">'.format(self.__class__.__module__,
                                          self.__class__.__name__, self.id,
                                          to_string(self.name))
示例#16
0
 def __str__(self):
     try:
         return super(User, self).__str__()
     except ResourceAttrError:
         return '{0} {1}'.format(to_string(self.firstname), to_string(self.lastname))
示例#17
0
 def __str__(self):
     return to_string(self.title)
示例#18
0
 def __str__(self):
     return to_string(self.filename)
示例#19
0
 def __str__(self):
     try:
         return to_string(self.subject)
     except ResourceAttrError:
         return str(self.id)
示例#20
0
 def __str__(self):
     return to_string(self.filename)
示例#21
0
 def __str__(self):
     """Informal representation of the Redmine resource object"""
     return to_string(self.name)
示例#22
0
 def internal_id(self):
     return to_string(self.title)
示例#23
0
 def __str__(self):
     return to_string(self.title)
示例#24
0
 def __str__(self):
     try:
         return to_string(self.filename)
     except ResourceAttrError:
         return str(self.id)
示例#25
0
 def internal_id(self):
     return to_string(self.title)
示例#26
0
 def __str__(self):
     try:
         return super(User, self).__str__()
     except ResourceAttrError:
         return '{0} {1}'.format(to_string(self.firstname),
                                 to_string(self.lastname))
示例#27
0
 def __str__(self):
     """Informal representation of the Redmine resource object"""
     return to_string(self.name)
示例#28
0
 def __str__(self):
     try:
         return to_string(self.subject)
     except ResourceAttrError:
         return str(self.id)
示例#29
0
 def __str__(self):
     try:
         return to_string(self.filename)
     except ResourceAttrError:
         return str(self.id)
示例#30
0
 def __repr__(self):
     return '<{0}.{1} #{2} "{3}">'.format(self.__class__.__module__,
                                          self.__class__.__name__, self.id,
                                          to_string(self.title))