Get all :class:`rtcclient.models.Attachment` objects of
        this workitem

        :return: a :class:`list` contains all the
            :class:`rtcclient.models.Attachment` objects
        :rtype: list
541045
def getAttachments(self):
        

        attachment_tag = ("rtc_cm:com.ibm.team.workitem.linktype."
                          "attachment.attachment")
        return (self.rtc_obj
                    ._get_paged_resources("Attachment",
                                          workitem_id=self.identifier,
                                          customized_attr=attachment_tag,
                                          page_size="10"))
334446
def get_all(self):
        
        components = []
        
        self._lock.acquire()
        try:
            for reference in self._references:
                components.append(reference.get_component())
        finally:
            self._lock.release()

        return components
896003
def all(self, cache=False):
        
        if cache:
            return [get_object(self.modelb, obj_id, cache=True, use_local=True) for obj_id in self.keys(True)]
        else:
            return self
980848
def all(self):
        
        return self.pages(self.url.page, self.url.max_page)
361949
def attachments
      return @builder.object.send(attribute_name).to_a unless multiple?
      @builder.object.send(attribute_name).sort_by { |a| @builder.object.send(relation_key).index(a.id) }
    end
1088449
def listFieldsFromWorkitem(self, copied_from, keep=False):
        

        return self.templater.listFieldsFromWorkitem(copied_from,
                                                     keep=keep)
1354151
def get_attachment_content(self, request, queryset):
        

        return self.dump_report_content(request, self.get_report_data_rows(request, queryset))
568162
def all(self):
        
        return self._get_json(HTTPMethods.GET,
                              self._cached_datasets_url,
                              self._get_master_key())
353969
def get_attachments(self, include_fields=None, exclude_fields=None):
        
        if "attachments" in self.__dict__:
            return self.attachments

        data = self.bugzilla.get_attachments([self.bug_id], None,
                include_fields, exclude_fields)
        return data["bugs"][str(self.bug_id)]
532607
def get_all(self):
        
        self._lock.acquire()
        try:
            return list(self._cache.values())
        finally:
            self._lock.release()
519907
def get_all_tags(self, item):
        
        all_tags = item.get_templates()

        for template_id in item.templates:
            template = self.templates[template_id]
            all_tags.append(template.name)
            all_tags.extend(self.get_all_tags(template))
        return list(set(all_tags))
135983
def List(self, device_path):
        
        connection = self.protocol_handler.Open(self._handle, destination=b'sync:')
        listing = self.filesync_handler.List(connection, device_path)
        connection.Close()
        return listing
318862
def _get_all(self):
        
        return [self._to_dict(row) for row in models.User.objects.all()]
456383
def get_works(self):
        
        Work = self._session.get_class(surf.ns.EFRBROO['F1_Work'])
        return list(Work.all())
1055123
def attachments(self):
        

        resource = copy(self)
        resource._url_builder = URLBuilder(self._base_url, self._base_path, '/attachment')

        path = self._api_path.strip('/').split('/')

        if path[0] != 'table':
            raise InvalidUsage('The attachment API can only be used with the table API')

        return Attachment(resource, path[1])
433875
def listAttachments(self, oid):
        
        url = self._url + "/%s/attachments" % oid
        params = {
            "f":"json"
        }
        return self._get(url, params,
                            securityHandler=self._securityHandler,
                            proxy_port=self._proxy_port,
                            proxy_url=self._proxy_url)
496918
def get_sorted_attachments(self):
        
        inf = float("inf")
        order = self.get_attachments_order()
        attachments = self.get_attachments()

        def att_cmp(att1, att2):
            _n1 = att1.get('UID')
            _n2 = att2.get('UID')
            _i1 = _n1 in order and order.index(_n1) + 1 or inf
            _i2 = _n2 in order and order.index(_n2) + 1 or inf
            return cmp(_i1, _i2)

        sorted_attachments = sorted(attachments, cmp=att_cmp)
        return sorted_attachments