class EmbeddedListFieldNonFullTestResource(resources.MongoEngineResource): embeddedlist = fields.EmbeddedListField(of='test_project.test_app.api.resources.EmbeddedPersonResource', attribute='embeddedlist', full=False, null=True) class Meta: queryset = documents.EmbeddedListFieldTest.objects.all() allowed_methods = ('get', 'post', 'put', 'patch', 'delete') authorization = tastypie_authorization.Authorization()
class PurchaseOrderResource(InvoiceBaseResource, InvoiceMakableResourceMixin): state = base_fields.CharField( attribute='state', readonly=True, help_text=HELP_TEXT['purchase_order']['state'] ) current_revision = fields.EmbeddedDocumentField( embedded='invoicing.api.resources.PurchaseOrderRevisionResource', attribute='current_revision', help_text=HELP_TEXT['purchase_order']['current_revision'] ) revisions = fields.EmbeddedListField( of='invoicing.api.resources.PurchaseOrderRevisionResource', attribute='revisions', readonly=True, null=True, blank=True, help_text=HELP_TEXT['purchase_order']['revisions'] ) class Meta(InvoiceBaseResource.Meta): resource_name = 'purchase_order' queryset = PurchaseOrder.objects.all() detail_specific_methods = ('make_down_payment_invoice', 'make_invoice', 'mark_as_awaiting_approval') def prepend_urls(self): """Add urls for resources actions.""" urls = super(PurchaseOrderResource, self).prepend_urls() urls.extend(( url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/make_invoice%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('make_invoice'), name='api_quotation_make_invoice'), url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/make_down_payment_invoice%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('make_down_payment_invoice'), name='api_quotation_make_down_payment_invoice'), )) return urls
class SnapshotCurrencyResource(VosaeResource): symbol = base_fields.CharField(attribute='symbol', help_text=HELP_TEXT['currency']['symbol']) rates = fields.EmbeddedListField( of='invoicing.api.resources.ExchangeRateResource', attribute='rates', full=True, null=True, help_text=HELP_TEXT['currency']['rates']) class Meta(VosaeResource.Meta): object_class = SnapshotCurrency excludes = ('id', ) def hydrate(self, bundle): """ If an `id` is present in serialized data (data comes from a Currency and not a SnapshotCurrency), the currency is fetch and exchange rates are updated based on their current rates. """ bundle = super(SnapshotCurrencyResource, self).hydrate(bundle) if 'id' in bundle.data: currency = Currency.objects.get(id=bundle.data.pop('id')) snapshot = currency.get_snapshot() bundle.data['symbol'] = snapshot.symbol bundle.data['rates'] = [] for rate in snapshot.rates: bundle.data['rates'].append({ 'currency_to': rate.currency_to, 'datetime': rate.datetime, 'rate': rate.rate }) return bundle
class BoardResource(resources.MongoEngineResource): posts = fields.EmbeddedListField(of='test_project.test_app.api.resources.EmbeddedPostResource', attribute='posts', full=True, null=True) class Meta: queryset = documents.Board.objects.all() allowed_methods = ('get', 'post', 'put', 'patch', 'delete') authorization = tastypie_authorization.Authorization()
class PipeResource(resources.MongoEngineResource): exporters = fields.EmbeddedListField(of='test_project.test_app.api.resources.EmbeddedExporterListResource', attribute='exporters', full=True, null=True) class Meta: queryset = documents.Pipe.objects.all() resource_name = 'pipes' allowed_methods = ('get', 'post', 'put', 'delete') authorization = tastypie_authorization.Authorization()
class CalendarAclResource(VosaeResource): rules = fields.EmbeddedListField( of='organizer.api.resources.CalendarAclRuleResource', attribute='rules', full=True, help_text=HELP_TEXT['calendar_acl']['rules']) class Meta(VosaeResource.Meta): object_class = CalendarAcl excludes = ('read_list', 'write_list', 'negate_list')
class EmbeddedPostResource(resources.MongoEngineResource): comments = fields.EmbeddedListField( of='test_project.test_app.api.resources.EmbeddedCommentResource', attribute='comments', full=True, null=True) class Meta(object): object_class = documents.EmbeddedPost ordering = ('title', 'comments')
class FunctionResource(resources.MongoEngineResource): args = fields.EmbeddedListField(of='netlambda.resources.ArgResource', attribute='args', full=True, null=True) class Meta: object_class = models.Function allowed_methods = ('get') resource_name = 'func'
class PostResource(resources.MongoEngineResource): comments = fields.EmbeddedListField( of='HelloDjandroid.droid.resources.CommentResource', attribute='comments', full=True, null=True) class Meta: object_class = documents.Post authentication = FacebookOAUTH2Authentication() ordering = ('datetime', )
class PostResource(AuthoredResource): """ Query set is ordered by updated time for following reasons: * those who open web page will get posts in updated time order, * others with already opened page will get updated posts again as they will request them based on ID of current newest post. This is useful if we would like to show on the client side that post has been updated (but we do not necessary have to reorder them). """ updated_time = tastypie_fields.DateTimeField(attribute='updated_time', null=False, readonly=True) comments = fields.EmbeddedListField( of='piplmesh.api.resources.CommentResource', attribute='comments', default=lambda: [], null=True, full=False) attachments = fields.EmbeddedListField( of='piplmesh.api.resources.AttachmentResource', attribute='attachments', default=lambda: [], null=True, full=True) def obj_create(self, bundle, request=None, **kwargs): bundle = super(PostResource, self).obj_create(bundle, request=request, **kwargs) signals.post_created.send(sender=self, post=bundle.obj, request=request or bundle.request, bundle=bundle) return bundle class Meta: queryset = api_models.Post.objects.all().order_by('-updated_time') allowed_methods = ('get', 'post', 'put', 'patch', 'delete') authorization = authorization.PostAuthorization() paginator_class = paginator.Paginator
class ReminderSettingsResource(VosaeResource): use_default = base_fields.BooleanField( attribute='use_default', help_text=HELP_TEXT['reminder']['use_default']) overrides = fields.EmbeddedListField( of='organizer.api.resources.ReminderEntryResource', attribute='overrides', null=True, blank=True, full=True, help_text=HELP_TEXT['reminder']['overrides']) class Meta(VosaeResource.Meta): object_class = ReminderSettings
class CurrencyResource(VosaeResource): symbol = base_fields.CharField(attribute='symbol', help_text=HELP_TEXT['currency']['symbol']) rates = fields.EmbeddedListField( of='invoicing.api.resources.ExchangeRateResource', attribute='rates', readonly=True, full=True, help_text=HELP_TEXT['currency']['rates']) class Meta(VosaeResource.Meta): queryset = Currency.objects.all() authorization = Authorization() list_allowed_methods = ('get', ) detail_allowed_methods = ('get', ) filtering = {"symbol": ('exact', )}
class CreditNoteResource(InvoiceBaseResource): state = base_fields.CharField( attribute='state', readonly=True, help_text=HELP_TEXT['creditnote']['state'] ) current_revision = fields.EmbeddedDocumentField( embedded='invoicing.api.resources.CreditNoteRevisionResource', attribute='current_revision', help_text=HELP_TEXT['creditnote']['current_revision'] ) revisions = fields.EmbeddedListField( of='invoicing.api.resources.CreditNoteRevisionResource', attribute='revisions', readonly=True, null=True, blank=True, help_text=HELP_TEXT['creditnote']['revisions'] ) related_to = fields.ReferenceField( to='invoicing.api.resources.InvoiceResource', attribute='related_to', readonly=True, null=True, help_text=HELP_TEXT['creditnote']['related_to'] ) class Meta(InvoiceBaseResource.Meta): resource_name = 'credit_note' queryset = CreditNote.objects.all() list_allowed_methods = ('get',) detail_allowed_methods = ('get',) detail_specific_methods = ('cancel',) def dehydrate_related_to(self, bundle): from invoicing.api.resources import DownPaymentInvoiceResource, InvoiceResource try: if bundle.obj.related_to.is_down_payment_invoice(): resource = DownPaymentInvoiceResource() elif bundle.obj.related_to.is_invoice(): resource = InvoiceResource() resource_bundle = resource.build_bundle(obj=bundle.obj.related_to, request=bundle.request) return resource.get_resource_uri(resource_bundle) except: return
class QuotationResource(InvoiceBaseResource, InvoiceMakableResourceMixin): state = base_fields.CharField(attribute='state', readonly=True, help_text=HELP_TEXT['quotation']['state']) current_revision = fields.EmbeddedDocumentField( embedded='invoicing.api.resources.QuotationRevisionResource', attribute='current_revision', help_text=HELP_TEXT['quotation']['current_revision']) revisions = fields.EmbeddedListField( of='invoicing.api.resources.QuotationRevisionResource', attribute='revisions', readonly=True, null=True, blank=True, help_text=HELP_TEXT['quotation']['revisions']) class Meta(InvoiceBaseResource.Meta): queryset = Quotation.objects.all() detail_specific_methods = ('make_purchase_order', 'make_down_payment_invoice', 'make_invoice', 'mark_as_awaiting_approval') def prepend_urls(self): """Add urls for resources actions.""" urls = super(QuotationResource, self).prepend_urls() urls.extend(( url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/make_purchase_order%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('make_purchase_order'), name='api_quotation_make_purchase_order'), url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/make_down_payment_invoice%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('make_down_payment_invoice'), name='api_quotation_make_down_payment_invoice'), url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/make_invoice%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('make_invoice'), name='api_quotation_make_invoice'), )) return urls def make_purchase_order(self, request, **kwargs): """Create a purchase order from a quotation""" from invoicing.api.resources.purchase_order import PurchaseOrderResource self.method_check(request, allowed=['put']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs)) except ObjectDoesNotExist: return http.HttpNotFound() purchase_order = obj.make_purchase_order(request.vosae_user) invoicing_signals.post_make_purchase_order.send( obj.__class__, issuer=request.vosae_user, document=obj, new_document=purchase_order) purchase_order_resource = PurchaseOrderResource() purchase_order_resource_bundle = purchase_order_resource.build_bundle( obj=purchase_order, request=request) self.log_throttled_access(request) to_be_serialized = { 'purchase_order_uri': purchase_order_resource.get_resource_uri( purchase_order_resource_bundle) } to_be_serialized = self.alter_list_data_to_serialize( request, to_be_serialized) return self.create_response(request, to_be_serialized)
class IdeaResource(BaseCorsResource, resources.MongoEngineResource): protective_marking = mongo_fields.EmbeddedDocumentField( embedded='ideasapp.api.ProtectiveMarkingResource', attribute='protective_marking', help_text= 'protective marking of this idea, comprising classification, descriptor, codewords and national caveats.', null=True) comments = mongo_fields.EmbeddedListField( of='ideasapp.api.CommentResource', attribute='comments', full=True, null=True) likes = mongo_fields.EmbeddedListField( of='ideasapp.api.LikeResource', attribute='likes', help_text='The user likes recorded for this idea', full=True, null=True) dislikes = mongo_fields.EmbeddedListField( of='ideasapp.api.DislikeResource', attribute='dislikes', help_text='The user dislikes recorded for this idea', full=True, null=True) class Meta: queryset = documents.Idea.objects.all() resource_name = 'idea' # What is permitted at the list level and at the single instance level list_allowed_methods = ['get', 'post', 'delete', 'put'] detailed_allowed_methods = ['get', 'post', 'put', 'delete', 'patch'] # Setup to default print pretty - mainly for debuggin serializer = CustomSerializer() authentication = CustomApiKeyAuthentication() authorization = StatusAuthorization() max_limit = None filtering = { 'created': ['gt', 'gte', 'lt', 'lte'], 'modified': ['gt', 'gte', 'lt', 'lte'], 'like_count': ['gt', 'gte', 'lt', 'lte'], 'dislike_count': ['gt', 'gte', 'lt', 'lte'], 'comment_count': ['gt', 'gte', 'lt', 'lte'], 'vote_score': ['gt', 'gte', 'lt', 'lte'], 'tag_count': ['gt', 'gte', 'lt', 'lte'], 'verified': ['exact'], 'verified_by': ['exact'], 'tags': ['exact', 'in', 'contains'], 'status': ['exact', 'in'], 'user': ['exact'], 'public': ['exact'] } ordering = [ 'title', 'created', 'modified', 'like_count', 'dislike_count', 'comment_count', 'verified', 'status', 'vote_score' ] def serialize(self, request, data, format, options=None): """ Override of resource.serialize so that custom options can be built for the rss serializer """ # Is it an rss feed if 'application/rss+xml' in format: options = {} # Has the feed been filtered? params = request.GET.keys() params.pop(params.index('format')) if params and len(params) > 0: filtered = ' (filtered)' else: filtered = '' # Build a title based on the end point path = request.path.strip('/').split('/') # If it's not a detail view if len(path[-1]) != 24: # If there are tags, then make them available for the title tags = request.GET.get('tags', None) if not tags: tags = request.GET.get('tags__in', None) if tags: filtered = ' (Tags:%s)' % (tags) # Build the title api_end_point = path[-1].lower() options['title'] = settings.END_POINT_DESCRIPTIONS[ api_end_point] + filtered current_site = get_current_site(request) options['link'] = current_site.domain + settings.FRONT_END_URL options['description'] = settings.END_POINT_DESCRIPTIONS[ api_end_point] return super(IdeaResource, self).serialize(request, data, format, options) # ------------------------------------------------------------------------------------------------------------ def obj_create(self, bundle, **kwargs): """ Modifies the content before submission """ # Add in the user bundle.data['user'] = bundle.request.user.username # These ensure that counts are present if ideas are created with tags/likes/dislikes and comments bundle = count_builder(bundle, 'comments', 'comment_count') bundle = count_builder(bundle, 'likes', 'like_count') bundle = count_builder(bundle, 'dislikes', 'dislike_count') bundle = count_builder(bundle, 'tags', 'tag_count') # Sanitize tags before they get submitted try: bundle.data['tags'] = cleanup_tags(bundle.data['tags']) except: pass # Finally build the score bundle.data['vote_score'] = vote_score(bundle.data['like_count'], bundle.data['dislike_count']) return super(IdeaResource, self).obj_create(bundle) # No obj_update here because updates to lists of embedded docs don't trigger that function. # See individual embedded doc lists for update calls # ------------------------------------------------------------------------------------------------------------ def obj_update(self, bundle, **kwargs): """ Updates content when resource is PUT or PATCHed """ # These ensure that counts are present if ideas are created with tags/likes/dislikes and comments bundle = count_builder(bundle, 'tags', 'tag_count') return super(IdeaResource, self).obj_create(bundle) # No obj_update here because updates to lists of embedded docs don't trigger that function. # See individual embedded doc lists for update calls # ------------------------------------------------------------------------------------------------------------ def alter_detail_data_to_serialize(self, request, data): """ Modify the content just before serializing data for a specific item """ # Don't apply the meta object if it's anything but GET if request.method == 'GET': # Add a meta element for the single item response response_data = {'meta': {}, 'objects': [data]} # Add max PM into a newly created meta object pms = get_all_pms(response_data['objects'], subdocs_to_check=['comments'], pm_name='protective_marking') response_data['meta']['max_pm'] = get_max_pm(pms) # Get the modified time for this 1 object response_data['meta']['modified'] = data.data['modified'] # Filter out the meta and objects content based on the data_level response_data = filter_by_data_level(request, response_data) else: response_data = data return response_data # ------------------------------------------------------------------------------------------------------------ def alter_list_data_to_serialize(self, request, data): """ Modify content just before serialized to output """ # Try to get the modified timestamp. Except catches instance where no data try: idea_mod = documents.Idea.objects.order_by( '-modified')[0]['modified'] except: return data # Retrieve all comment modified timestamps (idea, comments) res = documents.Idea._get_collection().aggregate([{ "$project": { "_id": 0, "comments": 1 } }, { "$unwind": "$comments" }, { "$project": { "modified": "$comments.modified" } }, { "$sort": { "modified": -1 } }, { "$limit": 1 }])['result'] # In the event that there are no comments, chuck in an old date to guarantee the idea mod date wins if res: comments_mod = res[0]['modified'] else: comments_mod = datetime.datetime(1970, 1, 1) # Assign the meta-level modified datetime to the most recent comment/idea modified datetime data['meta']['modified'] = max([idea_mod, comments_mod]) # Tag-based filtering if request.method == 'GET' and request.GET.get('tags__in'): data = tag_based_filtering(request, data) # Find the highest protective marking in the dataset pms = get_all_pms(data['objects'], subdocs_to_check=['comments'], pm_name='protective_marking') data['meta']['max_pm'] = get_max_pm(pms) # Filter out the meta and objects content based on the data_level if request.method == 'GET': data = filter_by_data_level(request, data) return data # ------------------------------------------------------------------------------------------------------------ def determine_format(self, request): """ Override the default format, so that format=json is not required """ content_types = { 'json': 'application/json', 'jsonp': 'text/javascript', 'xml': 'application/xml', 'yaml': 'text/yaml', 'html': 'text/html', 'plist': 'application/x-plist', 'csv': 'text/csv', 'rss': 'application/rss+xml', } format = request.GET.get('format', None) if format == None: return 'application/json' else: return content_types[format] # ------------------------------------------------------------------------------------------------------------ ''' def hydrate(self, bundle): """ Need to pass through user all the way through to dehydrate, so enabling that here""" print 'in hydrate', bundle.request.user bundle = super(IdeaResource, self).hydrate(bundle) return bundle ''' # ------------------------------------------------------------------------------------------------------------ def hydrate_modified(self, bundle): """ Updates the idea-level modified timestamp field if the idea is edited. It doesn't handle updates to comments because they are an embedded resource""" if bundle.request.method != 'GET': bundle.data['modified'] = datetime.datetime.utcnow() return bundle # ------------------------------------------------------------------------------------------------------------ def dehydrate(self, bundle): """ Dehydrate - data on its way back to requester """ # User gets passed through because CustomAuth now passes it even for GET requests bundle.data['user_voted'] = get_user_vote_status(bundle) # Class will always have a time_stamp due to default. bundle.data['informal_created'] = calculate_informal_time( bundle.data['created']) bundle.data['informal_modified'] = calculate_informal_time( bundle.data['modified']) # Get the useful protective marking elements bundle = get_top_level_pm_elements(bundle) # Lookup the user's info bundle = get_contributors_info(bundle) # Produce a truncated (by word), html-tag cleaned version if bundle.data.has_key('description'): bundle.data['description_snippet'] = derive_snippet( bundle.data['description']) return bundle
class BaseRevisionResource(VosaeResource): revision = base_fields.CharField( attribute='revision', readonly=True, help_text=HELP_TEXT['base_revision']['revision']) issue_date = base_fields.DateTimeField( attribute='issue_date', readonly=True, help_text=HELP_TEXT['base_revision']['issue_date']) sender = base_fields.CharField( attribute='sender', null=True, blank=True, help_text=HELP_TEXT['base_revision']['sender']) sender_organization = base_fields.CharField( attribute='sender_organization', readonly=True, null=True, help_text=HELP_TEXT['base_revision']['sender_organization']) custom_payment_conditions = base_fields.CharField( attribute='custom_payment_conditions', null=True, blank=True, help_text=HELP_TEXT['base_revision']['custom_payment_conditions']) customer_reference = base_fields.CharField( attribute='customer_reference', null=True, blank=True, help_text=HELP_TEXT['base_revision']['customer_reference']) taxes_application = base_fields.CharField( attribute='taxes_application', help_text=HELP_TEXT['base_revision']['taxes_application']) issuer = fields.ReferenceField( to='core.api.resources.VosaeUserResource', attribute='issuer', readonly=True, null=True, help_text=HELP_TEXT['base_revision']['issuer']) sender_address = fields.EmbeddedDocumentField( embedded='contacts.api.resources.AddressResource', attribute='sender_address', null=True, help_text=HELP_TEXT['base_revision']['sender_address']) contact = fields.ReferenceField( to='contacts.api.resources.ContactResource', attribute='contact', null=True, help_text=HELP_TEXT['base_revision']['contact']) organization = fields.ReferenceField( to='contacts.api.resources.OrganizationResource', attribute='organization', null=True, help_text=HELP_TEXT['base_revision']['organization']) billing_address = fields.EmbeddedDocumentField( embedded='contacts.api.resources.AddressResource', attribute='billing_address', null=True, help_text=HELP_TEXT['base_revision']['billing_address']) delivery_address = fields.EmbeddedDocumentField( embedded='contacts.api.resources.AddressResource', attribute='delivery_address', null=True, help_text=HELP_TEXT['base_revision']['delivery_address']) currency = fields.EmbeddedDocumentField( embedded='invoicing.api.resources.SnapshotCurrencyResource', attribute='currency', help_text=HELP_TEXT['base_revision']['currency']) line_items = fields.EmbeddedListField( of='invoicing.api.resources.InvoiceItemResource', attribute='line_items', full=True, null=True, help_text=HELP_TEXT['base_revision']['line_items']) pdf = ReferencedDictField(of='core.api.resources.VosaeFileResource', attribute='pdf', readonly=True, null=True, help_text=HELP_TEXT['base_revision']['pdf']) class Meta(VosaeResource.Meta): object_class = InvoiceRevision def hydrate(self, bundle): """Set issue data and issuer on POST, extracted from request""" bundle = super(BaseRevisionResource, self).hydrate(bundle) bundle.obj.issuer = bundle.request.vosae_user bundle.obj.issue_date = datetime_now() return bundle
class PluginResource(resources.MongoEngineResource): description = fields.EmbeddedListField( of='lisa.server.web.manageplugins.api.EmbeddedDescriptionResource', attribute='description', full=True, null=True) class Meta: queryset = Plugin.objects.all() allowed_methods = ('get', 'post', 'put', 'delete') authorization = authorization.Authorization() authentication = MultiAuthentication(CustomApiKeyAuthentication()) extra_actions = [ { 'name': 'install', 'summary': 'Install a plugin', 'http_method': 'POST', "errorResponses": [{ "reason": "Plugin was installed correctly.", "code": 201 }, { 'reason': "There was a problem during the install.", 'code': 304 }], 'fields': {} }, { 'name': 'uninstall', 'summary': 'Uninstall a plugin', 'http_method': 'GET', 'fields': {} }, { 'name': 'enable', 'summary': 'Enable a plugin', 'http_method': 'GET', 'fields': {} }, { 'name': 'disable', 'summary': 'Disable a plugin', 'http_method': 'GET', 'fields': {} }, { 'name': 'methodslist', 'summary': 'List the method of all (or the plugin name in parameter) plugins installed', 'http_method': 'GET', 'fields': {} }, ] def prepend_urls(self): return [ url(r"^(?P<resource_name>%s)/(?P<plugin_name>[\w_-]+)/install%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('install'), name="api_plugin_install"), url(r"^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/enable%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('enable'), name="api_plugin_enable"), url(r"^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/disable%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('disable'), name="api_plugin_disable"), url(r"^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/uninstall%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('uninstall'), name="api_plugin_uninstall"), url(r"^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/upgrade%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('upgrade'), name="api_plugin_upgrade"), url(r"^(?P<resource_name>%s)/(?P<plugin_name>[\w_-]+)/methodslist%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('methodslist'), name="api_plugin_methodslist"), url(r"^(?P<resource_name>%s)/methodslist%s" % (self._meta.resource_name, trailing_slash()), self.wrap_view('methodslist'), name="api_plugin_methodslist"), ] def install(self, request, **kwargs): self.method_check(request, allowed=['post', 'get']) self.is_authenticated(request) self.throttle_check(request) plugin_name = kwargs['plugin_name'] status = PluginManagerSingleton.get().installPlugin( plugin_name=plugin_name) self.log_throttled_access(request) LisaFactorySingleton.get().SchedReload() LisaFactorySingleton.get().LisaReload() return self.create_response(request, status, HttpCreated) def enable(self, request, **kwargs): self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) status = PluginManagerSingleton.get().enablePlugin( plugin_pk=kwargs['pk']) self.log_throttled_access(request) LisaFactorySingleton.get().SchedReload() LisaFactorySingleton.get().LisaReload() return self.create_response(request, status, HttpAccepted) def disable(self, request, **kwargs): self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) status = PluginManagerSingleton.get().disablePlugin( plugin_pk=kwargs['pk']) self.log_throttled_access(request) LisaFactorySingleton.get().SchedReload() LisaFactorySingleton.get().LisaReload() return self.create_response(request, status, HttpAccepted) def uninstall(self, request, **kwargs): self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) status = PluginManagerSingleton.get().uninstallPlugin( plugin_pk=kwargs['pk']) self.log_throttled_access(request) LisaFactorySingleton.get().SchedReload() LisaFactorySingleton.get().LisaReload() return self.create_response(request, status, HttpAccepted) def methodslist(self, request, **kwargs): self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) if 'plugin_name' in kwargs: methods = PluginManagerSingleton.get().methodListPlugin( plugin_name=kwargs['plugin_name']) else: methods = PluginManagerSingleton.get().methodListPlugin() self.log_throttled_access(request) return self.create_response(request, methods, HttpAccepted)
class InvoiceResource(InvoiceBaseResource): state = base_fields.CharField(attribute='state', readonly=True, help_text=HELP_TEXT['invoice']['state']) paid = base_fields.DecimalField(attribute='paid', readonly=True, help_text=HELP_TEXT['invoice']['paid']) balance = base_fields.DecimalField( attribute='balance', readonly=True, help_text=HELP_TEXT['invoice']['balance']) has_temporary_reference = base_fields.BooleanField( attribute='has_temporary_reference', readonly=True, help_text=HELP_TEXT['invoice']['has_temporary_reference']) current_revision = fields.EmbeddedDocumentField( embedded='invoicing.api.resources.InvoiceRevisionResource', attribute='current_revision', help_text=HELP_TEXT['invoice']['current_revision']) revisions = fields.EmbeddedListField( of='invoicing.api.resources.InvoiceRevisionResource', attribute='revisions', readonly=True, null=True, blank=True, help_text=HELP_TEXT['invoice']['revisions']) related_to = fields.ReferenceField( to='invoicing.api.resources.QuotationResource', attribute='related_to', readonly=True, null=True, help_text=HELP_TEXT['invoice']['related_to']) payments = fields.ReferencedListField( of='invoicing.api.resources.PaymentResource', attribute='payments', readonly=True, null=True, blank=True, help_text=HELP_TEXT['invoice']['payments']) class Meta(InvoiceBaseResource.Meta): queryset = Invoice.objects.all() detail_specific_methods = ('cancel', 'mark_as_registered') def prepend_urls(self): """Add urls for resources actions.""" urls = super(InvoiceResource, self).prepend_urls() urls.extend( (url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/cancel%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('invoice_cancel'), name='api_invoice_cancel'), )) return urls def invoice_cancel(self, request, **kwargs): """Cancel the invoice and returns the associated credit note.""" from invoicing.api.resources.credit_note import CreditNoteResource self.method_check(request, allowed=['put']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs)) except ObjectDoesNotExist: return http.HttpNotFound() try: credit_note = obj.cancel(request.vosae_user) invoicing_signals.post_cancel_invoice.send( obj.__class__, issuer=request.vosae_user, document=obj, credit_note=credit_note) credit_note_resource = CreditNoteResource() credit_note_resource_bundle = credit_note_resource.build_bundle( obj=credit_note, request=request) except NotCancelableInvoice as e: raise BadRequest(e) self.log_throttled_access(request) to_be_serialized = { 'credit_note_uri': credit_note_resource.get_resource_uri(credit_note_resource_bundle) } to_be_serialized = self.alter_list_data_to_serialize( request, to_be_serialized) return self.create_response(request, to_be_serialized) def dehydrate_related_to(self, bundle): from invoicing.api.resources import QuotationResource, PurchaseOrderResource try: if bundle.obj.related_to.is_quotation(): resource = QuotationResource() elif bundle.obj.related_to.is_purchase_order(): resource = PurchaseOrderResource() resource_bundle = resource.build_bundle(obj=bundle.obj.related_to, request=bundle.request) return resource.get_resource_uri(resource_bundle) except: return
class VosaeEventResource(TenantResource): status = base_fields.CharField( attribute='status', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['status']) created_at = base_fields.DateTimeField( attribute='created_at', readonly=True, help_text=HELP_TEXT['vosae_event']['created_at']) updated_at = base_fields.DateTimeField( attribute='updated_at', readonly=True, help_text=HELP_TEXT['vosae_event']['updated_at']) summary = base_fields.CharField( attribute='summary', help_text=HELP_TEXT['vosae_event']['summary']) description = base_fields.CharField( attribute='description', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['description']) location = base_fields.CharField( attribute='location', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['location']) color = base_fields.CharField(attribute='color', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['color']) start = fields.EmbeddedDocumentField( embedded='organizer.api.resources.EventDateTimeResource', attribute='start', help_text=HELP_TEXT['vosae_event']['start']) end = fields.EmbeddedDocumentField( embedded='organizer.api.resources.EventDateTimeResource', attribute='end', help_text=HELP_TEXT['vosae_event']['end']) recurrence = base_fields.CharField( attribute='recurrence', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['recurrence']) original_start = fields.EmbeddedDocumentField( embedded='organizer.api.resources.EventDateTimeResource', attribute='original_start', readonly=True, help_text=HELP_TEXT['vosae_event']['original_start']) instance_id = base_fields.CharField( attribute='instance_id', readonly=True, null=True, blank=True, help_text=HELP_TEXT['vosae_event']['instance_id']) transparency = base_fields.CharField( attribute='transparency', null=True, blank=True, help_text=HELP_TEXT['vosae_event']['transparency']) calendar = fields.ReferenceField( to='organizer.api.resources.VosaeCalendarResource', attribute='calendar', help_text=HELP_TEXT['vosae_event']['calendar']) creator = fields.ReferenceField( to='core.api.resources.VosaeUserResource', attribute='creator', readonly=True, help_text=HELP_TEXT['vosae_event']['creator']) organizer = fields.ReferenceField( to='core.api.resources.VosaeUserResource', attribute='organizer', readonly=True, help_text=HELP_TEXT['vosae_event']['organizer']) attendees = fields.EmbeddedListField( of='organizer.api.resources.AttendeeResource', attribute='attendees', null=True, blank=True, full=True, help_text=HELP_TEXT['vosae_event']['attendees']) reminders = fields.EmbeddedDocumentField( embedded='organizer.api.resources.ReminderSettingsResource', attribute='reminders', blank=True, help_text=HELP_TEXT['vosae_event']['reminders']) class Meta(TenantResource.Meta): resource_name = 'vosae_event' queryset = VosaeEvent.objects.all() excludes = ('tenant', 'occurrences', 'next_reminder', 'ical_uid', 'ical_data') filtering = { 'start': ('exact', 'gt', 'gte'), 'end': ('exact', 'lt', 'lte'), 'calendar': ('exact') } validation = EventValidation() def prepend_urls(self): """Add urls for resources actions.""" urls = super(VosaeEventResource, self).prepend_urls() urls.extend( (url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/instances%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('event_instances'), name='api_vosae_event_instances'), )) return urls def build_filters(self, filters=None): qs_filters = super(VosaeEventResource, self).build_filters(filters) for filter_name, filter_value in qs_filters.iteritems(): if filter_name.endswith('__exact'): new_name = filter_name[:filter_name.index('__exact')] qs_filters[new_name] = filter_value del qs_filters[filter_name] filter_name = new_name if filter_name in DATERANGE_FILTERS: if isinstance(filter_value, basestring): qs_filters[filter_name] = parse(filter_value) return qs_filters def get_object_list(self, request): """Filters events based on calendar accesses (extracted from request user)""" from organizer.models import VosaeCalendar object_list = super(VosaeEventResource, self).get_object_list(request) principals = [request.vosae_user] + request.vosae_user.groups calendars = VosaeCalendar.objects.filter( acl__read_list__in=principals, acl__negate_list__nin=principals) return object_list.filter(calendar__in=list(calendars)) def apply_filters(self, request, applicable_filters): object_list = super(VosaeEventResource, self).apply_filters(request, applicable_filters) filters = request.GET if 'single_events' in filters and filters['single_events'] in [ 'true', 'True', True ]: start = None end = None for filter_name, filter_value in filters.iteritems(): try: if filter_name.startswith('start'): start = parse(filter_value) elif filter_name.startswith('end'): end = parse(filter_value) except: pass return object_list.with_instances(start, end) return object_list def event_instances(self, request, **kwargs): """List all instances of the event""" self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) objects = self.obj_get_list( bundle, **self.remove_api_resource_names(kwargs)).with_instances() except ObjectDoesNotExist: return http.HttpNotFound() if objects.count() < 2: return http.HttpNotFound() sorted_objects = self.apply_sorting(objects, options=request.GET) first_objects_bundle = self.build_bundle(obj=objects[0], request=request) instances_resource_uri = '%sinstances/' % self.get_resource_uri( first_objects_bundle) paginator = self._meta.paginator_class( request.GET, sorted_objects, resource_uri=instances_resource_uri, limit=self._meta.limit) to_be_serialized = paginator.page() # Dehydrate the bundles in preparation for serialization. bundles = [ self.build_bundle(obj=obj, request=request) for obj in to_be_serialized['objects'] ] to_be_serialized['objects'] = [self.full_dehydrate(b) for b in bundles] to_be_serialized = self.alter_list_data_to_serialize( request, to_be_serialized) return self.create_response(request, to_be_serialized) def full_hydrate(self, bundle): """Set event's creator and organizer""" bundle = super(VosaeEventResource, self).full_hydrate(bundle) bundle.obj.creator = bundle.request.vosae_user # Organizer should be the user owner of the calendar try: organizer = bundle.obj.calendar.acl.get_owner() except: organizer = bundle.request.vosae_user bundle.obj.organizer = organizer return bundle def full_dehydrate(self, bundle, for_list=False): bundle = super(VosaeEventResource, self).full_dehydrate(bundle, for_list=for_list) if not bundle.data['instance_id']: del bundle.data['instance_id'] return bundle def dehydrate(self, bundle): """Dehydrates the appropriate CalendarList which differs according to user (extracted from request)""" from organizer.models import CalendarList from organizer.api.resources import CalendarListResource bundle = super(VosaeEventResource, self).dehydrate(bundle) calendar_list = CalendarList.objects.get( calendar=bundle.obj.calendar, vosae_user=bundle.request.vosae_user) calendar_list_resource = CalendarListResource() calendar_list_resource_bundle = calendar_list_resource.build_bundle( obj=calendar_list, request=bundle.request) bundle.data['calendar_list'] = calendar_list_resource.get_resource_uri( calendar_list_resource_bundle) return bundle
class InvoiceBaseResource(NotificationAwareResourceMixin, TenantResource, VosaeIMEXMixinResource): reference = base_fields.CharField( attribute='reference', readonly=True, help_text=HELP_TEXT['invoicebase']['reference']) total = base_fields.DecimalField( attribute='total', readonly=True, help_text=HELP_TEXT['invoicebase']['total']) amount = base_fields.DecimalField( attribute='amount', readonly=True, help_text=HELP_TEXT['invoicebase']['amount']) account_type = base_fields.CharField( attribute='account_type', help_text=HELP_TEXT['invoicebase']['account_type']) issuer = fields.ReferenceField( to='core.api.resources.VosaeUserResource', attribute='issuer', readonly=True, help_text=HELP_TEXT['invoicebase']['issuer']) organization = fields.ReferenceField( to='contacts.api.resources.OrganizationResource', attribute='organization', readonly=True, null=True, help_text=HELP_TEXT['invoicebase']['organization']) contact = fields.ReferenceField( to='contacts.api.resources.ContactResource', attribute='contact', readonly=True, null=True, help_text=HELP_TEXT['invoicebase']['contact']) history = fields.EmbeddedListField( of='invoicing.api.resources.InvoiceHistoryEntryResource', attribute='history', readonly=True, full=True, null=True, blank=True, help_text=HELP_TEXT['invoicebase']['history']) notes = fields.EmbeddedListField( of='invoicing.api.resources.InvoiceNoteResource', attribute='notes', full=True, null=True, blank=True, help_text=HELP_TEXT['invoicebase']['notes']) group = fields.ReferenceField( to='invoicing.api.resources.InvoiceBaseGroupResource', attribute='group', readonly=True, help_text=HELP_TEXT['invoicebase']['group']) attachments = fields.ReferencedListField( of='core.api.resources.VosaeFileResource', attribute='attachments', null=True, blank=True, help_text=HELP_TEXT['invoicebase']['attachments']) class Meta(TenantResource.Meta): excludes = ('tenant', 'base_type', 'subscribers') filtering = { 'state': ('exact', 'in'), 'contact': ('exact', ), 'organization': ('exact', ), 'account_type': ('exact', ), 'reference': ('contains', ) } available_imex_serializers = (invoicing_imex.PDFSerializer, ) def prepend_urls(self): """Add urls for resources actions.""" urls = super(InvoiceBaseResource, self).prepend_urls() urls.extend(VosaeIMEXMixinResource.prepend_urls(self)) urls.extend(( url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/send/mail%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('send_by_mail'), name='api_invoicebase_send_by_mail'), url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/mark_as_(?P<invoicebase_state>(%s))%s$' % (self._meta.resource_name, '|'.join( [k.lower() for k in MARK_AS_STATES]), trailing_slash()), self.wrap_view('mark_as_state'), name='api_invoicebase_mark_as_state'), url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/generate_pdf%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('generate_pdf'), name='api_invoicebase_generate_pdf'), )) return urls @classmethod def post_save(self, sender, resource, bundle, created, **kwargs): """ Post save API hook handler - Add timeline and notification entries """ # Add timeline and notification entries invoicebase_saved_task.delay(bundle.request.vosae_user, bundle.obj, created) def obj_delete(self, bundle, **kwargs): """Raises a BadRequest if the :class:`~invoicing.models.InvoiceBase` is not in a deletable state""" try: super(InvoiceBaseResource, self).obj_delete(bundle, **kwargs) except NotDeletableInvoice as e: raise BadRequest(e) def do_export(self, request, serializer, export_objects): """Export""" if len(export_objects) is not 1: raise BadRequest('PDF export can only be done on a single item.') return serializer.serialize(export_objects[0]), None def send_by_mail(self, request, **kwargs): """Send an InvoiceBase by mail.""" self.method_check(request, allowed=['post']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs)) except ObjectDoesNotExist: return http.HttpNotFound() try: email_data = self.deserialize(request, request.body, format=request.META.get( 'CONTENT_TYPE', 'application/json')) subject = email_data.get('subject') message = email_data.get('message') to = email_data.get('to') cc = email_data.get('cc', []) bcc = email_data.get('bcc', []) assert isinstance(to, list) and isinstance( cc, list) and isinstance(bcc, list) except: raise BadRequest('Invalid email parameters.') try: obj.send_by_mail(subject, message, to, cc, bcc, request.vosae_user) except: raise BadRequest('Can\'t send email. Verify parameters.') self.log_throttled_access(request) to_be_serialized = {} to_be_serialized = self.alter_list_data_to_serialize( request, to_be_serialized) return self.create_response(request, to_be_serialized) def mark_as_state(self, request, invoicebase_state, **kwargs): """Set state for an InvoiceBase.""" self.method_check(request, allowed=['put']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs)) except ObjectDoesNotExist: return http.HttpNotFound() try: previous_state, new_state = obj.set_state( invoicebase_state.upper(), issuer=request.vosae_user) invoicing_signals.post_client_changed_invoice_state.send( obj.__class__, issuer=request.vosae_user, document=obj, previous_state=previous_state) except (obj.InvalidState, InvalidInvoiceBaseState) as e: raise BadRequest(e) self.log_throttled_access(request) return http.HttpNoContent() # May need to use this with ember (check if always_return_data) # to_be_serialized = '' # to_be_serialized = self.alter_list_data_to_serialize(request, to_be_serialized) # return self.create_response(request, to_be_serialized) def generate_pdf(self, request, **kwargs): """Generate a PDF""" self.method_check(request, allowed=['get']) self.is_authenticated(request) self.throttle_check(request) try: bundle = self.build_bundle(request=request) obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs)) except ObjectDoesNotExist: return http.HttpNotFound() try: language = request.META.get('HTTP_X_REPORT_LANGUAGE', None) if language is not None: assert language in [k[0] for k in settings.LANGUAGES] except: raise BadRequest('Invalid language parameters.') try: pdf = obj.get_pdf(issuer=request.vosae_user, language=language) pdf_resource = VosaeFileResource() pdf_resource_bundle = pdf_resource.build_bundle(obj=pdf, request=request) except Exception, e: print e raise BadRequest('Can\'t generate PDF. Verify parameters.') self.log_throttled_access(request) pdf_resource_bundle = pdf_resource.full_dehydrate(pdf_resource_bundle) pdf_resource_bundle = pdf_resource.alter_detail_data_to_serialize( request, pdf_resource_bundle) return pdf_resource.create_response(request, pdf_resource_bundle)
class CalendarListResource(TenantResource): summary = base_fields.CharField( attribute='calendar__summary', readonly=True, help_text=HELP_TEXT['vosae_calendar']['summary'] ) description = base_fields.CharField( attribute='calendar__description', null=True, readonly=True, help_text=HELP_TEXT['vosae_calendar']['description'] ) location = base_fields.CharField( attribute='calendar__location', null=True, readonly=True, help_text=HELP_TEXT['vosae_calendar']['location'] ) timezone = base_fields.CharField( attribute='calendar__timezone', readonly=True, help_text=HELP_TEXT['vosae_calendar']['timezone'] ) summary_override = base_fields.CharField( attribute='summary_override', null=True, blank=True, help_text=HELP_TEXT['calendar_list']['summary_override'] ) color = base_fields.CharField( attribute='color', blank=True, help_text=HELP_TEXT['calendar_list']['color'] ) selected = base_fields.BooleanField( attribute='selected', blank=True, help_text=HELP_TEXT['calendar_list']['selected'] ) is_own = base_fields.BooleanField( readonly=True, help_text=HELP_TEXT['calendar_list']['is_own'] ) calendar = fields.ReferenceField( to='organizer.api.resources.VosaeCalendarResource', attribute='calendar', help_text=HELP_TEXT['calendar_list']['calendar'] ) reminders = fields.EmbeddedListField( of='organizer.api.resources.ReminderEntryResource', attribute='reminders', null=True, blank=True, full=True, help_text=HELP_TEXT['calendar_list']['reminders'] ) class Meta(TenantResource.Meta): resource_name = 'calendar_list' queryset = CalendarList.objects.all() excludes = ('tenant', 'vosae_user') filtering = { 'calendar': ('exact',) } def get_object_list(self, request): """Filters objects on current user (extracted from request)""" object_list = super(CalendarListResource, self).get_object_list(request) return object_list.filter(vosae_user=request.vosae_user) def hydrate(self, bundle): """Automatically set the user (extracted from request)""" bundle = super(CalendarListResource, self).hydrate(bundle) bundle.obj.vosae_user = bundle.request.vosae_user return bundle def dehydrate_is_own(self, bundle): """`is_own` is processed here, based on the request's user""" try: if bundle.obj.calendar.acl.get_owner() == bundle.request.vosae_user: return True except: pass return False
class FeedbackResource(BaseCorsResource, resources.MongoEngineResource): protective_marking = mongo_fields.EmbeddedDocumentField(embedded='contentapp.api.ProtectiveMarkingResource', attribute='protective_marking', help_text='protective marking of this content', null=True) comments = mongo_fields.EmbeddedListField(of='contentapp.api.FeedbackCommentResource', attribute='comments', full=True, null=True) class Meta: resource_name = 'feedback' queryset = documents.Feedback.objects.all() serializer = CustomSerializer() allowed_methods = ('get', 'post', 'put', 'delete') authentication = CustomApiKeyAuthentication() authorization = PrivilegedAndSubmitterOnly() filtering = {'created' : ['gt', 'gte', 'lt', 'lte'], 'modified' : ['gt', 'gte', 'lt', 'lte'], 'status' : ['exact'], 'type' : ['exact'], 'user' : ['exact']} ordering = ['title', 'created', 'modified', 'status', 'user', 'summary', 'body'] # ------------------------------------------------------------------------------------------------------------ def determine_format(self, request): """ Override the default format, so that format=json is not required """ content_types = { 'json': 'application/json', 'jsonp': 'text/javascript', 'xml': 'application/xml', 'yaml': 'text/yaml', 'html': 'text/html', 'plist': 'application/x-plist', 'csv': 'text/csv', 'rss': 'application/rss+xml', } format = request.GET.get('format', None) if format == None: return 'application/json' else: return content_types[format] # ------------------------------------------------------------------------------------------------------------ def obj_create(self, bundle, **kwargs): """ How to create a feedback object """ # Add the user to the data payload bundle.data['user'] = bundle.request.user.username bundle = count_builder(bundle, 'comments', 'comment_count') return super(FeedbackResource, self).obj_create(bundle) # ------------------------------------------------------------------------------------------------------------ def obj_update(self, bundle, **kwargs): """ Apply the authorization limits when putting""" # We must get the primary key because the mongoengine obj_update function is # expecting one to access the object we want to modify. regExp = re.compile('.*/(?P<doc_id>[a-zA-Z0-9]{24})/') m = re.match(regExp, bundle.request.path).groupdict() if not getattr(bundle.obj, 'pk', None): bundle.obj.pk = m['doc_id'] return super(FeedbackResource, self).obj_update(bundle) # ------------------------------------------------------------------------------------------------------------ def hydrate_modified(self, bundle): """ Updates the idea-level modified timestamp field if the idea is edited. It doesn't handle updates to comments because they are an embedded resource""" if bundle.request.method != 'GET': bundle.data['modified'] = datetime.datetime.utcnow() return bundle # ------------------------------------------------------------------------------------------------------------ def dehydrate(self, bundle): """ Dehydrate - data on its way back to requester """ # Class will always have a time_stamp due to default. bundle.data['informal_created'] = calculate_informal_time(bundle.data['created']) bundle.data['informal_modified'] = calculate_informal_time(bundle.data['modified']) # Get the useful protective marking elements bundle = get_top_level_pm_elements(bundle) # Lookup the user's info bundle = get_contributors_info(bundle) return bundle # ------------------------------------------------------------------------------------------------------------ def alter_detail_data_to_serialize(self, request, data): """ Modify the content just before serializing data for a specific item """ # Don't apply the meta object if it's anything but GET if request.method == 'GET': # Add a meta element for the single item response response_data = {'meta':{},'objects':[data]} # Add max PM into a newly created meta object pms = get_all_pms(response_data['objects'], subdocs_to_check=['comments'], pm_name='protective_marking') response_data['meta']['max_pm'] = get_max_pm(pms) # Get the modified time for this 1 object response_data['meta']['modified'] = data.data['modified'] else: response_data = data return response_data # ------------------------------------------------------------------------------------------------------------ def alter_list_data_to_serialize(self, request, data): """ Modify content just before serialized to output """ # Try to get the modified timestamp. Except catches instance where no data try: idea_mod = documents.Feedback.objects.order_by('-modified')[0]['modified'] data['meta']['modified'] = idea_mod except: return data # Find the highest protective marking in the dataset if request.method == 'GET': pms = get_all_pms(data['objects'], subdocs_to_check=['comments'], pm_name='protective_marking') data['meta']['max_pm'] = get_max_pm(pms) return data #----------------------------------------------------------------------------- def serialize(self, request, data, format, options=None): """ Override of resource.serialize so that custom options can be built for the rss serializer """ # Is it an rss feed if 'application/rss+xml' in format: options = {} # Has the feed been filtered? params = request.GET.keys() params.pop(params.index('format')) if params and len(params) > 0: filtered = ' (filtered)' else: filtered = '' # Build a title based on the end point path = request.path.strip('/').split('/') # If it's not a detail view if len(path[-1]) != 24: # If there are tags, then make them available for the title tags = request.GET.get('tags', None) if not tags: tags = request.GET.get('tags__in', None) if tags: filtered = ' (Tags:%s)'%(tags) # Build the title api_end_point = path[-1].lower() options['title'] = settings.END_POINT_DESCRIPTIONS[api_end_point] current_site = get_current_site(request) options['link'] = current_site.domain + settings.FRONT_END_URL options['description'] = settings.END_POINT_DESCRIPTIONS[api_end_point] return super(FeedbackResource, self).serialize(request, data, format, options)