Esempio n. 1
0
    def obj_update(self, bundle, **kwargs):
        if 'tag' not in bundle.data:
            raise BadRequest("tag must be specified")

        try:
            bundle.obj = FixtureDataType.get(kwargs['pk'])
        except ResourceNotFound:
            raise NotFound('Lookup table not found')

        if bundle.obj.domain != kwargs['domain']:
            raise NotFound('Lookup table not found')

        if bundle.obj.tag != bundle.data['tag']:
            raise BadRequest("Lookup table tag cannot be changed")

        save = False
        if 'is_global' in bundle.data:
            save = True
            bundle.obj.is_global = bundle.data['is_global']

        if 'fields' in bundle.data:
            save = True
            bundle.obj.fields = [
                FixtureTypeField.wrap(field) for field in bundle.data['fields']
            ]

        if 'item_attributes' in bundle.data:
            save = True
            bundle.obj.item_attributes = bundle.data['item_attributes']

        if save:
            bundle.obj.save()
        return bundle
 def to_sdf(self, bundle_or_dict, options=None):
     no_struct_error_msg = 'Molecule has no structure records.'
     if isinstance(bundle_or_dict, dict):
         data_dict = bundle_or_dict
         if 'error_message' in data_dict and data_dict[
                 'error_message'] == no_struct_error_msg:
             return no_struct_error_msg
         if 'molecules' in data_dict:
             ret_text = ''
             for molecule_bundle in data_dict['molecules']:
                 ret_text += self.to_sdf(molecule_bundle) + '\n\n$$$$\n'
             return ret_text
         else:
             raise ValueError(
                 'Error, unexpected dictionary received with keys: {0}'.
                 format(data_dict.keys()))
     elif isinstance(bundle_or_dict, Bundle):
         data_bundle = bundle_or_dict
         molecule_structures = data_bundle.data.get('molecule_structures')
         if not molecule_structures:
             raise NotFound(no_struct_error_msg)
         molecule_sdf = molecule_structures.data.get('molfile', None)
         if not molecule_sdf:
             raise NotFound(no_struct_error_msg)
         ret = molecule_sdf.rstrip() + '\n'
         return ret
     else:
         raise ValueError('Error, unexpected type received: {0}'.format(
             type(bundle_or_dict)))
Esempio n. 3
0
    def obj_update(self, bundle, **kwargs):
        if 'data_type_id' not in bundle.data:
            raise BadRequest("data_type_id must be specified")

        try:
            bundle.obj = FixtureDataItem.get(kwargs['pk'])
        except ResourceNotFound:
            raise NotFound('Lookup table item not found')

        if bundle.obj.domain != kwargs['domain']:
            raise NotFound('Lookup table item not found')

        save = False
        if 'fields' in bundle.data:
            save = True
            bundle.obj.fields = {
                field_name: FieldList.wrap(field_list)
                for field_name, field_list in bundle.data['fields'].items()
            }

        if 'item_attributes' in bundle.data:
            save = True
            bundle.obj.item_attributes = bundle.data['item_attributes']

        if save:
            bundle.obj.save()

        return bundle
Esempio n. 4
0
    def obj_delete(self, request=None, **kwargs):
        """
        A ORM-specific implementation of ``obj_delete``.

        Takes optional ``kwargs``, which are used to narrow the query to find
        the instance.
        """
        logger.debug('CampaignDeleteCascade API get called')

        obj = kwargs.pop('_obj', None)
        if not hasattr(obj, 'delete'):
            try:
                obj = self.obj_get(request, **kwargs)
            except:
                error_msg = "A model instance matching the provided arguments could not be found."
                logger.error(error_msg)
                raise NotFound(error_msg)

        #obj.delete()
        campaign_id = obj.id
        try:
            del_campaign = Campaign.objects.get(id=campaign_id)
            phonebook_count = del_campaign.phonebook.all().count()

            if phonebook_count == 0:
                del_campaign.delete()
            else:
                # phonebook_count > 0
                other_campaing_count =\
                Campaign.objects.filter(user=request.user,
                    phonebook__in=del_campaign.phonebook.all())\
                .exclude(id=campaign_id).count()

                if other_campaing_count == 0:
                    # delete phonebooks as well as contacts belong to it

                    # 1) delete all contacts which are belong to phonebook
                    contact_list = Contact.objects\
                    .filter(phonebook__in=del_campaign.phonebook.all())
                    contact_list.delete()

                    # 2) delete phonebook
                    phonebook_list = Phonebook.objects\
                    .filter(id__in=del_campaign.phonebook.all())
                    phonebook_list.delete()

                    # 3) delete campaign
                    del_campaign.delete()
                else:
                    del_campaign.delete()
                logger.debug('CampaignDeleteCascade API : result ok 200')
        except:
            error_msg = "A model matching arguments not found."
            logger.error(error_msg)
            raise NotFound(error_msg)
Esempio n. 5
0
    def obj_get(self, bundle, **kwargs):
        """
        Method copied from parent class so we can handle the case where MultipleObjectsReturned
        happens for Config (deletable) models.
        """
        # Use ignore_bad_filters=True. `obj_get_list` filters based on
        # request.GET, but `obj_get` usually filters based on `detail_uri_name`
        # or data from a related field, so we don't want to raise errors if
        # something doesn't explicitly match a configured filter.
        applicable_filters = self.build_filters(filters=kwargs, ignore_bad_filters=True)
        if self._meta.detail_uri_name in kwargs:
            applicable_filters[self._meta.detail_uri_name] = kwargs[self._meta.detail_uri_name]

        try:
            object_list = self.apply_filters(bundle.request, applicable_filters)
            stringified_kwargs = ', '.join(["%s=%s" % (k, v) for k, v in applicable_filters.items()])

            if len(object_list) <= 0:
                raise self._meta.object_class.DoesNotExist("Couldn't find an instance of '%s' which matched '%s'." % (self._meta.object_class.__name__, stringified_kwargs))
            elif len(object_list) > 1:
                if self._meta.queryset.model._admin.deletable is False:
                    object_list = object_list.order_by('-id')
                else:
                    raise MultipleObjectsReturned("More than '%s' matched '%s'." % (self._meta.object_class.__name__, stringified_kwargs))
            bundle.obj = object_list[0]
            self.authorized_read_detail(object_list, bundle)
            return bundle.obj
        except ValueError:
            raise NotFound("Invalid resource lookup data provided (mismatched type).")
Esempio n. 6
0
    def obj_update(self, bundle, skip_errors=False, **kwargs):
        """
        A ORM-specific implementation of ``obj_update``.
        """
        if not bundle.obj or not self.get_bundle_detail_data(bundle):
            try:
                lookup_kwargs = self.lookup_kwargs_with_identifiers(
                    bundle, kwargs)
            except:
                # if there is trouble hydrating the data, fall back to just
                # using kwargs by itself (usually it only contains a "pk" key
                # and this will work fine.
                lookup_kwargs = kwargs

            try:
                bundle.obj = self.obj_get(bundle, **lookup_kwargs)
                self.post_obj_get(bundle.obj)
            except ObjectDoesNotExist:
                raise NotFound(
                    "A model instance matching the provided arguments could not be found."
                )

        self.authorized_update_detail(self.get_object_list(bundle.request),
                                      bundle)
        bundle = self.full_hydrate(bundle)
        self.post_full_hydrate(bundle, **kwargs)
        return self.save(bundle, skip_errors=skip_errors)
Esempio n. 7
0
 def obj_get(self, request=None, **kwargs):
     # get one object from data source
     pk = int(kwargs['pk'])
     try:
         return data[pk]
     except KeyError:
         raise NotFound("Object not found")
Esempio n. 8
0
 def obj_get(self, bundle, **kwargs):
     test_id = kwargs.get("test_id", None)
     test = self._read_test(test_id)
     if test:
         return test
     else:
         raise NotFound('Test with test_id %s not found' % test_id)
Esempio n. 9
0
 def obj_get(self, bundle, **kwargs):
     id = kwargs.get("id", None)
     exercise = get_exercise_data(bundle.request, id)
     if exercise:
         return Exercise(**exercise)
     else:
         raise NotFound('Exercise with id %s not found' % id)
Esempio n. 10
0
 def obj_get(self, bundle, **kwargs):
     event_id = int(kwargs.get('pk'))
     try:
         event = Event.objects.get(pk=event_id)
     except Event.DoesNotExist:
         raise NotFound("Organizer not found")
     if event.organizer:
         event_organizer = event.organizer
         match_user = MatchQuerySet.between(
             user_id1=bundle.request.user.id, user_id2=event_organizer.id
         )
         if match_user:
             match_user = match_user[0]
             match_user.id = event_id
         else:
             match_user = NonMatchUser(
                 bundle.request.user.id, event_organizer.id
             )
         match_user.event_type = event.event_type
     else:
         fb_event = FacebookEvent.objects.filter(
             facebook_id=event.eid).first()
         obj = A()
         obj.id = event.id
         obj.first_name = fb_event.owner_info.get('name')
         obj.link = 'https://www.facebook.com/{}/'.format(
             fb_event.owner_info.get('id')
         )
         obj.event_type = event.event_type
         return obj
     return match_user
Esempio n. 11
0
    def obj_delete(self, bundle, **kwargs):
        """
        Adapted version of the method in TastyPie's ModelResource
        to take into account the c2dm_notification need
        """
        annObj = bundle.obj

        if not hasattr(annObj, 'delete'):
            try:
                annObj = self.obj_get(bundle=bundle, **kwargs)
            except ObjectDoesNotExist:
                raise NotFound(
                    "A model instance matching the provided arguments could not be found."
                )

        receiver_profile = annObj.user
        registration_id = None
        if receiver_profile:
            registration_id = receiver_profile.c2dm_id

        params = {
            'type': OrderFeature.RESOLVED_REQUEST,
            'order_request': annObj.get_annotation_data()
        }
        self._make_c2dm_notification(registration_id,
                                     None,
                                     bundle,
                                     params=params)
        annObj.delete()
Esempio n. 12
0
 def obj_update(self, bundle, **kwargs):
     self._ensure_toggle_enabled(bundle.request)
     domain = kwargs['domain']
     pk = kwargs['pk']
     try:
         data_source = get_document_or_404(DataSourceConfiguration, domain,
                                           pk)
     except Http404 as e:
         raise NotFound(str(e))
     allowed_update_fields = [
         'display_name',
         'configured_filter',
         'configured_indicators',
     ]
     for key, value in bundle.data.items():
         if key in allowed_update_fields:
             data_source[key] = value
     try:
         data_source.validate()
         data_source.save()
     except BadSpecError as e:
         raise ImmediateHttpResponse(
             add_cors_headers_to_response(
                 HttpResponse(
                     json.dumps({
                         "error":
                         _("Invalid data source! Details: {details}").
                         format(details=str(e))
                     }),
                     content_type="application/json",
                     status=500,
                 )))
     bundle.obj = data_source
     return bundle
Esempio n. 13
0
    def build_filters(self, filters=None):
        if filters is None:
            filters = {}
        orm_filters = super(CommentResource, self).build_filters(
            filters)  # modify super(*,self)
        if 'parent__exact' in orm_filters:
            del orm_filters['parent__exact']
            # delete this field since this is a GFK
#        else:
#            raise ImmediateHttpResponse(response=http.HttpNotFound())

        if "parent" in filters:
            try:
                obj = self.fields['parent'].build_related_resource(
                    filters['parent']).obj
                if not obj.is_active:
                    raise NotFound("Parent object does not exist")
                sqs = obj.comment_set.filter(is_active=True)
                orm_filters["pk__in"] = [i.pk for i in sqs]
            except Comment.DoesNotExist:
                orm_filters["pk__in"] = []
                # return HttpGone()
            except Comment.MultipleObjectsReturned:
                orm_filters["pk__in"] = []
                # return HttpMultipleChoices("More than one resource is found "
                #                            "at this URI.")
                raise ImmediateHttpResponse(response=http.HttpNotFound())
        return orm_filters
Esempio n. 14
0
 def obj_get(self, request=None, **kwargs):
     pk = int(kwargs['pk'])
     try:
         return self._new_obj(
             nc.get_relationship_model(nc.graphdb.manager, pk))
     except KeyError:
         raise NotFound("Object not found")
    def obj_get_no_auth_check(self, request=None, **kwargs):
        """
        Same as the original ``obj_get`` knows when it is being called to get
        a nested resource.

        Does *not* do authorization checks.
        """
        # TODO: merge this and original obj_get and use another argument in
        #       kwargs to know if we should check for auth?
        try:
            object_list = self.get_object_list(request).filter(**kwargs)
            stringified_kwargs = ', '.join(
                ["%s=%s" % (k, v) for k, v in kwargs.items()])

            if len(object_list) <= 0:
                raise self._meta.object_class.DoesNotExist(
                    "Couldn't find an "
                    "instance of '%s' which matched '%s'." %
                    (self._meta.object_class.__name__, stringified_kwargs))
            elif len(object_list) > 1:
                raise MultipleObjectsReturned(
                    "More than '%s' matched '%s'." %
                    (self._meta.object_class.__name__, stringified_kwargs))

            return object_list[0]
        except ValueError:
            raise NotFound("Invalid resource lookup data provided (mismatched "
                           "type).")
    def obj_get(self, request=None, **kwargs):
        """
        Same as the original ``obj_get`` but knows when it is being called to
        get an object from a nested resource uri.

        Performs authorization checks in every case.
        """
        try:
            base_object_list = self.get_object_list(request).filter(
                **self.real_remove_api_resource_names(kwargs))

            object_list = self.apply_proper_authorization_limits(
                request, base_object_list, **kwargs)

            stringified_kwargs = ', '.join(
                ["%s=%s" % (k, v) for k, v in kwargs.items()])

            if len(object_list) <= 0:
                raise self._meta.object_class.DoesNotExist(
                    "Couldn't find an "
                    "instance of '%s' which matched '%s'." %
                    (self._meta.object_class.__name__, stringified_kwargs))
            elif len(object_list) > 1:
                raise MultipleObjectsReturned(
                    "More than '%s' matched '%s'." %
                    (self._meta.object_class.__name__, stringified_kwargs))

            return object_list[0]
        except ValueError:
            raise NotFound("Invalid resource lookup data provided (mismatched "
                           "type).")
Esempio n. 17
0
 def obj_get(self, bundle, **kwargs):
     assessment_item_id = kwargs.get("id", None)
     assessment_item = get_assessment_item_data(bundle.request, assessment_item_id)
     if assessment_item:
         return AssessmentItem(**assessment_item)
     else:
         raise NotFound('AssessmentItem with id %s not found' % assessment_item_id)
Esempio n. 18
0
    def obj_get(self, bundle, **kwargs):
        try:
            wallet = Wallet.objects.get(user=bundle.request.user)
        except Wallet.DoesNotExist:
            raise NotFound("User has no associated wallet")

        return wallet
Esempio n. 19
0
 def obj_get(self, bundle, **kwargs):
     event_id = int(kwargs.get('pk'))
     only_my = bundle.request.GET.get('only_my') == 'true'
     user_id = bundle.request.user.id
     attendees = Membership.objects.filter(
         event_id=event_id, rsvp__in=('yes', 'maybe')
     ).values_list('user_id', flat=True)
     if attendees:
         if only_my:
             my_interests = Interest.objects.filter(
                 user_id=user_id).values_list('interest', flat=True)
             interest_qs = InterestSubject.objects.filter(
                 interest__user__in=attendees,
                 interest__interest__in=my_interests
             )
         else:
             interest_qs = InterestSubject.objects.filter(
                 interest__user__in=attendees
             )
         interests = interest_qs.annotate(
             num_interests=Count('interest')
         ).order_by('-num_interests').values(
             'description', 'num_interests', 'id'
         )
         shared_interests = ResourseObject(
             {
                 'id': event_id,
                 'shared_interests': interests,
                 'total_count': len(interests)
              }
         )
         return shared_interests
     else:
         raise NotFound("Shared interests not found")
Esempio n. 20
0
 def dispatch_classmethod(self, request, method=None, **kwargs):
     method_ref = self.settings.get('classmethods', {}).get(method, None)
     if not method_ref:
         raise NotFound("No such class method: %s" % method)
     method_callable = self._import_function(method_ref)
     ret = method_callable(self, request, method=method, **kwargs)
     return ret
Esempio n. 21
0
    def obj_get(self, **kwargs):

        chembl_id = kwargs.get('molecule__chembl_id')
        standard_inchi_key = kwargs.get('standard_inchi_key')

        if not chembl_id and not standard_inchi_key:
            raise BadRequest("ChEMBL ID or standard InChi Key required.")

        filters = dict((k,v) for k,v in kwargs.items() if k in ('molecule__chembl_id','standard_inchi_key'))
        stringified_kwargs = ', '.join(["%s=%s" % (k, v) for k, v in filters.items()])

        filters.update({
            'molecule__chembl__entity_type':'COMPOUND',
            'molecule__compoundstructures__isnull': False,
            'molecule__compoundproperties__isnull': False,
        })

        try:
            molfile_list = self.get_object_list(None).filter(**filters).values_list('molfile', flat=True)

            if len(molfile_list) <= 0:
                raise ObjectDoesNotExist("Couldn't find an instance of '%s' which matched '%s'." %
                                                           (self._meta.object_class.__name__, stringified_kwargs))
            elif len(molfile_list) > 1:
                raise MultipleObjectsReturned("More than '%s' matched '%s'." %
                                              (self._meta.object_class.__name__, stringified_kwargs))
        except ValueError:
            raise NotFound("Invalid resource lookup data provided (mismatched type).")

        return molfile_list[0]
Esempio n. 22
0
    def put_detail(self, request, **kwargs):
        """Override put_detail so that it doesn't create a new resource when
        One doesn't exists, I don't like this reflex"""
        if VERSION >= (1, 4):
            body = request.body
        else:
            body = request.raw_post_data
        deserialized = self.deserialize(request,
                                        body,
                                        format=request.META.get(
                                            'CONTENT_TYPE',
                                            'application/json'))
        deserialized = self.alter_deserialized_detail_data(
            request, deserialized)
        bundle = self.build_bundle(data=dict_strip_unicode_keys(deserialized),
                                   request=request)

        try:
            updated_bundle = self.obj_update(
                bundle=bundle, **self.remove_api_resource_names(kwargs))

            if not self._meta.always_return_data:
                return http.HttpNoContent()
            else:
                updated_bundle = self.full_dehydrate(updated_bundle)
                updated_bundle = self.alter_detail_data_to_serialize(
                    request, updated_bundle)
                return self.create_response(request,
                                            updated_bundle,
                                            response_class=http.HttpAccepted)
        except (NotFound, MultipleObjectsReturned):
            raise NotFound(
                "A model instance matching the provided arguments could not be found."
            )
Esempio n. 23
0
    def get_via_uri(self, uri, request=None):
        """
        This pulls apart the salient bits of the URI and populates the
        resource via a ``obj_get``.

        Optionally accepts a ``request``.

        If you need custom behavior based on other portions of the URI,
        simply override this method.
        """
        prefix = get_script_prefix()
        chomped_uri = uri

        if prefix and chomped_uri.startswith(prefix):
            chomped_uri = chomped_uri[len(prefix)-1:]

        try:
            view, args, kwargs = resolve(chomped_uri)
            resource_name = kwargs['resource_name']
            resource_class = self.resource_mapping[resource_name]
        except (Resolver404, KeyError):
            raise NotFound("The URL provided '%s' was not a link to a valid resource." % uri)

        parent_resource = resource_class(api_name=self._meta.api_name)
        kwargs = parent_resource.remove_api_resource_names(kwargs)
        return parent_resource.obj_get(**kwargs)
Esempio n. 24
0
 def obj_create(self, bundle, **kwargs):
     try:
         time_left = int(bundle.data['time_left'])
     except KeyError, ValueError:
         # missing mandatory param time_left (in seconds)
         # or not a int
         raise NotFound("No time_left argument")
Esempio n. 25
0
    def dispatch_instancemethod(self, request, method=None, **kwargs):
        method_ref = self.settings.get('methods', {}).get(method, None)
        if not method_ref:
            raise NotFound("No such method: %s" % method)
        method_callable = self._import_function(method_ref)
        id = kwargs.get(self._meta.detail_uri_name)
        if id.isdigit():
            id = int(id)

        basic_bundle = self.build_bundle(request=request)
        try:
            obj = self.cached_obj_get(bundle=basic_bundle,
                                      **self.remove_api_resource_names(kwargs))
        except Exception, ex:
            raise NotFound("No such object %s%s/" %
                           (self.get_list_endpoint(), id))
Esempio n. 26
0
class PilotJobResource(ModelResource):
    """This resource handler jobs requests.

    Allowed Methods:
    ----------------

        GET    /dispatcher/{id}            # Get info about an job
        GET    /dispatcher/schema/         # Get job schema
        GET    /dispatcher/set/{id};{id}/  # Get a list of jobs
        POST   /dispatcher/                # Get a new job
        PATCH  /dispatcher/{id}/           # Partially update a job
    """

    application = fields.ToOneField(ApplicationResource,
                                    'application',
                                    full=True)

    input_objs = fields.ToManyField(DataObjectResource,
                                    'input_objs',
                                    null=True,
                                    full=True)
    output_objs = fields.ToManyField(DataObjectResource,
                                     'output_objs',
                                     null=True,
                                     full=True)
    checkpoint_objs = fields.ToManyField(DataObjectResource,
                                         'checkpoint_objs',
                                         null=True,
                                         full=True)

    class Meta:
        resource_name = 'dispatcher'
        authentication = PilotTokenAuthentication()
        authorization = PilotAuthorization()
        # Remove from query deleted jobs
        queryset = Job.objects.all()
        list_allowed_methods = ['post']
        detail_allowed_methods = ['get', 'patch']
        # Return data on the POST query
        always_return_data = True

    def dehydrate(self, bundle):
        bundle.data['slug'] = slugify(bundle.obj.name)
        return bundle

    def obj_create(self, bundle, **kwargs):
        try:
            time_left = int(bundle.data['time_left'])
        except KeyError, ValueError:
            # missing mandatory param time_left (in seconds)
            # or not a int
            raise NotFound("No time_left argument")

        try:
            bundle.obj = bundle.request.pilot.get_new_job(time_left)
        except StopIteration:
            # no jobs found
            raise NotFound("No jobs found")

        return bundle
Esempio n. 27
0
    def get_via_uri(self, uri, request=None):
        """
        This pulls apart the salient bits of the URI and populates the
        resource via a ``obj_get``.

        Optionally accepts a ``request``.

        If you need custom behavior based on other portions of the URI,
        simply override this method.
        """
        prefix = get_script_prefix()
        chomped_uri = uri

        if prefix and chomped_uri.startswith(prefix):
            chomped_uri = chomped_uri[len(prefix) - 1:]

        try:
            view, args, kwargs = resolve(chomped_uri)
        except Resolver404:
            raise NotFound(
                "The URL provided '%s' was not a link to a valid resource." %
                uri)

        parent_resource = view.func_closure[0].cell_contents.func_closure[
            0].cell_contents
        return parent_resource.obj_get(
            **self.remove_api_resource_names(kwargs))
Esempio n. 28
0
    def resource_from_data(self, fk_resource, data, request=None, related_obj=None, related_name=None):
        """
        Given a dictionary-like structure is provided, a fresh related
        resource is created using that data.
        """
        # Try to hydrate the data provided.
        data = dict_strip_unicode_keys(data)
        fk_bundle = fk_resource.build_bundle(data=data, request=request)

        if related_obj:
            fk_bundle.related_obj = related_obj
            fk_bundle.related_name = related_name

        # We need to check to see if updates are allowed on the FK
        # resource. If not, we'll just return a populated bundle instead
        # of mistakenly updating something that should be read-only.
        if not fk_resource.can_update():
            return fk_resource.full_hydrate(fk_bundle)

        try:
            return fk_resource.obj_update(fk_bundle, skip_errors=True, **data)
        except NotFound:
            try:
                # Attempt lookup by primary key
                lookup_kwargs = dict((k, v) for k, v in data.iteritems() if getattr(fk_resource, k).unique)

                if not lookup_kwargs:
                    raise NotFound()
                return fk_resource.obj_update(fk_bundle, skip_errors=True, **lookup_kwargs)
            except NotFound:
                fk_bundle = fk_resource.full_hydrate(fk_bundle)
                fk_resource.is_valid(fk_bundle, request)
                return fk_bundle
        except MultipleObjectsReturned:
            return fk_resource.full_hydrate(fk_bundle)
Esempio n. 29
0
    def obj_get_list(self, bundle, **kwargs):
        application_id = bundle.request.GET.get('application_id')
        if not application_id:
            raise NotFound('application_id parameter required')

        domain = kwargs['domain']
        couch_user = CouchUser.from_django_user(bundle.request.user)
        if not domain_has_privilege(domain, privileges.ZAPIER_INTEGRATION
                                    ) or not couch_user.is_member_of(domain):
            raise ImmediateHttpResponse(
                HttpForbidden(
                    'You are not allowed to get list of forms for this domain')
            )

        results = []
        application = Application.get(docid=application_id)
        if not application:
            return []
        forms_objects = application.get_forms(bare=False)

        for form_object in forms_objects:
            form = form_object['form']
            module = form_object['module']
            form_name = '{} > {} > {}'.format(application.name,
                                              module.default_name(),
                                              form.default_name())
            results.append(Form(form_xmlns=form.xmlns, form_name=form_name))
        return results
Esempio n. 30
0
 def obj_get(self, request=None, **kwargs):
     # get one object from data source
     pk = int(kwargs['pk'])
     try:
         return consul_session.kv[self._meta.consul_key_root + pk]
     except AttributeError:
         raise NotFound("Object not found")