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'
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
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
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
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'
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'
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()
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
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
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)
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
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
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())
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))
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)
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))
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
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,
}
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
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
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()
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
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']
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
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))
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)
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']}
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
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']
