def test_dehydrate(self):
note = Note.objects.get(pk=1)
bundle = Bundle(obj=note)
field_1 = FloatField(default=20)
self.assertEqual(field_1.dehydrate(bundle), 20.0)
field_2 = IntegerField(default=18.5)
self.assertEqual(field_2.dehydrate(bundle), 18)
class BrandResource(ProtectedModelResource):
class Meta:
resource_name = 'brand'
authorization = Auth('owner')
allowed_methods = ('get', 'post', 'get', 'put', 'delete')
always_return_data = True
filtering = {
'is_deleted': (ALL),
'appnexus_access_status': (
'exact',
'startswith',
),
}
validation = BrandValidation()
queryset = Brand.objects.all()
fields = ('brand_id', 'check_access_status', 'page_name')
id = IntegerField('id', readonly=True)
facebook_page_id = CharField('thirdparty_page_id')
appnexus_access_status = CharField('appnexus_access_status', readonly=True)
owner = CharField('owner', readonly=True)
# Get only not deleted Brands
def get_object_list(self, request):
return super(BrandResource,
self).get_object_list(request).filter(is_deleted=False)
def raise_appnexus_error(self, request, error_msg):
""
from tastypie.exceptions import ImmediateHttpResponse
errors = {'brand': {'error': error_msg}}
raise ImmediateHttpResponse(
response=self.error_response(request, errors))
def hydrate(self, bundle):
bundle.obj.owner = bundle.request.user.account
# Send for confirmation
if bundle.data['check_access_status'] is True:
bundle.obj.appnexus_access_status = ACCESS_STATUS['pending']
return bundle
# Before save call AppNexus API to check brand id and facebook page id
def save(self, bundle, skip_errors=False):
if bundle.request.method == 'POST':
self.is_valid(bundle)
if not bundle.errors:
result = bundle.obj.update_access_status()
if 'error' in result:
self.raise_appnexus_error(bundle.request, result['error'])
return super(BrandResource, self).save(bundle, skip_errors)
def dehydrate_appnexus_access_status(self, bundle):
return bundle.obj.get_appnexus_access_status_display()
def dehydrate(self, bundle):
return bundle
class AudienceResource(ProtectedModelResource):
id = IntegerField('id', readonly=True)
is_deleted = BooleanField('is_deleted', default=False, readonly=True)
owner = CharField(readonly=True)
tracking_code = CharField(readonly=True)
piggyback_url = CharField(readonly=True)
class Meta:
authorization = Auth('owner')
allowed_methods = ('get', 'post', 'get', 'put', 'delete')
always_return_data = True
filtering = {"is_deleted": (ALL)}
fields = ('name', 'id_random')
validation = FormValidation(form_class=AudienceForm)
queryset = Audience.objects.all()
resource_name = 'audience'
def hydrate(self, bundle):
bundle.obj.owner = bundle.request.user.account
return bundle
def dehydrate(self, bundle):
# We need to use public_id here
public_id = bundle.obj.public_id
bundle.data['tracking_code'] = get_audience_code(public_id)
bundle.data['piggyback_url'] = get_audience_piggyback_url(public_id)
return bundle
class EventResource(ModelResource):
band = IntegerField(attribute="band__pk")
class Meta:
queryset = Event.objects.all()
include_resource_uri = False
list_allowed_methods = ['get']
resource_name = 'events'
collection_name = 'events'
class SignalResource(ModelResource):
local_computer_id = IntegerField(attribute="local_computer_id")
system_id = IntegerField(attribute="system_id", null=True)
name = CharField(attribute="name", null=True)
experiment_id = IntegerField(attribute="experiment_id", null=True)
class Meta:
queryset = Signal.objects.all()
authorization = Authorization()
authentication = Authentication()
resource_name = 'signal'
always_return_data = True
filtering = {
'local_computer_id': ALL_WITH_RELATIONS,
'name': ALL_WITH_RELATIONS,
'experiment_id': ALL_WITH_RELATIONS
}
serializer = PrettyJSONSerializer()
class EventResource(ModelResource):
local_computer_id = IntegerField(attribute="local_computer_id")
system_id = IntegerField(attribute="system_id", null=True)
experiment_id = IntegerField(attribute="experiment_id", null=True)
class Meta:
queryset = Event.objects.all()
authorization = Authorization()
authentication = Authentication()
resource_name = 'event'
always_return_data = True
max_limit = 0
limit = 1000
filtering = {
'local_computer_id': ALL_WITH_RELATIONS,
'system_id': ALL_WITH_RELATIONS,
'created_at': ['gte', 'lte', 'lt', 'gt', 'eq'],
'experiment_id': ALL_WITH_RELATIONS,
'type': ALL_WITH_RELATIONS
}
serializer = PrettyJSONSerializer()
class QueryResource(ModelResource):
sample = CharField(attribute='sample',
readonly=True,
null=True,
help_text="sample of the data returned")
num_records = IntegerField(attribute='num_records',
readonly=True,
help_text="number of records matched")
sort_by = ToOneField(CensusFieldResource,
attribute='sort_by',
help_text="field to sort results by")
queryfilter_set = ToManyField('dds.api.QueryFilterResource',
attribute='queryfilter_set',
blank=True,
null=True,
full=True)
export_jobs = ToManyField(ExportJobResource,
attribute='exportjob_set',
help_text="jobs run with this query",
full=True,
blank=True,
null=True)
class Meta:
queryset = Query.objects.all()
authentication = SessionAuthentication()
authorization = OwnedOnlyAuthorization()
def obj_create(self, bundle, **kwargs):
return super(QueryResource,
self).obj_create(bundle,
account=bundle.request.user.account,
**kwargs)
def obj_get_list(self, bundle, **kwargs):
return [
f
for f in super(QueryResource, self).obj_get_list(bundle, **kwargs)
if f.account == bundle.request.user.account
]
def obj_get(self, bundle, **kwargs):
result = super(QueryResource, self).obj_get(bundle, **kwargs)
if result.account != bundle.request.user.account:
raise Unauthorized("Forbidden")
return result
def apply_authorization_limits(self, request, object_list):
return object_list.filter(account=request.user.account)
class CommandResource(ModelResource):
local_computer_id = IntegerField(attribute="local_computer_id")
is_executed = BooleanField(attribute="is_executed")
class Meta:
queryset = Command.objects.all()
authorization = Authorization()
authentication = Authentication()
resource_name = 'command'
always_return_data = True
filtering = {
'local_computer_id': ALL_WITH_RELATIONS,
'is_executed': ALL_WITH_RELATIONS
}
serializer = PrettyJSONSerializer()
class ExperimentResource(ModelResource):
local_computer_id = IntegerField(attribute="local_computer_id")
name = CharField(attribute="name", null=True)
class Meta:
queryset = Experiment.objects.all()
authorization = Authorization()
authentication = Authentication()
resource_name = 'experiment'
filtering = {
'local_computer_id': ALL_WITH_RELATIONS,
'name': ALL_WITH_RELATIONS,
}
always_return_data = True
serializer = PrettyJSONSerializer()
class NonSiteLocationNameResource(ModelResource):
loc_type = CharField()
parent_id = IntegerField()
text = CharField()
class Meta:
fields = ['pk']
limit = 0
resource_name = 'location-names'
allowed_methods = ['get']
queryset = Location.objects.exclude(loc_type__code='adm6')
def dehydrate(self, bundle):
bundle.data['text'] = bundle.obj.name
bundle.data['loc_type'] = bundle.obj.loc_type.name.lower()
if bundle.obj.parent:
bundle.data['parent_id'] = bundle.obj.parent.pk
else:
bundle.data['parent_id'] = None
return bundle
class CreativeResource(ProtectedModelResource):
class Meta:
resource_name = 'creative'
allowed_methods = ('get', 'post', 'get', 'put', 'delete')
always_return_data = True
filtering = {
'destination': (
'exact',
'startswith',
),
}
queryset = Creative.objects_visible.all()
authorization = Auth('owner')
fields = ('name', 'width', 'height', 'api_data', 'destination')
validation = CreativeValidation()
id = IntegerField('id', readonly=True)
size = ListField('size', readonly=True)
type = CharField(readonly=True)
status = CharField('appnexus_status', readonly=True)
api_data = CharField('api_data')
vast_url = CharField('vast_url', readonly=True, null=True)
to_audit = BooleanField('to_audit', readonly=True, null=True)
fb_title = CharField('title', null=True)
fb_body = CharField('body', null=True)
fb_message = CharField('message', null=True)
fb_domain = CharField('domain', null=True)
fb_brand_page = IntegerField('brand_id', null=True)
def prepend_urls(self):
return [
url(r"^{0}/audit/(?P<creative_id>[\d]+)$".format(
self._meta.resource_name, ),
self.wrap_view('manual_audit'),
name="creative_manual_audit"),
]
def manual_audit(self, request, creative_id, **kwargs):
"""
Manual audit api view.
:param request: request object
:param int creative_id: creative which we want to send to audit
Returns detail response.
"""
creative = Creative.objects.get(id=creative_id)
creative.to_audit = True
creative.save()
return self.get_detail(request, pk=creative_id)
def dehydrate_destination(self, bundle):
return bundle.obj.get_destination_display()
def dehydrate(self, bundle):
creative = bundle.obj
# get type based on class name
bundle.data['type'] = creative.type
bundle.data['status'] = creative.state.status
bundle.data['is_auditable'] = creative.is_auditable
if creative.is_facebook_destination(verify_is_newsfeed=True):
bundle.data[
'fb_brand_page_access'] = creative.brand.appnexus_access_status
if creative.type == 'Video':
bundle.data['liverail_status'] = creative.liverail_status
else:
bundle.data['liverail_status'] = ''
# If facebook creative was added to strategy,
# Add information about strategy and campaign
if creative.is_facebook_destination():
# For facebook creatives there is only one advert
advert = creative.advert_set.filter(
is_deleted=False,
strategy__is_deleted=False,
strategy__campaign__is_deleted=False).first()
if advert:
strategy = advert.strategy
campaign = strategy.campaign
bundle.data['strategy'] = strategy.name
bundle.data['campaign'] = campaign.name
return bundle
def hydrate_destination(self, bundle):
bundle.data['destination'] = DESTINATION[bundle.data['destination']]
return bundle
def hydrate_fb_brand_page(self, bundle):
""" Clear creative brand page if it is not facebook newsfeed. """
if bundle.data['destination'] != 'facebook_newsfeed':
bundle.data['fb_brand_page'] = None
return bundle
def hydrate(self, bundle):
# A bug in Tastypie: on update, hydrate is called 2 times,
# once with obj.id == None and method == 'PUT'
# We should create an object only if method is POST
if not bundle.obj.id and bundle.request.method == 'POST':
bundle.obj = creative_factory(bundle.data['type'],
owner=bundle.request.user.account)
return bundle
