Esempio n. 1
0
class GroupResource(HqBaseResource, DomainSpecificResourceMixin):
    id = fields.CharField(attribute='get_id', unique=True, readonly=True)
    domain = fields.CharField(attribute='domain')
    name = fields.CharField(attribute='name')

    users = fields.ListField(attribute='get_user_ids')
    path = fields.ListField(attribute='path')

    case_sharing = fields.BooleanField(attribute='case_sharing', default=False)
    reporting = fields.BooleanField(default=True, attribute='reporting')

    metadata = fields.DictField(attribute='metadata', null=True, blank=True)

    def obj_get(self, bundle, **kwargs):
        return get_object_or_not_exist(Group, kwargs['pk'], kwargs['domain'])

    def obj_get_list(self, bundle, domain, **kwargs):
        groups = Group.by_domain(domain)
        return groups

    class Meta(CustomResourceMeta):
        authentication = RequirePermissionAuthentication(
            Permissions.edit_commcare_users)
        object_class = Group
        list_allowed_methods = ['get']
        detail_allowed_methods = ['get']
        resource_name = 'group'
Esempio n. 2
0
class BuyerVerifyPinResource(BuyerEndpointBase):
    valid = fields.BooleanField(attribute='valid', default=False)
    locked = fields.BooleanField(attribute='locked', default=False)

    class Meta(BuyerEndpointBase.Meta):
        resource_name = 'verify_pin'

    def obj_create(self, bundle, request=None, **kwargs):
        buyer = self.get_data(bundle)
        if buyer.pin_confirmed:
            if buyer.locked_out:
                log_cef('Attempted access to locked out account: %s'
                        % buyer.uuid, request, severity=1)
                bundle.obj.locked = True
                return bundle
            bundle.obj.valid = buyer.pin == bundle.data.pop('pin')
            if not bundle.obj.valid:
                locked = buyer.incr_lockout()
                if locked:
                    bundle.obj.locked = True
                    log_cef('Locked out account: %s' % buyer.uuid,
                            request, severity=1)
            if bundle.obj.valid and buyer.pin_failures:
                buyer.clear_lockout()
        else:
            bundle.obj.valid = False
        return bundle
Esempio n. 3
0
class LocationResource(HqBaseResource):
    type = "location"
    uuid = fields.CharField(attribute='location_id',
                            readonly=True,
                            unique=True)
    location_type = fields.CharField(attribute='location_type', readonly=True)
    is_archived = fields.BooleanField(attribute='is_archived', readonly=True)
    can_edit = fields.BooleanField(readonly=True)
    name = fields.CharField(attribute='name', readonly=True, unique=True)

    def obj_get(self, bundle, **kwargs):
        domain = kwargs['domain']
        location_id = kwargs['pk']
        if not user_can_access_location_id(domain, bundle.request.couch_user,
                                           location_id):
            raise BadRequest(LOCATION_ACCESS_DENIED)
        return get_location_or_not_exist(location_id, domain)

    def child_queryset(self, domain, include_inactive, parent):
        return parent.sql_location.child_locations(include_inactive)

    @memoized
    def domain_obj(self, domain_name):
        return Domain.get_by_name(domain_name)

    def obj_get_list(self, bundle, **kwargs):
        domain = kwargs['domain']
        project = getattr(bundle.request, 'project', self.domain_obj(domain))
        parent_id = bundle.request.GET.get('parent_id', None)
        include_inactive = json.loads(
            bundle.request.GET.get('include_inactive', 'false'))
        user = bundle.request.couch_user
        viewable = _user_locations_ids(user, project, only_editable=False)

        if not parent_id:
            if not user.has_permission(domain, 'access_all_locations'):
                raise BadRequest(LOCATION_ACCESS_DENIED)
            locs = SQLLocation.root_locations(domain, include_inactive)
        else:
            if not user_can_access_location_id(kwargs['domain'], user,
                                               parent_id):
                raise BadRequest(LOCATION_ACCESS_DENIED)
            parent = get_location_or_not_exist(parent_id, domain)
            locs = self.child_queryset(domain, include_inactive, parent)
        return [child for child in locs if child.location_id in viewable]

    def dehydrate_can_edit(self, bundle):
        project = getattr(bundle.request, 'project',
                          self.domain_obj(bundle.request.domain))
        editable_ids = _user_locations_ids(bundle.request.couch_user,
                                           project,
                                           only_editable=True)
        return bundle.obj.location_id in editable_ids

    class Meta(CustomResourceMeta):
        authentication = LoginAndDomainAuthentication()
        object_class = SQLLocation
        resource_name = 'location'
        limit = 0
        max_limit = 10000
Esempio n. 4
0
class InvoicingSettingsResource(VosaeResource):
    fy_start_month = base_fields.IntegerField(
        attribute='fy_start_month',
        null=True,
        blank=True,
        help_text=HELP_TEXT['invoicing_settings']['fy_start_month'])
    inv_taxes_application = base_fields.CharField(
        attribute='inv_taxes_application',
        help_text=HELP_TEXT['invoicing_settings']['inv_taxes_application'])
    quotation_validity = base_fields.CharField(
        attribute='quotation_validity',
        help_text=HELP_TEXT['invoicing_settings']['quotation_validity'])
    payment_conditions = base_fields.CharField(
        attribute='payment_conditions',
        help_text=HELP_TEXT['invoicing_settings']['payment_conditions'])
    custom_payment_conditions = base_fields.CharField(
        attribute='custom_payment_conditions',
        null=True,
        blank=True,
        help_text=HELP_TEXT['invoicing_settings']['custom_payment_conditions'])
    late_fee_rate = base_fields.DecimalField(
        attribute='late_fee_rate',
        null=True,
        blank=True,
        help_text=HELP_TEXT['invoicing_settings']['late_fee_rate'])
    accepted_payment_types = base_fields.ListField(
        attribute='accepted_payment_types',
        help_text=HELP_TEXT['invoicing_settings']['accepted_payment_types'])
    down_payment_percent = base_fields.DecimalField(
        attribute='down_payment_percent',
        help_text=HELP_TEXT['invoicing_settings']['down_payment_percent'])
    automatic_reminders = base_fields.BooleanField(
        attribute='automatic_reminders',
        help_text=HELP_TEXT['invoicing_settings']['automatic_reminders'])
    automatic_reminders_text = base_fields.CharField(
        attribute='automatic_reminders_text',
        null=True,
        blank=True,
        help_text=HELP_TEXT['invoicing_settings']['automatic_reminders_text'])
    automatic_reminders_send_copy = base_fields.BooleanField(
        attribute='automatic_reminders_send_copy',
        help_text=HELP_TEXT['invoicing_settings']
        ['automatic_reminders_send_copy'])

    supported_currencies = SupportedCurrenciesListField(
        of='invoicing.api.resources.CurrencyResource',
        attribute='supported_currencies',
        help_text=HELP_TEXT['invoicing_settings']['supported_currencies'])
    default_currency = fields.ReferenceField(
        to='invoicing.api.resources.CurrencyResource',
        attribute='default_currency',
        help_text=HELP_TEXT['invoicing_settings']['default_currency'])
    numbering = fields.EmbeddedDocumentField(
        embedded=
        'vosae_settings.api.resources.invoicing_settings.InvoicingNumberingSettingsResource',
        attribute='numbering',
        help_text=HELP_TEXT['invoicing_settings']['numbering'])

    class Meta:
        object_class = InvoicingSettings
Esempio n. 5
0
class GroupResource(CouchResourceMixin, HqBaseResource,
                    DomainSpecificResourceMixin):
    id = fields.CharField(attribute='get_id', unique=True, readonly=True)
    domain = fields.CharField(attribute='domain')
    name = fields.CharField(attribute='name')

    users = fields.ListField(attribute='get_user_ids')

    case_sharing = fields.BooleanField(attribute='case_sharing', default=False)
    reporting = fields.BooleanField(default=True, attribute='reporting')

    metadata = fields.DictField(attribute='metadata', null=True, blank=True)

    def obj_get(self, bundle, **kwargs):
        return get_object_or_not_exist(Group, kwargs['pk'], kwargs['domain'])

    def obj_get_list(self, bundle, domain, **kwargs):
        if toggles.GROUP_API_USE_COUCH_BACKEND.enabled_for_request(
                bundle.request):
            return GroupQuerySetAdapterCouch(domain)
        else:
            return GroupQuerySetAdapterES(domain)

    class Meta(CustomResourceMeta):
        authentication = RequirePermissionAuthentication(
            Permissions.edit_commcare_users)
        object_class = Group
        list_allowed_methods = ['get']
        detail_allowed_methods = ['get']
        resource_name = 'group'
Esempio n. 6
0
class ServerResource(LdapResourceBase):
    id = fields.CharField(
        attribute='zarafaId', readonly=True, null=True, help_text=id_help_text)
    name = fields.CharField(
        attribute='cn', help_text=u'The name of the server.')
    isAccount = fields.BooleanField(
        attribute='zarafaAccount', null=True, help_text=isAccount_help_text)
    isHidden = fields.BooleanField(
        attribute='zarafaHidden', null=True, help_text=isHidden_help_text)
    ipAddress = fields.CharField(
        attribute='ipHostNumber', help_text=u'The ip address of the server.')
    httpPort = fields.IntegerField(
        attribute='zarafaHttpPort', null=True,
        help_text=u'The HTTP port Zarafa is running under on the server.')
    sslPort = fields.IntegerField(
        attribute='zarafaSslPort', null=True,
        help_text=u'The SSL port Zarafa is running under on the server.')
    filePath = fields.CharField(
        attribute='zarafaFilePath', null=True,
        help_text=u'The Unix socket Zarafa is running under on the server.')
    containsPublic = fields.BooleanField(
        attribute='zarafaContainsPublic', null=True,
        help_text=u'Whether this server contains the public store.')
    proxyUrl = fields.CharField(
        attribute='zarafaProxyURL', null=True, help_text=u'The proxy url for this server.')

    class Meta:
        detail_allowed_methods = DEFAULT_DETAIL_METHODS
        list_allowed_methods = DEFAULT_LIST_METHODS
        object_class = Server
        resource_name = 'servers'
Esempio n. 7
0
class UserSettingsResource(UserResource):
    '''
    Resource representing users.
    '''
    email = fields.CharField()
    biography = fields.CharField()
    email_updates = fields.BooleanField()
    has_current_password = fields.BooleanField()

    big_mugshot = fields.CharField()
    initials_mugshot = fields.CharField()
    gravatar_mugshot = fields.CharField()

    def dehydrate_email(self, bundle):
        return bundle.obj.email

    def dehydrate_biography(self, bundle):
        return bundle.obj.get_profile().biography

    def dehydrate_email_updates(self, bundle):
        return bundle.obj.get_profile().email_updates

    def dehydrate_has_current_password(self, bundle):
        return bundle.obj.password != '!'

    def dehydrate_big_mugshot(self, bundle):
        return bundle.obj.get_profile().get_big_mugshot()

    def dehydrate_initials_mugshot(self, bundle):
        return bundle.obj.get_profile().get_initials_mugshot()

    def dehydrate_gravatar_mugshot(self, bundle):
        return bundle.obj.get_profile().get_gravatar_mugshot()
Esempio n. 8
0
class ProfileResource(ModelResource):
    """Profile Resource."""
    profile_url = fields.CharField()
    avatar_url = fields.CharField()
    is_mentor = fields.BooleanField()
    is_council = fields.BooleanField()
    functional_areas = fields.ToManyField(FunctionalAreasResource,
                                          attribute='functional_areas',
                                          full=True, null=True)
    mentor = fields.ToOneField('remo.profiles.api.RepResource', 
                               attribute='mentor')

    class Meta:
        queryset = UserProfile.objects.filter(registration_complete=True)
        resource_name = 'profile'
        authentication = Authentication()
        authorization = ReadOnlyAuthorization()
        include_resource_uri = False
        include_absolute_url = False
        allowed_methods = ['get']
        fields = ['city', 'region', 'country', 'display_name', 'local_name',
                  'lon', 'lat', 'mozillians_profile_url', 'twitter_account',
                  'facebook_url', 'diaspora_url', 'personal_blog_feed',
                  'irc_name']
        ordering = ['country']
        filtering = {'display_name': ALL,
                     'local_name': ALL,
                     'irc_name': ALL,
                     'country': ALL,
                     'region': ALL,
                     'city': ALL,
                     'functional_areas': ALL_WITH_RELATIONS}

    def dehydrate(self, bundle):
        """Prepare bundle.data for CSV export."""
        if bundle.request.method == 'GET':
            req = bundle.request.GET
            if req.get('format') == 'csv':
                bundle.data.pop('functional_areas', None)
                bundle.data.pop('personal_blog_feed', None)
                bundle.data.pop('profile_url', None)
        return bundle

    def dehydrate_profile_url(self, bundle):
        """Calculate and return full url to Rep profile."""
        return (settings.SITE_URL + reverse('profiles_view_profile',
                                            kwargs={'display_name':
                                                    bundle.obj.display_name}))

    def dehydrate_avatar_url(self, bundle):
        """Calculate and return full avatar of Rep."""
        return get_avatar_url(bundle.obj.user, -1)

    def dehydrate_is_mentor(self, bundle):
        """Calculate and return if user is mentor."""
        return bundle.obj.user.groups.filter(name='Mentor').count() == 1

    def dehydrate_is_council(self, bundle):
        """Calculate and return if user is counselor."""
        return bundle.obj.user.groups.filter(name='Council').count() == 1
Esempio n. 9
0
class LocationResource(HqBaseResource):
    type = "location"
    uuid = fields.CharField(attribute='location_id',
                            readonly=True,
                            unique=True)
    location_type = fields.CharField(attribute='location_type', readonly=True)
    is_archived = fields.BooleanField(attribute='is_archived', readonly=True)
    can_edit = fields.BooleanField(readonly=True)
    name = fields.CharField(attribute='name', readonly=True, unique=True)

    def obj_get(self, bundle, **kwargs):
        domain = kwargs['domain']
        location_id = kwargs['pk']
        if not user_can_access_location_id(domain, bundle.request.couch_user,
                                           location_id):
            raise BadRequest(LOCATION_ACCESS_DENIED)
        return get_location_or_not_exist(location_id, domain)

    def child_queryset(self, domain, include_inactive, parent):
        return parent.sql_location.child_locations(include_inactive)

    @memoized
    def domain_obj(self, domain_name):
        return Domain.get_by_name(domain_name)

    def obj_get_list(self, bundle, **kwargs):
        domain = kwargs['domain']
        project = getattr(bundle.request, 'project', self.domain_obj(domain))
        parent_id = bundle.request.GET.get('parent_id', None)

        try:
            include_inactive = string_to_boolean(
                bundle.request.GET.get('include_inactive', False))
        except ValueError:
            include_inactive = False

        user = bundle.request.couch_user

        if not parent_id:
            if not user.has_permission(domain, 'access_all_locations'):
                raise BadRequest(LOCATION_ACCESS_DENIED)
            return SQLLocation.root_locations(domain, include_inactive)
        else:
            if not user_can_access_location_id(kwargs['domain'], user,
                                               parent_id):
                raise BadRequest(LOCATION_ACCESS_DENIED)
            parent = get_location_or_not_exist(parent_id, domain)
            return self.child_queryset(domain, include_inactive, parent)

    def dehydrate_can_edit(self, bundle):
        # This is a relic of times past; if you can see a location, you can edit it
        return True

    class Meta(CustomResourceMeta):
        authentication = LoginAndDomainAuthentication()
        object_class = SQLLocation
        resource_name = 'location'
        limit = 0
        max_limit = 10000
Esempio n. 10
0
        class UserElectionResource(ResultsElectionResource):
            '''
            ElectionResource with some handy information for the user
            '''
            has_user_voted = fields.BooleanField(default=False)
            has_user_voted_via_a_delegate = fields.BooleanField(default=False)

            def dehydrate_has_user_voted(self, bundle):
                return bundle.obj.has_user_voted(request.user)

            def dehydrate_has_user_voted_via_a_delegate(self, bundle):
                return bundle.obj.has_user_voted_via_a_delegate(request.user)
Esempio n. 11
0
class RadUserResource(ModelResource):
    password = fields.CharField(attribute='password', readonly=True)
    is_active = fields.BooleanField(attribute='is_active')
    is_online = fields.BooleanField(attribute='is_online')
    groups = fields.ListField(attribute='groups')

    class Meta:
        queryset = RadUser.objects.all()
        resource_name = 'raduser'
        fields = ['username', 'password', 'is_active', 'is_online', 'groups']
        filtering = {
            "username": ('exact', ),
            "is_online": ('exact', ),
            "is_active": ('exact', )
        }
        authentication = MultiAuthentication(SessionAuthentication(),
                                             ApiKeyAuthentication())
        authorization = DjangoAuthorization()
        detail_uri_name = 'username'

    def prepend_urls(self):
        return [
            url(r"^(?P<resource_name>%s)/(?P<username>[\w\d_.-]+)/$" %
                self._meta.resource_name,
                self.wrap_view('dispatch_detail'),
                name="api_dispatch_detail"),
        ]

    def obj_create(self, bundle, **kwargs):
        data = bundle.data
        if 'password' not in data:
            data['password'] = gen_random_password(6)

        raduser = RadUser.objects.create(username=data['username'],
                                         password=data['password'])
        update = dict([(k, data[k]) for k in data
                       if k not in ('username', 'password')])
        raduser.update(**update)

        return raduser

    def obj_update(self, bundle, **kwargs):
        data = bundle.data
        username = kwargs.get('username')
        raduser, created = RadUser.objects.get_or_create(username=username)
        update = dict([(k, data[k]) for k in data if k not in ('username', )])
        raduser.update(**update)
        bundle.obj = raduser

        return raduser
Esempio n. 12
0
class AttendeeResource(VosaeResource):
    email = base_fields.CharField(
        attribute='email',
        help_text=HELP_TEXT['attendee']['email']
    )
    display_name = base_fields.CharField(
        attribute='display_name',
        null=True,
        blank=True,
        help_text=HELP_TEXT['attendee']['display_name']
    )
    organizer = base_fields.BooleanField(
        attribute='organizer',
        blank=True,
        help_text=HELP_TEXT['attendee']['organizer']
    )
    optional = base_fields.BooleanField(
        attribute='optional',
        blank=True,
        help_text=HELP_TEXT['attendee']['optional']
    )
    response_status = base_fields.CharField(
        attribute='response_status',
        blank=True,
        help_text=HELP_TEXT['attendee']['response_status']
    )
    comment = base_fields.CharField(
        attribute='comment',
        null=True,
        blank=True,
        help_text=HELP_TEXT['attendee']['comment']
    )
    photo_uri = base_fields.CharField(
        attribute='vosae_user__photo_uri',
        readonly=True,
        null=True,
        help_text=HELP_TEXT['attendee']['photo_uri']
    )

    vosae_user = fields.ReferenceField(
        to='core.api.resources.VosaeUserResource',
        attribute='vosae_user',
        null=True,
        blank=True,
        help_text=HELP_TEXT['attendee']['vosae_user']
    )

    class Meta(VosaeResource.Meta):
        object_class = Attendee
Esempio n. 13
0
class CommCareCaseResource(JsonResource, DomainSpecificResourceMixin):
    type = "case"
    id = fields.CharField(attribute='case_id', readonly=True, unique=True)
    case_id = id
    user_id = fields.CharField(attribute='user_id')
    date_modified = fields.CharField(attribute='date_modified',
                                     default="1900-01-01")
    closed = fields.BooleanField(attribute='closed')
    date_closed = fields.CharField(attribute='date_closed', null=True)

    server_date_modified = fields.CharField(attribute='server_date_modified',
                                            default="1900-01-01")
    server_date_opened = fields.CharField(attribute='server_date_opened',
                                          null=True)

    xform_ids = fields.ListField(attribute='xform_ids')

    properties = fields.DictField('properties')

    indices = fields.DictField('indices')

    def obj_get(self, bundle, **kwargs):
        case = get_object_or_not_exist(CommCareCase, kwargs['pk'],
                                       kwargs['domain'])
        return dict_object(case.get_json())
Esempio n. 14
0
class WebUserResource(UserResource):
    role = fields.CharField()
    is_admin = fields.BooleanField()
    permissions = fields.DictField()

    def dehydrate_role(self, bundle):
        return bundle.obj.get_role(bundle.request.domain).name

    def dehydrate_permissions(self, bundle):
        return bundle.obj.get_role(bundle.request.domain).permissions._doc

    def dehydrate_is_admin(self, bundle):
        return bundle.obj.is_domain_admin(bundle.request.domain)

    class Meta(UserResource.Meta):
        object_class = WebUser
        resource_name = 'web-user'

    def obj_get_list(self, bundle, **kwargs):
        domain = kwargs['domain']
        username = bundle.request.GET.get('username')
        if username:
            user = WebUser.get_by_username(username)
            return [user] if user else []
        return list(WebUser.by_domain(domain))
Esempio n. 15
0
class NotificationBaseResource(TenantResource):
    sent_at = base_fields.DateTimeField(
        attribute='sent_at',
        readonly=True,
        help_text=HELP_TEXT['notification_base']['sent_at']
    )
    read = base_fields.BooleanField(
        attribute='read',
        readonly=True,
        help_text=HELP_TEXT['notification_base']['read']
    )

    issuer = fields.ReferenceField(
        to='core.api.resources.VosaeUserResource',
        attribute='issuer',
        readonly=True,
        null=True,
        help_text=HELP_TEXT['notification_base']['issuer']
    )

    class Meta(TenantResource.Meta):
        object_class = Notification
        excludes = ('tenant', 'recipient')
        list_allowed_methods = ('get',)
        detail_allowed_methods = ('get',)

    def get_object_list(self, request):
        """Filters the notifications list on the recipient (extracted from request)"""
        return super(NotificationBaseResource, self).get_object_list(request).filter(recipient=request.vosae_user)
Esempio n. 16
0
class WebUserResource(UserResource):
    role = fields.CharField()
    is_admin = fields.BooleanField()
    permissions = fields.DictField()

    def dehydrate_role(self, bundle):
        role = bundle.obj.get_role(bundle.request.domain)
        return role.name if role else ''

    def dehydrate_permissions(self, bundle):
        role = bundle.obj.get_role(bundle.request.domain)
        return role.permissions.to_json() if role else {}

    def dehydrate_is_admin(self, bundle):
        return bundle.obj.is_domain_admin(bundle.request.domain)

    class Meta(UserResource.Meta):
        authentication = RequirePermissionAuthentication(
            Permissions.edit_web_users)
        object_class = WebUser
        resource_name = 'web-user'

    def obj_get_list(self, bundle, **kwargs):
        domain = kwargs['domain']
        username = bundle.request.GET.get('web_username')
        if username:
            user = WebUser.get_by_username(username)
            if not (user and user.is_member_of(domain)):
                user = None
            return [user] if user else []
        return list(WebUser.by_domain(domain))
Esempio n. 17
0
class ResourceResource(BaseModelResource):
    name = fields.CharField('host')
    icon = fields.CharField('icon')
    total_count = fields.BooleanField()

    class Meta(BaseModelResource.Meta):
        abstract = False
        queryset = Resource.objects.all()
        resource_name = 'resource'
        excludes = ('total_count', )
        filtering = {
            'total_count': ['exact'],
            'id': ['exact', 'in'],
            'name': ['exact', 'iregex', 'regex', 'in'],
        }
        ordering = [
            'id',
            'name',
        ]

    def dehydrate(self, *args, **kwargs):
        bundle = super().dehydrate(*args, **kwargs)
        bundle.data[
            'icon'] = '/imagefit/static_resize/64x64/' + bundle.data['icon']
        return bundle
Esempio n. 18
0
class SellerPaypalResource(ModelResource):
    seller = fields.ToOneField('lib.sellers.resources.SellerResource',
                               'seller')
    secret = fields.BooleanField(readonly=True, attribute='secret_exists')
    token = fields.BooleanField(readonly=True, attribute='token_exists')

    class Meta(ModelResource.Meta):
        queryset = SellerPaypal.objects.filter()
        excludes = ['id']
        list_allowed_methods = ['post']
        allowed_methods = ['get', 'put', 'patch']
        resource_name = 'seller'
        validation = FormValidation(form_class=SellerPaypalValidation)
        filtering = {
            'seller': ALL_WITH_RELATIONS,
        }
Esempio n. 19
0
class ReportSettingsResource(VosaeResource):
    font_name = base_fields.CharField(
        attribute='font_name',
        blank=True,
        help_text=HELP_TEXT['report_settings']['font_name'])
    font_size = base_fields.IntegerField(
        attribute='font_size',
        blank=True,
        help_text=HELP_TEXT['report_settings']['font_size'])
    font_color = base_fields.CharField(
        attribute='font_color',
        blank=True,
        help_text=HELP_TEXT['report_settings']['font_color'])
    base_color = base_fields.CharField(
        attribute='base_color',
        blank=True,
        help_text=HELP_TEXT['report_settings']['base_color'])
    force_bw = base_fields.BooleanField(
        attribute='force_bw',
        blank=True,
        help_text=HELP_TEXT['report_settings']['force_bw'])
    language = base_fields.CharField(
        attribute='language',
        blank=True,
        help_text=HELP_TEXT['report_settings']['language'])

    class Meta(VosaeResource.Meta):
        object_class = ReportSettings
Esempio n. 20
0
class ResourceFileResource(ModelResource):

    file_extension = fields.CharField(readonly=True)
    is_embeddable = fields.BooleanField(readonly=True)

    class Meta:
        queryset = ResourceFile.objects.all()
        resource_name = 'resourcefile'
        allowed_methods = ['get', 'delete']
        excludes = ['create_date', 'update_date', 'image', 'file_full_text']
        authentication = ApiKeyAuthentication()
        authorization = ORBAuthorization()
        serializer = PrettyJSONSerializer()
        always_return_data = True
        include_resource_uri = True

    def dehydrate_is_embeddable(self, bundle):
        """Returns whether this file is considered embeddable or not"""
        return bundle.obj.is_embeddable

    def dehydrate_file_extension(self, bundle):
        """Returns the parsed file extension"""
        return bundle.obj.file_extension

    def dehydrate_file(self, bundle):
        if bundle.obj.file:
            return bundle.request.build_absolute_uri(settings.MEDIA_URL +
                                                     bundle.obj.file.name)
        else:
            return None
Esempio n. 21
0
            class CastVoteResource(GenericResource):
                is_changed = fields.BooleanField()
                question = fields.DictField()
                user_info = fields.DictField()

                class Meta:
                    queryset = CastVote.objects.all()
                    list_allowed_methods = []
                    detail_allowed_methods = ['get']
                    fields = [
                        'is_public', 'is_direct', 'id', 'resource_uri',
                        'reason'
                    ]

                def dehydrate_is_changed(self, bundle):
                    return bundle.obj.is_changed_vote()

                def dehydrate_question(self, bundle):
                    if bundle.obj.is_direct and bundle.obj.is_public and bundle.obj.is_plaintext(
                    ):
                        return bundle.obj.get_first_pretty_answer()
                    else:
                        return dict()

                def dehydrate_user_info(self, bundle):
                    return dict(short_description=bundle.obj.voter.get_profile(
                    ).get_short_description(),
                                num_agoras=bundle.obj.voter.agoras.count(),
                                num_votes=bundle.obj.voter.get_profile().
                                count_direct_votes())
class BooleanMapTestResource(resources.MongoEngineResource):
    is_published_defined = tastypie_fields.BooleanField(default=False, null=False, attribute='is_published_defined')

    class Meta:
        queryset = documents.BooleanMapTest.objects.all()
        allowed_methods = ('get', 'post', 'put', 'patch', 'delete')
        authorization = tastypie_authorization.Authorization()
Esempio n. 23
0
class GuestResource(BaseModelResource):

    event = fields.ForeignKey('api.private_v1.resources.EventResource',
                              'event')

    # DEPRECATED
    # old "invited" flag (2014-07-16)
    invited = fields.BooleanField(attribute='is_invited', default=False)

    class Meta(BaseMeta):  # set Meta to the public API Meta
        queryset = Guest.objects.all()
        fields = [
            'name',
            'email',
            'is_invited',
            # DEPRECATED
            'invited',
        ]
        list_allowed_methods = ['get', 'post']
        detail_allowed_methods = ['get', 'post', 'put', 'delete', 'patch']
        filtering = {
            'event': ['exact'],
            'email': ALL,
            'is_invited': ALL,
            # DEPRECATED
            'invited': ALL,
        }

    def dehydrate(self, bundle):

        ### DEPRECATED/COMPATIBILITY ###
        bundle.data['type'] = '/private_v1/type/6/'

        return bundle
Esempio n. 24
0
class JurisdictionResource(DeprecatedModelResourceWithFieldsFilter):
    has_scraper = fields.BooleanField(
        attribute='has_opinion_scraper',
        help_text='Whether the jurisdiction has a scraper that obtains '
        'opinions automatically.')

    class Meta:
        authentication = authentication.MultiAuthentication(
            BasicAuthenticationWithUser(realm="courtlistener.com"),
            authentication.SessionAuthentication())
        throttle = PerUserCacheThrottle(throttle_at=1000)
        resource_name = 'jurisdiction'
        queryset = Court.objects.exclude(jurisdiction='T')
        max_limit = 1000
        allowed_methods = ['get']
        filtering = {
            'id': ('exact', ),
            'date_modified': good_time_filters,
            'in_use': ALL,
            'has_scraper': ALL,
            'position': numerical_filters,
            'short_name': ALL,
            'full_name': ALL,
            'url': ALL,
            'start_date': good_date_filters,
            'end_date': good_date_filters,
            'jurisdictions': ALL,
        }
        ordering = [
            'date_modified', 'start_date', 'end_date', 'position',
            'jurisdiction'
        ]
        excludes = ['has_opinion_scraper', 'has_oral_argument_scraper']
Esempio n. 25
0
class RegistrationResource(ModelResource):

    race_class = fields.ToOneField('garage.api.RaceClassResource',
                                   'race_class',
                                   full=True)
    pax_class = fields.ToOneField('garage.api.RaceClassResource',
                                  'pax_class',
                                  full=True,
                                  null=True,
                                  blank=True)
    bump_class = fields.ToOneField('garage.api.RaceClassResource',
                                   'bump_class',
                                   full=True,
                                   null=True,
                                   blank=True)
    first_name = fields.CharField(attribute='first_name', readonly=True)
    last_name = fields.CharField(attribute='last_name', readonly=True)
    car_name = fields.CharField(attribute='car_name', readonly=True)
    anon = fields.BooleanField(readonly=False)

    results = fields.ToManyField('garage.api.ResultResource',
                                 'results',
                                 readonly=True,
                                 full=True)

    class Meta:
        authentication = SessionAuthentication()
        authorization = ClubAdminAuthorization()
        queryset = Registration.objects.all().select_related()
        excludes = ['_anon_l_name', '_anon_f_name', '_anon_car']

    def dehydrate(self, bundle):
        bundle.data['anon'] = (bundle.obj.user_profile is None)
        return bundle
Esempio n. 26
0
class AuthenticatedLinkResource(BaseLinkResource):
    notes = fields.CharField(attribute='notes', blank=True)
    created_by = fields.ForeignKey(LinkUserResource,
                                   'created_by',
                                   full=True,
                                   null=True,
                                   blank=True,
                                   readonly=True)

    is_private = fields.BooleanField(attribute='is_private')
    private_reason = fields.CharField(attribute='private_reason',
                                      blank=True,
                                      null=True)
    archive_timestamp = fields.DateTimeField(attribute='archive_timestamp',
                                             readonly=True)
    organization = fields.ForeignKey(OrganizationResource,
                                     'organization',
                                     full=True,
                                     blank=True,
                                     null=True,
                                     readonly=True)

    class Meta(BaseLinkResource.Meta):
        authorization = AuthenticatedLinkAuthorization()
        queryset = BaseLinkResource.Meta.queryset.select_related(
            'created_by', )
        allowed_update_fields = [
            'title', 'notes', 'is_private', 'private_reason', 'folder', 'file'
        ]

    def get_search_filters(self, search_query):
        return (super(AuthenticatedLinkResource,
                      self).get_search_filters(search_query)
                | Q(notes__icontains=search_query))
Esempio n. 27
0
class BuyerResource(ModelResource):
    paypal = fields.ToOneField('lib.buyers.resources.BuyerPaypalResource',
                               'paypal', blank=True, full=True,
                               null=True, readonly=True)
    pin_failures = fields.IntegerField(attribute='pin_failures', readonly=True)
    pin_is_locked_out = fields.BooleanField(attribute='locked_out',
                                            blank=True, null=True,
                                            readonly=True)

    class Meta(ModelResource.Meta):
        queryset = Buyer.objects.filter()
        fields = ['uuid', 'pin', 'active', 'new_pin', 'needs_pin_reset',
                  'pin_confirmed', 'pin_was_locked_out']
        list_allowed_methods = ['get', 'post', 'put']
        allowed_methods = ['get', 'patch', 'put']
        resource_name = 'buyer'
        validation = BuyerFormValidation(form_class=BuyerForm)
        filtering = {
            'uuid': 'exact',
            'active': 'exact',
        }

    def dehydrate_pin(self, bundle):
        return bool(bundle.obj.pin)

    def dehydrate_new_pin(self, bundle):
        return bool(bundle.obj.new_pin)
Esempio n. 28
0
class CaptureResource(DefaultResource):
    role = fields.CharField(attribute='role', null=True, blank=True)
    status = fields.CharField(attribute='status', null=True, blank=True)
    url = fields.CharField(attribute='url', null=True, blank=True)
    record_type = fields.CharField(attribute='record_type',
                                   null=True,
                                   blank=True)
    content_type = fields.CharField(attribute='content_type',
                                    null=True,
                                    blank=True)
    user_upload = fields.BooleanField(attribute='user_upload',
                                      null=True,
                                      blank=True)

    # calculated fields
    playback_url = fields.CharField(attribute='playback_url',
                                    null=True,
                                    blank=True)

    class Meta(DefaultResource.Meta):
        resource_name = 'captures'
        queryset = Capture.objects.all()
        filtering = {'archive': ['exact']}

    def dehydrate_archive(self, bundle):
        return {'guid': bundle.data['archive']}
Esempio n. 29
0
class BspLabelsAPI(Resource):
    """
    Tastypie resource to get a BSP type labels.

    **Type**: GET

    **Points**:

        - Param ``type`` specifies BSP type
        - Param ``include_common`` (0,1) can be used include or exclude common bsp labels. By default, these are included.

    **Authors**: Gagandeep Singh
    """
    label = fields.CharField(attribute='label',
                             help_text='Label/identified iof the attribute.')
    description = fields.CharField(attribute='description',
                                   null=True,
                                   help_text='Description of the attribute.')
    dtype = fields.CharField(attribute='dtype',
                             help_text='Data type of the attribute')
    required = fields.BooleanField(
        attribute='required',
        help_text='Whether this field is mandatory or not.')
    path = fields.CharField(attribute='path',
                            help_text='Dot (.) separated path in the model.')

    class Meta:
        object_class = GenericTastypieObject
        resource_name = 'bsp_type_labels'
        allowed_methods = ('get', )
        limit = 0
        max_limit = None
        include_resource_uri = False
        authentication = SessionAuthentication()

    def obj_get_list(self, bundle, **kwargs):
        bsp_type_code = bundle.request.GET['type']
        include_common = int(bundle.request.GET.get('include_common', 1))

        org_uid = bundle.request.GET.get('c', None)
        if org_uid:
            org = Organization.objects.get(org_uid=org_uid)
        else:
            org = None

        data = []
        for attr in get_bsp_labels(bsp_type_code, org):
            if (attr['is_common'] == True
                    and include_common) or attr['is_common'] == False:
                obj = GenericTastypieObject()
                obj.label = attr['label']
                obj.description = attr['description']
                obj.dtype = attr['dtype']
                obj.required = attr['required']
                obj.path = attr['path']

                data.append(obj)

        return data
Esempio n. 30
0
class CommCareCaseResource(HqBaseResource, DomainSpecificResourceMixin):
    type = "case"
    id = fields.CharField(attribute='case_id', readonly=True, unique=True)
    case_id = id
    user_id = fields.CharField(attribute='user_id', null=True)
    date_modified = fields.CharField(attribute='date_modified',
                                     default="1900-01-01")
    closed = fields.BooleanField(attribute='closed')
    date_closed = fields.CharField(attribute='closed_on', null=True)

    server_date_modified = fields.CharField(attribute='server_date_modified',
                                            default="1900-01-01")
    server_date_opened = fields.CharField(attribute='server_date_opened',
                                          null=True)

    xform_ids = fields.ListField(attribute='xform_ids')

    properties = fields.DictField()

    def dehydrate_properties(self, bundle):
        return bundle.obj.get_properties_in_api_format()

    indices = fields.DictField()

    def dehydrate_indices(self, bundle):
        return bundle.obj.get_index_map()

    def detail_uri_kwargs(self, bundle_or_obj):
        return {'pk': get_obj(bundle_or_obj).case_id}

    def case_es(self, domain):
        # Note that CaseESView is used only as an ES client, for `run_query` against the proper index
        return MOCK_CASE_ES_VIEW or CaseESView(domain)

    def obj_get(self, bundle, **kwargs):
        case_id = kwargs['pk']
        try:
            return CommCareCase.objects.get_case(case_id, kwargs['domain'])
        except CaseNotFound:
            raise object_does_not_exist("CommCareCase", case_id)

    def obj_get_list(self, bundle, domain, **kwargs):
        try:
            es_query = es_query_from_get_params(bundle.request.GET,
                                                domain,
                                                doc_type='case')
        except Http400 as e:
            raise BadRequest(str(e))

        return ElasticAPIQuerySet(
            payload=es_query, model=ESCase,
            es_client=self.case_es(domain)).order_by('server_modified_on')

    class Meta(CustomResourceMeta):
        authentication = RequirePermissionAuthentication(Permissions.edit_data)
        object_class = ESCase
        resource_name = 'case'
        list_allowed_methods = ['get']
        detail_allowed_methods = ['get']