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 QuotesResource(Resource):
""" Quotes resource """
date = fields.DateTimeField(attribute='date', null=True)
symbol = fields.CharField(attribute='symbol', null=True)
price = fields.DecimalField(attribute='price', null=True)
volume = fields.DecimalField(attribute='volume', null=True)
type = fields.CharField(attribute='type', null=True)
def base_urls(self):
return []
def override_urls(self):
return [
url(r"^symbols/(?P<symbol>[^/]+)/(?P<resource_name>%s)%s$" %
(self._meta.resource_name, trailing_slash()),
self.wrap_view('dispatch_list'),
name="api_quotes_list"),
]
def obj_get_list(self, request=None, **kwargs):
symbol = 'symbol_{0}'.format(kwargs.get('symbol').upper())
redis = RedisDB()
json = '[{0}]'.format(','.join(redis.lrange(symbol, 0, 1000)))
quote_type = request.GET.get('type', 'ask')
objs = [Quote(quote_type, **x) for x in simplejson.loads(json)]
return objs
class Meta:
resource_name = 'quotes'
list_allowed_methods = [
'get',
]
filtering = {"type": ALL_WITH_RELATIONS}
class InvoiceResource(ModelResource):
subscription = fields.IntegerField('subscription_id')
subtotal = fields.DecimalField('subtotal')
applied_credit = fields.DecimalField('applied_credit')
class Meta(AccountingResourceMeta):
queryset = Invoice.api_objects.all().order_by('pk')
fields = ['id', 'tax_rate', 'balance', 'date_due', 'date_paid', 'date_created',
'date_start', 'date_end', 'is_hidden', 'is_hidden_to_ops', 'last_modified']
resource_name = 'invoice'
class WeatherObservationResource(APIResource):
date = fields.CharField(attribute='local_date', readonly=True)
rainfall = fields.DecimalField(attribute='actual_rainfall', readonly=True)
dew_point = fields.DecimalField(attribute='dew_point', readonly=True)
station_id = fields.IntegerField(attribute='station_id', readonly=True)
station_name = fields.CharField(attribute='station__name', readonly=True)
station_bom_abbreviation = fields.CharField(
attribute='station__bom_abbreviation', readonly=True)
Meta = generate_meta(WeatherObservation)
Meta.filtering.update({
'station_id': ALL_WITH_RELATIONS,
})
class PopulationResource(ModelResource):
location = fields.ForeignKey(LocationResource, 'location')
geometry = fields.ListField()
percent = fields.DecimalField()
class Meta:
queryset = Population.objects.all()
resource_name = 'population'
allowed_methods = ['get']
limit = 200
def dehydrate_geometry(self, bundle):
logger.debug(bundle.obj.name)
geom = bundle.obj.location.geometry.simplify(0.0005,
preserve_topology=True)
if geom.geom_type != 'MultiPolygon':
logger.debug('Converting back to MultiPolygon')
geom = MultiPolygon(geom)
return geom.coords
def dehydrate_percent(self, bundle):
max_val = Population.objects.order_by('-total')[0].total * 1.0
# total = Population.objects.aggregate(sum=Sum('total'))['sum'] * 1.0
percent = bundle.obj.total / max_val
print bundle.obj.total, max_val, percent
return percent
class WeatherObservationResource(APIResource):
date = fields.CharField(attribute='local_date', readonly=True)
# TODO: dew_point and rainfall should be calculated on save and served straight from db
# rainfall = fields.DecimalField(attribute='get_rainfall', readonly=True)
dew_point = fields.DecimalField(attribute='dew_point', readonly=True)
station = fields.IntegerField(attribute='station_id', readonly=True)
Meta = generate_meta(WeatherObservation)
class OccupationInformation(Resource):
day = fields.IntegerField(readonly=True)
occupation = fields.DecimalField(readonly=True)
class Meta:
resource_name = 'occupation_information'
allowed_methods = 'get'
def dehydrate_day(self, bundle):
return int(bundle.obj[0])
def dehydrate_occupation(self, bundle):
return bundle.obj[1]
def obj_get(self, request, **kwargs):
#Information can only be obtained if asking for a list
return {'day': '', 'occupation': ''}
def obj_get_list(self, request, **kwargs):
try:
asset_id = int(request.GET.get('asset', ''))
month = int(request.GET.get('month', ''))
year = int(request.GET.get('year', ''))
except ValueError:
return []
ret = get_occupation_for_month(asset_id, month, year)
return ret
class CustomerInvoiceResource(ModelResource):
account = fields.IntegerField('account_id')
subtotal = fields.DecimalField('subtotal')
applied_credit = fields.DecimalField('applied_credit')
class Meta(AccountingResourceMeta):
queryset = CustomerInvoice.api_objects.order_by('pk')
fields = ['id', 'tax_rate', 'balance', 'date_due', 'date_paid', 'date_created',
'date_start', 'date_end', 'is_hidden', 'is_hidden_to_ops', 'last_modified']
resource_name = 'customer_invoice'
def dehydrate(self, bundle):
bundle.data['plan_versions'] = ','.join(set(
str(subscription.plan_version.id)
for subscription in bundle.obj.subscriptions.all()
))
return bundle
class LineItemResource(ModelResource):
invoice = fields.IntegerField('invoice_id', null=True)
feature_rate = fields.IntegerField('feature_rate_id', null=True)
product_rate = fields.IntegerField('product_rate_id', null=True)
subtotal = fields.DecimalField('subtotal')
applied_credit = fields.DecimalField('applied_credit')
class Meta(AccountingResourceMeta):
queryset = LineItem.objects.all().order_by('pk')
fields = ['id', 'base_description', 'base_cost', 'unit_description', 'unit_cost', 'quantity',
'last_modified']
resource_name = 'accounting_line_items'
filtering = {
'last_modified': ['gt', 'gte', 'lt', 'lte'],
'date_updated': ['gt', 'gte', 'lt', 'lte'],
'invoice': ['exact']
}
class PostResource(ModelResource):
author = fields.ForeignKey(AuthorResource, attribute='author', null=True)
files = fields.ManyToManyField('tests.tastypie_api.api.MediaResource',
attribute='files')
date = fields.DateTimeField('date')
rating = fields.DecimalField('rating', null=True)
content = fields.CharField('content')
class Meta:
queryset = Post.objects.all()
resource_name = u'post'
class InvoiceItemResource(VosaeResource):
reference = base_fields.CharField(
attribute='reference',
help_text=HELP_TEXT['invoice_item']['reference'])
description = base_fields.CharField(
attribute='description',
help_text=HELP_TEXT['invoice_item']['description'])
quantity = base_fields.DecimalField(
attribute='quantity', help_text=HELP_TEXT['invoice_item']['quantity'])
unit_price = base_fields.DecimalField(
attribute='unit_price',
help_text=HELP_TEXT['invoice_item']['unit_price'])
tax = fields.ReferenceField(to='invoicing.api.resources.TaxResource',
attribute='tax',
null=True,
help_text=HELP_TEXT['invoice_item']['tax'])
class Meta(VosaeResource.Meta):
object_class = InvoiceItem
class ExchangeRateResource(VosaeResource):
currency_to = base_fields.CharField(
attribute='currency_to',
help_text=HELP_TEXT['exchange_rate']['currency_to'])
datetime = base_fields.DateTimeField(
attribute='datetime', help_text=HELP_TEXT['exchange_rate']['datetime'])
rate = base_fields.DecimalField(
attribute='rate', help_text=HELP_TEXT['exchange_rate']['rate'])
class Meta(VosaeResource.Meta):
object_class = ExchangeRate
include_resource_uri = False
class ParagraphResource(ModelResource):
citation_id = fields.ForeignKey(CitationResource, 'citation_id')
sentscore = fields.DecimalField(readonly=True)
class Meta:
# object_list = Decision.objects.filter(canlii_id = "2001scc2")
# input_canlii_id = '2001scc2'
queryset = Paragraph.objects.all()
# queryset = Paragraph.objects.all().filter(citation_id = Citation.objects.all().filter(cited_case_id = Decision.objects.get(canlii_id = input_canlii_id)))
resource_name = 'paragraph'
filtering = {'cited_paragraph': ALL_WITH_RELATIONS}
# def dehydrate_sentscore(self, bundle):
# average_score = 0.0
# for para in bundle.obj.sentiment_score.all():
# average_score = 10000.000
# return average_score
# choose field names to include
# fields = ['cited_paragraph', 'sentiment_score']
# # http://django-tastypie.readthedocs.org/en/latest/resources.html#alter-list-data-to-serialize
# def alter_list_data_to_serialize(self, request, data):
# if request.GET.get('meta_only'):
# return {'meta': data['meta']}
# return data
# # Create your models here.
# class Decision(models.Model):
# case_id_canlii = models.CharField(max_length = 100)
# case_name = models.CharField(max_length = 500)
# case_neutral_citation = models.CharField(max_length = 100)
# def __str__(self):
# return self.case_name
# class Citation(models.Model):
# cited_case_id = models.ForeignKey(Decision, related_name="cited_case", on_delete = models.PROTECT)
# citing_case_id = models.ForeignKey(Decision, related_name="citing_case", on_delete = models.PROTECT)
# def __str__(self):
# return self.cited_case_id.case_name + " " + self.citing_case_id.case_name
# class Paragraph(models.Model):
# citing_case_id = models.ForeignKey(Citation, on_delete = models.PROTECT)
# cited_paragraph = models.PositiveIntegerField()
# citing_paragraph = models.PositiveIntegerField()
# def __str__(self):
# return self.cited_paragraph
class AnotherNoteResource(ModelResource):
aliases = fields.ListField(attribute='aliases', null=True)
meta = fields.DictField(attribute='metadata', null=True)
owed = fields.DecimalField(attribute='money_owed', null=True)
class Meta:
resource_name = 'anothernotes'
queryset = Note.objects.filter(is_active=True)
def dehydrate(self, bundle):
bundle.data['aliases'] = ['Mr. Smith', 'John Doe']
bundle.data['meta'] = {'threat': 'high'}
bundle.data['owed'] = Decimal('102.57')
return bundle
class TaxResource(ZombieMixinResource, TenantResource):
name = base_fields.CharField(attribute='name',
help_text=HELP_TEXT['tax']['name'])
rate = base_fields.DecimalField(attribute='rate',
help_text=HELP_TEXT['tax']['rate'])
class Meta(TenantResource.Meta):
queryset = Tax.objects.all()
excludes = ('tenant', )
def hydrate_rate(self, bundle):
"""Rate is immutable, on PUT, ensures that rate is equal to the initial value"""
if bundle.request.method.lower() == 'put':
bundle.data['rate'] = bundle.obj.rate
return bundle
class CampaignResource(ModelResource):
amount_raised = fields.DecimalField(attribute='amount_raised', null=True)
formatted_amount_raised = fields.CharField(attribute='formatted_amount_raised', null=True)
formatted_amount_goal = fields.CharField(attribute='formatted_amount_goal', null=True)
percent_raised = fields.IntegerField(attribute='percent_raised', null=True)
days_left = fields.IntegerField(attribute='days_left', null=True)
class Meta:
queryset = CommunityCampaign.objects.all()
resource_name = 'campaign'
allowed_methods = ['get']
authorization= Authorization()
authentication = Authentication()
filtering = {
'year': ('exact'),
}
class UserResource(ProtectedModelResource):
prepend_urls = prepend_slug
class Meta:
resource_name = 'user'
queryset = User.objects.all()
allowed_methods = ('get', )
authorization = Auth('id', lambda b: b.request.user.id)
always_return_data = True
fields = ['unread_events_count', 'email', 'account__account_number']
id = fields.IntegerField('id', readonly=True)
username = fields.CharField('username', readonly=True)
timezone = fields.CharField('account__timezone', readonly=True)
account_number = fields.IntegerField('account__account_number',
readonly=True)
account_balance = fields.DecimalField('account__account_balance',
readonly=True)
class PaymentBaseResource(TenantResource):
issued_at = base_fields.DateTimeField(
attribute='issued_at',
readonly=True,
help_text=HELP_TEXT['payment']['issued_at']
)
date = base_fields.DateField(
attribute='date',
help_text=HELP_TEXT['payment']['date']
)
amount = base_fields.DecimalField(
attribute='amount',
help_text=HELP_TEXT['payment']['amount']
)
type = base_fields.CharField(
attribute='type',
blank=True,
help_text=HELP_TEXT['payment']['type']
)
note = base_fields.CharField(
attribute='note',
null=True,
blank=True,
help_text=HELP_TEXT['payment']['note']
)
issuer = fields.ReferenceField(
to='core.api.resources.VosaeUserResource',
attribute='issuer',
readonly=True,
help_text=HELP_TEXT['payment']['issuer']
)
currency = fields.ReferenceField(
to='invoicing.api.resources.CurrencyResource',
attribute='currency',
help_text=HELP_TEXT['payment']['currency']
)
class Meta(TenantResource.Meta):
excludes = ('tenant',)
list_allowed_methods = ('post')
detail_allowed_methods = ('get', 'delete',)
class DownPaymentInvoiceResource(InvoiceResource):
state = base_fields.CharField(
attribute='state',
readonly=True,
help_text=HELP_TEXT['downpayment']['state']
)
percentage = base_fields.DecimalField(
attribute='percentage',
help_text=HELP_TEXT['downpayment']['percentage']
)
tax_applied = fields.ReferenceField(
to='invoicing.api.resources.TaxResource',
attribute='tax_applied',
help_text=HELP_TEXT['downpayment']['tax_applied']
)
class Meta(InvoiceResource.Meta):
resource_name = 'down_payment_invoice'
queryset = DownPaymentInvoice.objects.all()
list_allowed_methods = ('get',)
detail_allowed_methods = ('get',)
detail_specific_methods = ('cancel',)
class ItemResource(WakeUpMixinResource, ZombieMixinResource, TenantResource):
reference = base_fields.CharField(attribute='reference',
help_text=HELP_TEXT['item']['reference'])
description = base_fields.CharField(
attribute='description', help_text=HELP_TEXT['item']['description'])
unit_price = base_fields.DecimalField(
attribute='unit_price', help_text=HELP_TEXT['item']['unit_price'])
type = base_fields.CharField(attribute='type',
help_text=HELP_TEXT['item']['type'])
currency = fields.ReferenceField(
to='invoicing.api.resources.CurrencyResource',
attribute='currency',
null=True,
help_text=HELP_TEXT['item']['currency'])
tax = fields.ReferenceField(to='invoicing.api.resources.TaxResource',
attribute='tax',
null=True,
help_text=HELP_TEXT['item']['tax'])
class Meta(TenantResource.Meta):
queryset = Item.objects.all()
excludes = ('tenant', )
class BaseCategoryRestrictionResource(ModelResource):
category = fields.ForeignKey(CategoryResource,
'category',
null=False,
blank=False,
full=True,
readonly=True)
value = fields.DecimalField(attribute='value')
class Meta:
queryset = BaseCategoryRestriction.objects.all()
always_return_data = True
authentication = MultiAuthentication(SessionAuthentication(),
BasicAuthentication())
authorization = UserObjectsOnlyAuthorization()
validation = FormValidation(form_class=BaseCategoryRestrictionApiForm)
list_allowed_methods = ['get', 'post']
detail_allowed_methods = ['get', 'put', 'delete']
resource_name = "threshold/category"
def hydrate_category(self, bundle):
if not 'category' in bundle.data and bundle.request.method == "POST":
bundle.data['category'] = None
return bundle
def obj_create(self, bundle, **kwargs):
return super(BaseCategoryRestrictionResource,
self).obj_create(bundle, user=bundle.request.user)
def save(self, *args, **kwargs):
try:
return super(BaseCategoryRestrictionResource,
self).save(*args, **kwargs)
except IntegrityError, e:
if 'not unique' in unicode(e):
raise BadRequest(
_(u'Já existe um limite de gastos para este mês'))
class StrategyResource(ProtectedModelResource, Targeting):
prepend_urls = prepend_slug
class Meta:
resource_name = 'strategy'
queryset = Strategy.objects_visible.all()
fields = ('name', 'landing_site_variable', 'budget_total',
'budget_daily', 'budget_bid_CPM', 'capping_total',
'capping_day', 'is_automatically_bidded', 'optimized_metric')
allowed_methods = ('get', 'post', 'patch', 'put', 'delete')
always_return_data = True
authorization = Auth('campaign__account')
validation = StrategyValidation(**Targeting.ALL_MAPPINGS)
def get_object_list(self, request):
''' Filter by owner to avoid multiple objects with the same slug in details view '''
all_objects = super(StrategyResource, self).get_object_list(request)
return all_objects.filter(campaign__account=request.user.account)
id = fields.IntegerField('id', readonly=True)
campaign = \
fields.ForeignKey('ui.campaign.api.CampaignResource', 'campaign')
campaign_slug = fields.CharField('campaign__slug', readonly=True)
campaign_total_budget = fields.DecimalField('campaign__total_budget',
null=True)
periods = fields.ToManyField('ui.campaign.api.PeriodResource',
'biddingperiod_set',
full=True)
paused = fields.BooleanField('is_paused')
reviewed = fields.BooleanField('is_reviewed', readonly=True)
slug = fields.CharField('slug', readonly=True)
budget_spent_with_commission = fields.DecimalField(
'budget_spent_with_commission', readonly=True)
budget_left = fields.DecimalField('budget_left', readonly=True)
budget_daily_spent = fields.DecimalField('budget_daily_spent',
readonly=True)
distributed_evenly = fields.BooleanField('is_distributed_evenly')
capping_total_spent = fields.DecimalField('capping_total_spent',
readonly=True)
capping_day_spent = fields.DecimalField('capping_day_spent', readonly=True)
targetingIncludeAudiences = \
fields.ToManyField('ui.storage.api.AudienceResource',
'audiences', full=True)
targetingExcludeAudiences = \
fields.ToManyField('ui.storage.api.AudienceResource',
'audiences_exclude', full=True)
target_devices = fields.BooleanField('is_targeted_devices')
target_localization = fields.BooleanField('is_targeted_local')
target_user_profile = fields.BooleanField('is_targeted_user_profile')
target_publisher = fields.BooleanField('is_targeted_publisher')
publisherset = fields.ForeignKey('ui.publishers.api.PublisherSetResource',
'publisherset',
null=True)
utm_tags = fields.BooleanField('is_UTM_tags')
day_parted = fields.BooleanField('is_day_parted')
bid_on_unknown_users = fields.BooleanField('is_bid_on_unknown_users')
ui_to_db_mapping = {}
db_to_ui_mapping = {}
for ui_type, db_type in Strategy.STRATEGY_TYPES:
ui_to_db_mapping[ui_type] = db_type
db_to_ui_mapping[db_type] = ui_type
# frontend -> backend
def hydrate(self, bundle):
# filling missing fields
campaign_id = bundle.data['campaign']
publisherset_id = bundle.data['publisherset']
# FIXME: Use Django form for choices field.
# Translate from UI names to db/targeting/bidreq names:
bundle.obj.type = self.ui_to_db_mapping[bundle.data['type']]
if isinstance(campaign_id, int):
bundle.data['campaign'] = '/api/campaign/%d/' % campaign_id
if isinstance(publisherset_id, int):
bundle.data['publisherset'] =\
'/api/publishers/sets/%d/' % publisherset_id
bundle.data['periods'] = []
bundle.data['target_localization'] = []
bundle.data['target_user_profile'] = []
bundle.data['target_publisher'] = []
bundle.data['target_devices'] = []
# Warning: this will save actual value from UI. It will be updated
# by cron which push redis data to the sql.
if bundle.obj.pk:
db_object = Strategy.objects.get(pk=bundle.obj.pk)
bundle.obj.budget_spent = db_object.budget_spent
bundle.obj.budget_spent_commission = db_object.budget_spent_commission
bundle.obj.budget_daily_spent = db_object.budget_daily_spent
for preriod in bundle.data['bidding_periods']:
if isinstance(preriod['from'], basestring)\
and isinstance(preriod['to'], basestring):
preriod['from'] = datetime.datetime.strptime(
preriod['from'], '%H:%M').time()
preriod['to'] = datetime.datetime.strptime(
preriod['to'], '%H:%M').time()
return bundle
# frontend -> backend (m2m)
def hydrate_m2m(self, bundle):
if bundle.obj is not None and bundle.obj.pk is not None:
# adds related objects which are not explicitly in this resource
bundle.obj.landing_sites_def = bundle.data['landing_sites']
bundle.obj.bidding_periods = bundle.data['bidding_periods']
bundle.obj.adverts_def = bundle.data['adverts']
# map targeting search fields
bundle.obj.search_fields_def = self.frontend_to_backend_mapping(
self.SEARCH_FIELDS_MAPPING, bundle.data)
# map content category targeting fields
bundle.obj.content_categories_def = self.frontend_to_backend_mapping(
self.CONTENT_CATEGORY_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (maturity rating)
bundle.obj.proximic_maturity_rating_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_MATURITY_RATING_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (safety level)
bundle.obj.proximic_safety_level_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_SAFETY_LEVEL_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (language)
bundle.obj.proximic_language_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_LANGUAGE_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (page quality)
bundle.obj.proximic_page_quality_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_PAGE_QUALITY_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (page noticeability)
bundle.obj.proximic_page_noticeability_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_PAGE_NOTICEABILITY_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (page placement)
bundle.obj.proximic_page_placement_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_PAGE_PLACEMENT_FIELDS_MAPPING,
bundle.data,
)
# map segments targeting fields (contextual)
bundle.obj.proximic_contextual_fields_def = self.frontend_to_backend_mapping(
self.PROXIMIC_CONTEXTUAL_FIELDS_MAPPING,
bundle.data,
)
bundle.obj.peer_content_categories_def = self.frontend_to_backend_mapping(
self.PEER_CONTEXTUAL_SEGMENT_FIELDS_MAPPING,
bundle.data,
)
bundle.obj.peer_page_quality_def = self.frontend_to_backend_mapping(
self.PEER_PAGE_QUALITY_FIELDS_MAPPING, bundle.data)
bundle.obj.peer_language_def = self.frontend_to_backend_mapping(
self.PEER_LANGUAGE_FIELDS_MAPPING, bundle.data)
bundle.obj.peer_brand_protection_def = self.frontend_to_backend_mapping(
self.PEER_BRAND_PROTECTION_FIELDS_MAPPING, bundle.data)
bundle.obj.lotame_demographic = self.frontend_to_backend_mapping(
self.LOTAME_DEMOGRAPHIC_FIELDS_MAPPING, bundle.data)
bundle.obj.lotame_advanced_demographic = self.frontend_to_backend_mapping(
self.LOTAME_ADVANCED_DEMOGRAPHIC_FIELDS_MAPPING, bundle.data)
bundle.obj.lotame_behavioral_interest = self.frontend_to_backend_mapping(
self.LOTAME_BEHAVIORAL_FIELDS_MAPPING, bundle.data)
bundle.obj.lotame_influencers = self.frontend_to_backend_mapping(
self.LOTAME_INFLUENCERS_MAPPING, bundle.data)
bundle.obj.lotame_offline = self.frontend_to_backend_mapping(
self.LOTAME_OFFLINE_MAPPING, bundle.data)
return super(ProtectedModelResource, self).hydrate_m2m(bundle)
def dehydrate_state(self, bundle):
bundle.data['state'] = bundle.obj.state.to_dict()
# backend -> frontend
def dehydrate(self, bundle):
strategy = bundle.obj
# FIXME: Use Django form for choices field.
# Translate from db/targeting/bidreq names to UI names:
# Dehydrate may be called twice. Check if the names are already
# translated:
bundle.data['type'] = self.db_to_ui_mapping[strategy.type]
bundle.data['campaign'] = strategy.campaign_id
bundle.data['publisherset'] = strategy.publisherset_id
bundle.data['landing_sites'] = strategy.landing_sites_def
bundle.data['bidding_periods'] = strategy.bidding_periods
bundle.data['adverts'] = strategy.adverts_def
if (strategy.budget_bid_CPM):
bundle.data['budget_bid_CPM'] = \
strategy.budget_bid_CPM.quantize(TWOPLACES)
bundle.data['budget_spent_with_commission'] = Decimal(
strategy.budget_spent_with_commission).quantize(TWOPLACES)
bundle.data['budget_spent'] = \
Decimal(strategy.budget_spent).quantize(TWOPLACES)
if (strategy.budget_daily):
bundle.data['budget_daily'] = \
Decimal(strategy.budget_daily).quantize(TWOPLACES)
bundle.data['budget_daily_spent'] = \
Decimal(strategy.budget_daily_spent).quantize(TWOPLACES)
bundle.data['budget_left'] = \
Decimal(strategy.budget_left).quantize(TWOPLACES)
# map targeting search fields
self.backend_to_frontend_mapping(
self.SEARCH_FIELDS_MAPPING,
bundle.data,
strategy.search_fields_def,
)
# map content category targeting
self.backend_to_frontend_mapping(
self.CONTENT_CATEGORY_FIELDS_MAPPING,
bundle.data,
strategy.content_categories_def,
)
# map proximic maturity rating targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_MATURITY_RATING_FIELDS_MAPPING,
bundle.data,
strategy.proximic_maturity_rating_fields_def,
)
# map proximic safety level targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_SAFETY_LEVEL_FIELDS_MAPPING,
bundle.data,
strategy.proximic_safety_level_fields_def,
)
# map proximic safety level targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_LANGUAGE_FIELDS_MAPPING,
bundle.data,
strategy.proximic_language_fields_def,
)
# map proximic safety level targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_PAGE_QUALITY_FIELDS_MAPPING,
bundle.data,
strategy.proximic_page_quality_fields_def,
)
# map proximic noticeability targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_PAGE_NOTICEABILITY_FIELDS_MAPPING,
bundle.data,
strategy.proximic_page_noticeability_fields_def,
)
# map proximic page placement targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_PAGE_PLACEMENT_FIELDS_MAPPING,
bundle.data,
strategy.proximic_page_placement_fields_def,
)
# map proximic contextual targeting
self.backend_to_frontend_mapping(
self.PROXIMIC_CONTEXTUAL_FIELDS_MAPPING,
bundle.data,
strategy.proximic_contextual_fields_def,
)
self.backend_to_frontend_mapping(
self.PEER_CONTEXTUAL_SEGMENT_FIELDS_MAPPING, bundle.data,
strategy.peer_content_categories_def)
self.backend_to_frontend_mapping(self.PEER_LANGUAGE_FIELDS_MAPPING,
bundle.data,
strategy.peer_language_def)
self.backend_to_frontend_mapping(
self.PEER_BRAND_PROTECTION_FIELDS_MAPPING, bundle.data,
strategy.peer_brand_protection_def)
self.backend_to_frontend_mapping(self.PEER_PAGE_QUALITY_FIELDS_MAPPING,
bundle.data,
strategy.peer_page_quality_def)
self.backend_to_frontend_mapping(
self.LOTAME_DEMOGRAPHIC_FIELDS_MAPPING, bundle.data,
strategy.lotame_demographic)
self.backend_to_frontend_mapping(
self.LOTAME_ADVANCED_DEMOGRAPHIC_FIELDS_MAPPING, bundle.data,
strategy.lotame_advanced_demographic)
self.backend_to_frontend_mapping(self.LOTAME_BEHAVIORAL_FIELDS_MAPPING,
bundle.data,
strategy.lotame_behavioral_interest)
self.backend_to_frontend_mapping(self.LOTAME_INFLUENCERS_MAPPING,
bundle.data,
strategy.lotame_influencers)
self.backend_to_frontend_mapping(self.LOTAME_OFFLINE_MAPPING,
bundle.data, strategy.lotame_offline)
self.dehydrate_state(bundle)
return bundle
class InvoiceBaseResource(NotificationAwareResourceMixin, TenantResource,
VosaeIMEXMixinResource):
reference = base_fields.CharField(
attribute='reference',
readonly=True,
help_text=HELP_TEXT['invoicebase']['reference'])
total = base_fields.DecimalField(
attribute='total',
readonly=True,
help_text=HELP_TEXT['invoicebase']['total'])
amount = base_fields.DecimalField(
attribute='amount',
readonly=True,
help_text=HELP_TEXT['invoicebase']['amount'])
account_type = base_fields.CharField(
attribute='account_type',
help_text=HELP_TEXT['invoicebase']['account_type'])
issuer = fields.ReferenceField(
to='core.api.resources.VosaeUserResource',
attribute='issuer',
readonly=True,
help_text=HELP_TEXT['invoicebase']['issuer'])
organization = fields.ReferenceField(
to='contacts.api.resources.OrganizationResource',
attribute='organization',
readonly=True,
null=True,
help_text=HELP_TEXT['invoicebase']['organization'])
contact = fields.ReferenceField(
to='contacts.api.resources.ContactResource',
attribute='contact',
readonly=True,
null=True,
help_text=HELP_TEXT['invoicebase']['contact'])
history = fields.EmbeddedListField(
of='invoicing.api.resources.InvoiceHistoryEntryResource',
attribute='history',
readonly=True,
full=True,
null=True,
blank=True,
help_text=HELP_TEXT['invoicebase']['history'])
notes = fields.EmbeddedListField(
of='invoicing.api.resources.InvoiceNoteResource',
attribute='notes',
full=True,
null=True,
blank=True,
help_text=HELP_TEXT['invoicebase']['notes'])
group = fields.ReferenceField(
to='invoicing.api.resources.InvoiceBaseGroupResource',
attribute='group',
readonly=True,
help_text=HELP_TEXT['invoicebase']['group'])
attachments = fields.ReferencedListField(
of='core.api.resources.VosaeFileResource',
attribute='attachments',
null=True,
blank=True,
help_text=HELP_TEXT['invoicebase']['attachments'])
class Meta(TenantResource.Meta):
excludes = ('tenant', 'base_type', 'subscribers')
filtering = {
'state': ('exact', 'in'),
'contact': ('exact', ),
'organization': ('exact', ),
'account_type': ('exact', ),
'reference': ('contains', )
}
available_imex_serializers = (invoicing_imex.PDFSerializer, )
def prepend_urls(self):
"""Add urls for resources actions."""
urls = super(InvoiceBaseResource, self).prepend_urls()
urls.extend(VosaeIMEXMixinResource.prepend_urls(self))
urls.extend((
url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/send/mail%s$' %
(self._meta.resource_name, trailing_slash()),
self.wrap_view('send_by_mail'),
name='api_invoicebase_send_by_mail'),
url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/mark_as_(?P<invoicebase_state>(%s))%s$'
% (self._meta.resource_name, '|'.join(
[k.lower() for k in MARK_AS_STATES]), trailing_slash()),
self.wrap_view('mark_as_state'),
name='api_invoicebase_mark_as_state'),
url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/generate_pdf%s$' %
(self._meta.resource_name, trailing_slash()),
self.wrap_view('generate_pdf'),
name='api_invoicebase_generate_pdf'),
))
return urls
@classmethod
def post_save(self, sender, resource, bundle, created, **kwargs):
"""
Post save API hook handler
- Add timeline and notification entries
"""
# Add timeline and notification entries
invoicebase_saved_task.delay(bundle.request.vosae_user, bundle.obj,
created)
def obj_delete(self, bundle, **kwargs):
"""Raises a BadRequest if the :class:`~invoicing.models.InvoiceBase` is not in a deletable state"""
try:
super(InvoiceBaseResource, self).obj_delete(bundle, **kwargs)
except NotDeletableInvoice as e:
raise BadRequest(e)
def do_export(self, request, serializer, export_objects):
"""Export"""
if len(export_objects) is not 1:
raise BadRequest('PDF export can only be done on a single item.')
return serializer.serialize(export_objects[0]), None
def send_by_mail(self, request, **kwargs):
"""Send an InvoiceBase by mail."""
self.method_check(request, allowed=['post'])
self.is_authenticated(request)
self.throttle_check(request)
try:
bundle = self.build_bundle(request=request)
obj = self.cached_obj_get(bundle=bundle,
**self.remove_api_resource_names(kwargs))
except ObjectDoesNotExist:
return http.HttpNotFound()
try:
email_data = self.deserialize(request,
request.body,
format=request.META.get(
'CONTENT_TYPE',
'application/json'))
subject = email_data.get('subject')
message = email_data.get('message')
to = email_data.get('to')
cc = email_data.get('cc', [])
bcc = email_data.get('bcc', [])
assert isinstance(to, list) and isinstance(
cc, list) and isinstance(bcc, list)
except:
raise BadRequest('Invalid email parameters.')
try:
obj.send_by_mail(subject, message, to, cc, bcc, request.vosae_user)
except:
raise BadRequest('Can\'t send email. Verify parameters.')
self.log_throttled_access(request)
to_be_serialized = {}
to_be_serialized = self.alter_list_data_to_serialize(
request, to_be_serialized)
return self.create_response(request, to_be_serialized)
def mark_as_state(self, request, invoicebase_state, **kwargs):
"""Set state for an InvoiceBase."""
self.method_check(request, allowed=['put'])
self.is_authenticated(request)
self.throttle_check(request)
try:
bundle = self.build_bundle(request=request)
obj = self.cached_obj_get(bundle=bundle,
**self.remove_api_resource_names(kwargs))
except ObjectDoesNotExist:
return http.HttpNotFound()
try:
previous_state, new_state = obj.set_state(
invoicebase_state.upper(), issuer=request.vosae_user)
invoicing_signals.post_client_changed_invoice_state.send(
obj.__class__,
issuer=request.vosae_user,
document=obj,
previous_state=previous_state)
except (obj.InvalidState, InvalidInvoiceBaseState) as e:
raise BadRequest(e)
self.log_throttled_access(request)
return http.HttpNoContent()
# May need to use this with ember (check if always_return_data)
# to_be_serialized = ''
# to_be_serialized = self.alter_list_data_to_serialize(request, to_be_serialized)
# return self.create_response(request, to_be_serialized)
def generate_pdf(self, request, **kwargs):
"""Generate a PDF"""
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
try:
bundle = self.build_bundle(request=request)
obj = self.cached_obj_get(bundle=bundle,
**self.remove_api_resource_names(kwargs))
except ObjectDoesNotExist:
return http.HttpNotFound()
try:
language = request.META.get('HTTP_X_REPORT_LANGUAGE', None)
if language is not None:
assert language in [k[0] for k in settings.LANGUAGES]
except:
raise BadRequest('Invalid language parameters.')
try:
pdf = obj.get_pdf(issuer=request.vosae_user, language=language)
pdf_resource = VosaeFileResource()
pdf_resource_bundle = pdf_resource.build_bundle(obj=pdf,
request=request)
except Exception, e:
print e
raise BadRequest('Can\'t generate PDF. Verify parameters.')
self.log_throttled_access(request)
pdf_resource_bundle = pdf_resource.full_dehydrate(pdf_resource_bundle)
pdf_resource_bundle = pdf_resource.alter_detail_data_to_serialize(
request, pdf_resource_bundle)
return pdf_resource.create_response(request, pdf_resource_bundle)
class ImageResource(ModelResource):
user = fields.CharField('user__username')
revisions = fields.ToManyField(ImageRevisionResource, 'revisions')
subjects = fields.ListField()
imaging_telescopes = fields.ListField()
imaging_cameras = fields.ListField()
uploaded = fields.DateField('uploaded')
published = fields.DateField('published')
updated = fields.DateField('updated')
locations = fields.ToManyField(LocationResource, 'locations')
data_source = fields.CharField('data_source', null=True)
remote_source = fields.CharField('remote_source', null=True)
url_thumb = fields.CharField()
url_gallery = fields.CharField()
url_regular = fields.CharField()
url_hd = fields.CharField()
url_real = fields.CharField()
url_duckduckgo = fields.CharField()
url_duckduckgo_small = fields.CharField()
url_histogram = fields.CharField()
url_skyplot = fields.CharField()
is_solved = fields.BooleanField()
ra = fields.DecimalField()
dec = fields.DecimalField()
pixscale = fields.DecimalField()
orientation = fields.DecimalField()
radius = fields.DecimalField()
likes = fields.IntegerField()
bookmarks = fields.IntegerField()
comments = fields.IntegerField()
views = fields.IntegerField()
class Meta:
authentication = AppAuthentication()
queryset = Image.objects.filter(corrupted=False, is_wip=False)
fields = [
'id',
'hash',
'title',
'w',
'h',
'locations',
'data_source',
'remote_source',
'url_thumb',
'url_gallery',
'url_regular',
'url_hd',
'url_real',
'url_duckduckgo',
'url_duckduckgo_small',
'url_histogram',
'url_skyplot',
'uploaded',
'published',
'description',
'h',
'w',
'animated',
'link',
'link_to_fits',
'license',
# TODO: likes
'is_final',
'is_solved',
'ra',
'dec',
'pixscale',
'orientation',
'radius',
]
allowed_methods = ['get']
filtering = {
'title': ALL,
'description': ALL,
'is_solved': ALL,
'user': ALL_WITH_RELATIONS,
'uploaded': ALL,
'published': ALL,
'imaging_telescopes': ALL,
'imaging_cameras': ALL,
'w': ALL,
'h': ALL,
'data_source': ALL,
'remote_source': ALL,
}
ordering = ['uploaded']
def dehydrate_url_thumb(self, bundle):
return '%s/%s/0/rawthumb/thumb/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_gallery(self, bundle):
return '%s/%s/0/rawthumb/gallery/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_regular(self, bundle):
return '%s/%s/0/rawthumb/regular/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_hd(self, bundle):
return '%s/%s/0/rawthumb/hd/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_real(self, bundle):
return '%s/%s/0/rawthumb/real/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_duckduckgo(self, bundle):
return '%s/%s/0/rawthumb/duckduckgo/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_duckduckgo_small(self, bundle):
return '%s/%s/0/rawthumb/duckduckgo_small/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_histogram(self, bundle):
return '%s/%s/0/rawthumb/histogram/' % (settings.BASE_URL, bundle.obj.get_id())
def dehydrate_url_skyplot(self, bundle):
return bundle.obj.solution.skyplot_zoom1.url \
if bundle.obj.solution and bundle.obj.solution.skyplot_zoom1 \
else None
def dehydrate_is_solved(self, bundle):
return bundle.obj.solution != None
def dehydrate_subjects(self, bundle):
if bundle.obj.solution:
subjects = SolutionService(bundle.obj.solution).get_objects_in_field()
solar_system_main_subject = bundle.obj.solar_system_main_subject
ret = subjects
if solar_system_main_subject:
ret.append(ImageService(bundle.obj).get_solar_system_main_subject_label())
return ret
return []
def dehydrate_ra(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.ra
return None
def dehydrate_dec(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.dec
return None
def dehydrate_pixscale(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.pixscale
return None
def dehydrate_orientation(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.orientation
return None
def dehydrate_radius(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.radius
return None
def dehydrate_imaging_telescopes(self, bundle):
telescopes = bundle.obj.imaging_telescopes.all()
return [unicode(x) for x in telescopes]
def dehydrate_imaging_cameras(self, bundle):
cameras = bundle.obj.imaging_cameras.all()
return [unicode(x) for x in cameras]
def dehydrate_likes(self, bundle):
return ToggleProperty.objects.toggleproperties_for_object('like', bundle.obj).count()
def dehydrate_bookmarks(self, bundle):
return ToggleProperty.objects.toggleproperties_for_object('bookmark', bundle.obj).count()
def dehydrate_comments(self, bundle):
return bundle.obj.nested_comments.count()
def dehydrate_views(self, bundle):
try:
return HitCount.objects.get(
object_pk=bundle.obj.pk,
content_type=ContentType.objects.get_for_model(Image),
).hits
except (HitCount.DoesNotExist, HitCount.MultipleObjectsReturned):
return 0
def get_detail(self, request, **kwargs):
"""
Returns a single serialized resource.
Calls ``cached_obj_get/obj_get`` to provide the data, then handles that result
set and serializes it.
Should return a HttpResponse (200 OK).
"""
try:
obj = get_image_or_404(self._meta.queryset, kwargs.get("pk"))
except Http404:
return http.HttpNotFound()
bundle = self.build_bundle(obj=obj, request=request)
bundle = self.full_dehydrate(bundle)
bundle = self.alter_detail_data_to_serialize(request, bundle)
return self.create_response(request, bundle)
def build_filters(self, filters=None, ignore_bad_filters=False):
subjects = None
ids = None
user = None
if filters is None:
filters = {}
if 'subjects' in filters:
subjects = filters['subjects']
del filters['subjects']
if 'ids' in filters:
ids = filters['ids']
del filters['ids']
if 'user' in filters:
user = filters['user']
del filters['user']
orm_filters = super(ImageResource, self).build_filters(filters, ignore_bad_filters)
if subjects:
from astrobin_apps_platesolving.models import Solution
def fix_catalog(name):
capitalize = ('ngc', 'm', 'b', 'ic', 'ugc', 'pgc',)
if name.lower() in [x.lower() for x in capitalize]:
return name.upper() + ' '
remove = ('name',)
if name.lower() in [x.lower() for x in remove]:
return ''
return name + ' '
def fix_name(name):
import re
fix = re.compile('^(?P<catalog>M|NGC)(?P<name>\d+)', re.IGNORECASE)
m = fix.match(name)
if m:
return '%s%s' % (fix_catalog(m.group('catalog')), m.group('name'))
return name
r = r"\y{0}\y".format(fix_name(subjects))
qs = Solution.objects.filter(objects_in_field__iregex=r)
orm_filters['pk__in'] = [i.object_id for i in qs]
if ids:
orm_filters['pk__in'] = ids.split(',')
if user:
orm_filters['user__username'] = user
return orm_filters
class ImageRevisionResource(ModelResource):
image = fields.ForeignKey('astrobin.api.ImageResource', 'image')
url_thumb = fields.CharField()
url_gallery = fields.CharField()
url_regular = fields.CharField()
url_regular_sharpened = fields.CharField()
url_hd = fields.CharField()
url_hd_sharpened = fields.CharField()
url_real = fields.CharField()
url_duckduckgo = fields.CharField()
url_duckduckgo_small = fields.CharField()
url_histogram = fields.CharField()
url_skyplot = fields.CharField()
is_solved = fields.BooleanField()
ra = fields.DecimalField()
dec = fields.DecimalField()
pixscale = fields.DecimalField()
orientation = fields.DecimalField()
radius = fields.DecimalField()
class Meta:
authentication = AppAuthentication()
queryset = ImageRevision.objects.filter(image__is_wip=False, corrupted=False)
fields = [
'uploaded',
'w',
'h',
'url_thumb',
'url_gallery',
'url_regular',
'url_regular_sharpened',
'url_hd',
'url_hd_sharpened',
'url_real',
'url_duckduckgo',
'url_duckduckgo_small',
'url_histogram',
'url_skyplot',
'is_final',
'is_solved',
'ra',
'dec',
'pixscale',
'orientation',
'radius',
]
allowed_methods = ['get']
def dehydrate_url_thumb(self, bundle):
return '%s/%s/%s/rawthumb/thumb/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_gallery(self, bundle):
return '%s/%s/%s/rawthumb/gallery/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_regular(self, bundle):
return '%s/%s/%s/rawthumb/regular/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_regular_sharpened(self, bundle):
return '%s/%s/%s/rawthumb/regular_sharpened/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_hd(self, bundle):
return '%s/%s/%s/rawthumb/hd/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_hd_sharpened(self, bundle):
return '%s/%s/%s/rawthumb/hd_sharpened/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_real(self, bundle):
return '%s/%s/%s/rawthumb/real/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_duckduckgo(self, bundle):
return '%s/%s/%s/rawthumb/duckduckgo/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_duckduckgo_small(self, bundle):
return '%s/%s/%s/rawthumb/duckduckgo_small/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_histogram(self, bundle):
return '%s/%s/%s/rawthumb/histogram/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_skyplot(self, bundle):
return bundle.obj.solution.skyplot_zoom1.url \
if bundle.obj.solution and bundle.obj.solution.skyplot_zoom1 \
else None
def dehydrate_is_solved(self, bundle):
return bundle.obj.solution != None
def dehydrate_ra(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.ra
return None
def dehydrate_dec(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.dec
return None
def dehydrate_pixscale(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.pixscale
return None
def dehydrate_orientation(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.orientation
return None
def dehydrate_radius(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.radius
return None
class SimilarityResource(MoleculeResource):
similarity = fields.DecimalField('similarity')
class Meta(MoleculeResource.Meta):
queryset = MoleculeDictionary.objects.all()
resource_name = 'similarity'
required_params = {'api_dispatch_detail': ['smiles', 'similarity']}
# ----------------------------------------------------------------------------------------------------------------------
def base_urls(self):
return [
url(r"^(?P<resource_name>%s)%s$" % (
self._meta.resource_name,
trailing_slash(),
),
self.wrap_view('dispatch_list'),
name="dispatch_list"),
url(r"^(?P<resource_name>%s)\.(?P<format>\w+)$" %
self._meta.resource_name,
self.wrap_view('dispatch_list'),
name="dispatch_list"),
url(r"^(?P<resource_name>%s)/schema%s$" % (
self._meta.resource_name,
trailing_slash(),
),
self.wrap_view('get_schema'),
name="api_get_schema"),
url(r"^(?P<resource_name>%s)/schema\.(?P<format>\w+)$" %
self._meta.resource_name,
self.wrap_view('get_schema'),
name="api_get_schema"),
url(r"^(?P<resource_name>%s)/datatables\.(?P<format>\w+)$" %
self._meta.resource_name,
self.wrap_view('get_datatables'),
name="api_get_datatables"),
url(r"^(?P<resource_name>%s)/(?P<chembl_id>[Cc][Hh][Ee][Mm][Bb][Ll]\d[\d]*)/(?P<similarity>\d[\d]*)%s$"
% (
self._meta.resource_name,
trailing_slash(),
),
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>%s)/(?P<chembl_id>[Cc][Hh][Ee][Mm][Bb][Ll]\d[\d]*)/(?P<similarity>\d[\d]*)\.(?P<format>\w+)$"
% self._meta.resource_name,
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>%s)/(?P<standard_inchi_key>[A-Z]{14}-[A-Z]{10}-[A-Z])/(?P<similarity>\d[\d]*)%s$"
% (
self._meta.resource_name,
trailing_slash(),
),
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>%s)/(?P<standard_inchi_key>[A-Z]{14}-[A-Z]{10}-[A-Z])/(?P<similarity>\d[\d]*)\.(?P<format>\w+)$"
% self._meta.resource_name,
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>%s)/(?P<smiles>[^jx]+)/(?P<similarity>\d[\d]*)\.(?P<format>json|xml|sdf|mol)$"
% self._meta.resource_name,
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>%s)/(?P<smiles>[^jx]+)/(?P<similarity>\d[\d]*)%s$"
% (
self._meta.resource_name,
trailing_slash(),
),
self.wrap_view('dispatch_list'),
name="api_dispatch_detail"),
]
# ----------------------------------------------------------------------------------------------------------------------
def prepend_urls(self):
return []
# ----------------------------------------------------------------------------------------------------------------------
def obj_get_list(self, bundle, **kwargs):
smiles = kwargs.pop('smiles', None)
std_inchi_key = kwargs.pop('standard_inchi_key', None)
chembl_id = kwargs.pop('chembl_id', None)
if not smiles and not std_inchi_key and not chembl_id:
raise BadRequest("Structure or identifier required.")
similarity = kwargs.pop('similarity')
if not smiles:
if chembl_id:
mol_filters = {'chembl_id': chembl_id}
else:
mol_filters = {
'compoundstructures__standard_inchi_key': std_inchi_key
}
try:
objects = self.apply_filters(
bundle.request, mol_filters).values_list(
'compoundstructures__canonical_smiles', flat=True)
stringified_kwargs = ', '.join(
["%s=%s" % (k, v) for k, v in mol_filters.items()])
length = len(objects)
if length <= 0:
raise ObjectDoesNotExist(
"Couldn't find an instance of '%s' which matched '%s'."
%
(self._meta.object_class.__name__, stringified_kwargs))
elif length > 1:
raise MultipleObjectsReturned(
"More than '%s' matched '%s'." %
(self._meta.object_class.__name__, stringified_kwargs))
smiles = objects[0]
if not smiles:
raise ObjectDoesNotExist(
"No chemical structure defined for identifier {0}".
format(chembl_id or std_inchi_key))
except TypeError as e:
if e.message.startswith('Related Field has invalid lookup:'):
raise BadRequest(e.message)
else:
raise e
except ValueError:
raise BadRequest(
"Invalid resource lookup data provided (mismatched type).")
if not isinstance(smiles, basestring):
raise BadRequest(
"Similarity can only handle a single chemical structure identified by SMILES, "
"InChiKey or ChEMBL ID.")
similar = CompoundMols.objects.similar_to(
smiles, similarity).values_list('molecule_id', 'similarity')
similarity_map = None
try:
similarity_map = OrderedDict(sorted(similar, key=lambda x: x[1]))
except DatabaseError as e:
self._handle_database_error(e, bundle.request, {'smiles': smiles})
filters = {}
standard_filters, distinct = self.build_filters(filters=kwargs)
filters.update(standard_filters)
try:
only = filters.get('only')
if only:
del filters['only']
if isinstance(only, basestring):
only = only.split(',')
only = list(set(list_flatten(only)))
objects = self.get_object_list(bundle.request).filter(
pk__in=[sim[0] for sim in similar]).filter(**filters)
if chembl_id:
objects = objects.exclude(chembl_id=chembl_id)
if only:
objects = objects.only(*[
self.fields[field].attribute for field in only
if field in self.fields and field != 'similarity'
])
except ValueError:
raise BadRequest(
"Invalid resource lookup data provided (mismatched type).")
if distinct:
objects = objects.distinct()
objects = self.apply_sorting(objects, similarity_map, options=kwargs)
return self.authorized_read_list(objects, bundle)
# ----------------------------------------------------------------------------------------------------------------------
def cached_obj_get_list(self, bundle, **kwargs):
kwargs = self.unquote_args(kwargs)
return self.detail_cache_handler(self.obj_get_list)(bundle, 'list',
**kwargs)
# ----------------------------------------------------------------------------------------------------------------------
def get_list_impl(self, request, base_bundle, **kwargs):
return self.serialise_list(
self.list_cache_handler(self.cached_obj_get_list),
for_list=True,
for_search=False)(request, base_bundle,
**self.remove_api_resource_names(kwargs))
# ----------------------------------------------------------------------------------------------------------------------
def list_cache_handler(self, f):
def handle(bundle, **kwargs):
"""
Returns a serialized list of resources.
Calls ``obj_get_list`` to provide the data, then handles that result
set and serializes it.
Should return a HttpResponse (200 OK).
"""
request = bundle.request
if not kwargs.get('similarity'):
raise BadRequest("Similarity parameter is required.")
original_similarity = kwargs['similarity']
try:
kwargs['similarity'] = int(
re.search(r'^\d+', str(kwargs.get('similarity',
"0"))).group())
similarity = kwargs.get('similarity', 0)
if similarity < 70 or similarity > 100:
raise BadRequest("Invalid Similarity Score supplied: %s" %
original_similarity)
except (ValueError, AttributeError):
raise BadRequest("Invalid Similarity Score supplied: %s" %
original_similarity)
objects, in_cache = f(bundle=bundle,
**self.remove_api_resource_names(kwargs))
try:
limit = int(
re.search(
r'^\d+',
str(
kwargs.pop(
'limit',
getattr(settings, 'API_LIMIT_PER_PAGE',
"20")))).group())
except (ValueError, AttributeError):
limit = int(getattr(settings, 'API_LIMIT_PER_PAGE', 20))
try:
offset = int(
re.search(r'^\d+', str(kwargs.pop('offset', "0"))).group())
except (ValueError, AttributeError):
offset = 0
paginator_info = {'limit': limit, 'offset': offset}
paginator = self._meta.paginator_class(
paginator_info,
objects,
resource_uri=self.get_resource_uri(),
limit=self._meta.limit,
max_limit=self._meta.max_limit,
collection_name=self._meta.collection_name,
method=request.method,
params=self.remove_api_resource_names(kwargs),
format=request.format)
to_be_serialized = paginator.page()
return to_be_serialized, in_cache
return handle
# ----------------------------------------------------------------------------------------------------------------------
def apply_sorting(self, obj_list, similarity_map, options=None):
"""
Given a dictionary of options, apply some ORM-level sorting to the
provided ``QuerySet``.
Looks for the ``order_by`` key and handles either ascending (just the
field name) or descending (the field name with a ``-`` in front).
The field name should be the resource field, **NOT** model field.
"""
if options is None:
options = {}
parameter_name = 'order_by'
if 'order_by' not in options:
if 'sort_by' not in options:
# Nothing to alter the order. Return what we've got.
options['order_by'] = '-similarity'
else:
warnings.warn(
"'sort_by' is a deprecated parameter. Please use 'order_by' instead."
)
parameter_name = 'sort_by'
order_by_args = []
if hasattr(options, 'getlist'):
order_bits = options.getlist(parameter_name)
else:
order_bits = options.get(parameter_name)
if not isinstance(order_bits, (list, tuple)):
order_bits = [order_bits]
if (order_bits.index('similarity') == 0 if 'similarity' in order_bits else False) or \
(order_bits.index('-similarity') == 0 if '-similarity' in order_bits else False):
obj_list = self.prefetch_related(obj_list, **options)
for obj in obj_list:
sim = similarity_map[obj.molregno]
obj.similarity = sim
similarity_map[obj.molregno] = obj
vals = [
sim for sim in similarity_map.values()
if type(sim) == MoleculeDictionary
]
return list(
reversed(vals)) if '-similarity' in order_bits else vals
else:
for order_by in order_bits:
order_by_bits = order_by.split(LOOKUP_SEP)
field_name = order_by_bits[0]
order = ''
if order_by_bits[0].startswith('-'):
field_name = order_by_bits[0][1:]
order = '-'
if field_name not in self.fields:
# It's not a field we know about. Move along citizen.
raise InvalidSortError(
"No matching '%s' field for ordering on." % field_name)
if field_name not in self._meta.ordering:
raise InvalidSortError(
"The '%s' field does not allow ordering." % field_name)
if self.fields[field_name].attribute is None:
raise InvalidSortError(
"The '%s' field has no 'attribute' for ordering with."
% field_name)
order_by_args.append(
"%s%s" %
(order,
LOOKUP_SEP.join([self.fields[field_name].attribute] +
order_by_bits[1:])))
obj_list = self.prefetch_related(obj_list.order_by(*order_by_args),
**options)
for obj in obj_list:
obj.similarity = similarity_map[obj.molregno]
return obj_list
# ----------------------------------------------------------------------------------------------------------------------
def get_resource_uri(self, bundle_or_obj=None, url_name='dispatch_list'):
if bundle_or_obj is not None:
url_name = 'dispatch_detail'
try:
return self._build_reverse_url(
url_name, kwargs=self.resource_uri_kwargs(bundle_or_obj))
except NoReverseMatch:
return ''
# ----------------------------------------------------------------------------------------------------------------------
def remove_api_resource_names(self, kwargs):
return super(MoleculeResource,
self).remove_api_resource_names(self.decode_plus(kwargs))
# ----------------------------------------------------------------------------------------------------------------------
def _get_cache_args(self, *args, **kwargs):
cache_ordered_dict = super(SimilarityResource,
self)._get_cache_args(*args, **kwargs)
pk = kwargs.get('smiles', None)
if not pk:
pk = kwargs.get('standard_inchi_key', None)
if not pk:
pk = kwargs.get('chembl_id', None)
similarity = kwargs.get('similarity', 0)
cache_ordered_dict['limit'] = pk
cache_ordered_dict['offset'] = str(similarity)
return cache_ordered_dict
class PoliticalFileResource(ExpandedModelResource):
class Meta:
authentication = LocksmithKeyAuthentication()
serializer = ExpandedSerializer()
queryset = PoliticalBuy.objects.all()
limit = API_LIMIT_PER_PAGE
max_limit = API_MAX_RESULTS_PER_PAGE
resource_name = 'politicalfile'
api_name = API_NAME
allowed_methods = ['get']
cache = SimpleCache()
paginator_class = Paginator
fields = ('uuid_key', 'advertiser', 'contract_number', \
'contract_start_date', 'contract_end_date', \
'nielsen_dma', 'community_state', \
'candidate_type', 'upload_time', 'updated_at')
ordering = ('updated_at', 'contract_start_date', 'contract_end_date')
filtering = {
"nielsen_dma_id": ('exact', ),
"community_state": ('exact', ),
"contract_start_date": ('exact', 'lte', 'gte'),
"contract_end_date": ('exact', 'lte', 'gte'),
}
description = fields.CharField(
help_text='Description calculated from parsed and entered data')
source_file_uri = fields.CharField()
nielsen_dma_id = fields.IntegerField(attribute='dma_id',
null=True,
blank=True)
advertiser = fields.CharField(
help_text=
'Advertiser name: should be a political entity (most likely a committee)'
)
broadcasters = fields.ListField(
help_text='List of broadcaster station callsigns')
doc_status = fields.CharField()
total_spent = fields.DecimalField()
num_spots = fields.IntegerField(attribute='num_spots_raw',
null=True,
blank=True)
doc_source = fields.CharField()
def dehydrate_description(self, bundle):
return bundle.obj.name()
def dehydrate_source_file_uri(self, bundle):
if bundle.obj.documentcloud_doc:
return bundle.obj.documentcloud_doc.get_absolute_url()
elif bundle.obj.related_FCC_file:
return u'{0}'.format(
urlquote(bundle.obj.related_FCC_file.raw_url, ':/'))
else:
return None
def dehydrate_advertiser(self, bundle):
return bundle.obj.advertiser or None
def dehydrate_contract_number(self, bundle):
return bundle.obj.contract_number or None
def dehydrate_broadcasters(self, bundle):
return bundle.obj.broadcasters_callsign_list()
def dehydrate_doc_status(self, bundle):
return bundle.obj.doc_status()
def dehydrate_total_spent(self, bundle):
return bundle.obj.total_spent()
def dehydrate_doc_source(self, bundle):
return bundle.obj.doc_source()
def base_urls(self):
"""
***
Override:
- exclude pk resources
***
"The standard URLs this ``Resource`` should respond to."
"""
# Due to the way Django parses URLs, ``get_multiple`` won't work without
# a trailing slash.
return [
url(r"^(?P<resource_name>{0}){1}$".format(self._meta.resource_name,
trailing_slash()),
self.wrap_view('dispatch_list'),
name="api_dispatch_list"),
url(r"^(?P<resource_name>{0})/{1}{2}$".format(
self._meta.resource_name, uuid_re_str, trailing_slash()),
self.wrap_view('dispatch_detail'),
name="api_dispatch_detail"),
url(r"^(?P<resource_name>{0})/schema{1}$".format(
self._meta.resource_name, trailing_slash()),
self.wrap_view('get_schema'),
name="api_get_schema"),
]
def get_resource_uri(self, bundle_or_obj):
kwargs = {
'resource_name': self._meta.resource_name,
'api_name': self._meta.api_name
}
if isinstance(bundle_or_obj, Bundle):
kwargs['uuid_key'] = bundle_or_obj.obj.uuid_key
else:
kwargs['uuid_key'] = bundle_or_obj.uuid_key
return self._build_reverse_url("api_dispatch_detail", kwargs=kwargs)
def get_list(self, request, **kwargs):
"""
***
Override:
- Implements max_limit
***
Returns a serialized list of resources.
Calls ``obj_get_list`` to provide the data, then handles that result
set and serializes it.
Should return a HttpResponse (200 OK).
"""
# TODO: Uncached for now. Invalidation that works for everyone may be
# impossible.
objects = self.obj_get_list(request=request,
**self.remove_api_resource_names(kwargs))
sorted_objects = self.apply_sorting(objects, options=request.GET)
req_data = request.GET.copy()
limit = int(req_data.get('limit', self._meta.limit))
if limit > self._meta.max_limit or limit is 0:
limit = self._meta.max_limit
req_data['limit'] = unicode(limit)
paginator = self._meta.paginator_class(
req_data,
sorted_objects,
resource_uri=self.get_resource_list_uri(),
limit=limit)
to_be_serialized = paginator.page()
# Dehydrate the bundles in preparation for serialization.
bundles = [
self.build_bundle(obj=obj, request=request)
for obj in to_be_serialized['objects']
]
to_be_serialized['objects'] = [
self.full_dehydrate(bundle) for bundle in bundles
]
to_be_serialized = self.alter_list_data_to_serialize(
request, to_be_serialized)
return self.create_response(request, to_be_serialized)
def build_filters(self, filters=None):
if filters is None:
filters = {}
orm_filters = super(PoliticalFileResource, self).build_filters(filters)
if "q" in filters:
sqs = SearchQuerySet().auto_query(filters['q'])
orm_filters["pk__in"] = [i.pk for i in sqs]
return orm_filters
class InvoiceResource(InvoiceBaseResource):
state = base_fields.CharField(
attribute='state',
readonly=True,
help_text=HELP_TEXT['invoice']['state']
)
paid = base_fields.DecimalField(
attribute='paid',
readonly=True,
help_text=HELP_TEXT['invoice']['paid']
)
balance = base_fields.DecimalField(
attribute='balance',
readonly=True,
help_text=HELP_TEXT['invoice']['balance']
)
has_temporary_reference = base_fields.BooleanField(
attribute='has_temporary_reference',
readonly=True,
help_text=HELP_TEXT['invoice']['has_temporary_reference']
)
related_to = fields.ReferenceField(
to='invoicing.api.resources.QuotationResource',
attribute='related_to',
readonly=True,
null=True,
help_text=HELP_TEXT['invoice']['related_to']
)
payments = fields.ReferencedListField(
of='invoicing.api.resources.PaymentResource',
attribute='payments',
readonly=True,
null=True,
blank=True,
help_text=HELP_TEXT['invoice']['payments']
)
class Meta(InvoiceBaseResource.Meta):
queryset = Invoice.objects.all()
detail_specific_methods = ('cancel', 'mark_as_registered')
def prepend_urls(self):
"""Add urls for resources actions."""
urls = super(InvoiceResource, self).prepend_urls()
urls.extend((
url(r'^(?P<resource_name>%s)/(?P<pk>\w[\w/-]*)/cancel%s$' % (self._meta.resource_name, trailing_slash()), self.wrap_view('invoice_cancel'), name='api_invoice_cancel'),
))
return urls
def invoice_cancel(self, request, **kwargs):
"""Cancel the invoice and returns the associated credit note."""
from invoicing.api.resources.credit_note import CreditNoteResource
self.method_check(request, allowed=['put'])
self.is_authenticated(request)
self.throttle_check(request)
try:
bundle = self.build_bundle(request=request)
obj = self.cached_obj_get(bundle=bundle, **self.remove_api_resource_names(kwargs))
except ObjectDoesNotExist:
return http.HttpNotFound()
try:
credit_note = obj.cancel(request.vosae_user)
invoicing_signals.post_cancel_invoice.send(obj.__class__, issuer=request.vosae_user, document=obj, credit_note=credit_note)
credit_note_resource = CreditNoteResource()
credit_note_resource_bundle = credit_note_resource.build_bundle(obj=credit_note, request=request)
except NotCancelableInvoice as e:
raise BadRequest(e)
self.log_throttled_access(request)
to_be_serialized = {
'credit_note_uri': credit_note_resource.get_resource_uri(credit_note_resource_bundle)
}
to_be_serialized = self.alter_list_data_to_serialize(request, to_be_serialized)
return self.create_response(request, to_be_serialized)
def dehydrate_related_to(self, bundle):
from invoicing.api.resources import QuotationResource, PurchaseOrderResource
try:
if bundle.obj.related_to.is_quotation():
resource = QuotationResource()
elif bundle.obj.related_to.is_purchase_order():
resource = PurchaseOrderResource()
resource_bundle = resource.build_bundle(obj=bundle.obj.related_to, request=bundle.request)
return resource.get_resource_uri(resource_bundle)
except:
return
class ImageResource(ModelResource):
user = fields.CharField('user__username')
revisions = fields.ToManyField(ImageRevisionResource, 'revisions')
subjects = fields.ListField()
imaging_telescopes = fields.ListField()
imaging_cameras = fields.ListField()
uploaded = fields.DateField('uploaded')
published = fields.DateField('published')
updated = fields.DateField('updated')
locations = fields.ToManyField(LocationResource, 'locations')
url_thumb = fields.CharField()
url_gallery = fields.CharField()
url_regular = fields.CharField()
url_hd = fields.CharField()
url_real = fields.CharField()
url_duckduckgo = fields.CharField()
url_duckduckgo_small = fields.CharField()
is_solved = fields.BooleanField()
ra = fields.DecimalField()
dec = fields.DecimalField()
pixscale = fields.DecimalField()
orientation = fields.DecimalField()
radius = fields.DecimalField()
class Meta:
authentication = AppAuthentication()
queryset = Image.objects.all()
fields = [
'id',
'title',
'w',
'h',
'locations',
'url_thumb',
'url_gallery',
'url_regular',
'url_hd',
'url_real',
'url_duckduckgo',
'url_duckduckgo_small',
'uploaded',
'published',
'description',
'h',
'w',
'animated',
'link',
'link_to_fits',
'license',
# TODO: likes
'is_final',
'is_solved',
'ra',
'dec',
'pixscale',
'orientation',
'radius',
]
allowed_methods = ['get']
filtering = {
'title': ALL,
'description': ALL,
'is_solved': ALL,
'user': ALL_WITH_RELATIONS,
'uploaded': ALL,
'published': ALL,
'imaging_telescopes': ALL,
'imaging_cameras': ALL,
'w': ALL,
'h': ALL,
}
ordering = ['uploaded']
def dehydrate_url_thumb(self, bundle):
return '%s/%d/0/rawthumb/thumb/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_gallery(self, bundle):
return '%s/%d/0/rawthumb/gallery/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_regular(self, bundle):
return '%s/%d/0/rawthumb/regular/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_hd(self, bundle):
return '%s/%d/0/rawthumb/hd/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_real(self, bundle):
return '%s/%d/0/rawthumb/real/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_duckduckgo(self, bundle):
return '%s/%d/0/rawthumb/duckduckgo/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_url_duckduckgo_small(self, bundle):
return '%s/%d/0/rawthumb/duckduckgo_small/' % (settings.BASE_URL, bundle.obj.id)
def dehydrate_is_solved(self, bundle):
return bundle.obj.solution != None
def dehydrate_subjects(self, bundle):
if bundle.obj.solution:
subjects = bundle.obj.solution.objects_in_field
if subjects:
subjects = subjects.split(',')
else:
subjects = []
ssms = bundle.obj.solar_system_main_subject
ret = subjects
if ssms:
ret.append(SOLAR_SYSTEM_SUBJECT_CHOICES[ssms][1])
return ret
return []
def dehydrate_ra(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.ra
return None
def dehydrate_dec(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.dec
return None
def dehydrate_pixscale(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.pixscale
return None
def dehydrate_orientation(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.orientation
return None
def dehydrate_radius(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.radius
return None
def dehydrate_imaging_telescopes(self, bundle):
telescopes = bundle.obj.imaging_telescopes.all()
return [unicode(x) for x in telescopes]
def dehydrate_imaging_cameras(self, bundle):
cameras = bundle.obj.imaging_cameras.all()
return [unicode(x) for x in cameras]
def build_filters(self, filters = None, ignore_bad_filters = False):
subjects = None
ids = None
if filters is None:
filters = {}
if 'subjects' in filters:
subjects = filters['subjects']
del filters['subjects']
if 'ids' in filters:
ids = filters['ids']
del filters['ids']
orm_filters = super(ImageResource, self).build_filters(filters, ignore_bad_filters)
if subjects:
from astrobin_apps_platesolving.models import Solution
def fix_catalog(name):
capitalize = ('ngc', 'm', 'b', 'ic', 'ugc', 'pgc',)
if name.lower() in [x.lower() for x in capitalize]:
return name.upper() + ' '
remove = ('name',)
if name.lower() in [x.lower() for x in remove]:
return ''
return name + ' '
def fix_name(name):
import re
fix = re.compile('^(?P<catalog>M|NGC)(?P<name>\d+)', re.IGNORECASE)
m = fix.match(name)
if m:
return '%s%s' % (fix_catalog(m.group('catalog')), m.group('name'))
return name
r = r"\y{0}\y".format(fix_name(subjects))
qs = Solution.objects.filter(objects_in_field__iregex = r)
orm_filters['pk__in'] = [i.object_id for i in qs]
if ids:
orm_filters['pk__in'] = ids.split(',')
return orm_filters
class ImageRevisionResource(ModelResource):
image = fields.ForeignKey('astrobin.api.ImageResource', 'image')
url_thumb = fields.CharField()
url_gallery = fields.CharField()
url_regular = fields.CharField()
url_regular_sharpened = fields.CharField()
url_hd = fields.CharField()
url_hd_sharpened = fields.CharField()
url_real = fields.CharField()
url_duckduckgo = fields.CharField()
url_duckduckgo_small = fields.CharField()
url_histogram = fields.CharField()
url_skyplot = fields.CharField()
url_solution = fields.CharField()
url_advanced_solution = fields.CharField()
is_solved = fields.BooleanField()
solution_status = fields.CharField()
ra = fields.DecimalField()
dec = fields.DecimalField()
pixscale = fields.DecimalField()
orientation = fields.DecimalField()
radius = fields.DecimalField()
class Meta:
authentication = AppAuthentication()
queryset = ImageRevision.objects.filter(image__is_wip=False, corrupted=False)
fields = [
'id',
'uploaded',
'w',
'h',
'label',
'title',
'description',
'url_thumb',
'url_gallery',
'url_regular',
'url_regular_sharpened',
'url_hd',
'url_hd_sharpened',
'url_real',
'url_duckduckgo',
'url_duckduckgo_small',
'url_histogram',
'url_skyplot',
'url_solution',
'url_advanced_solution',
'is_final',
'is_solved',
'solution_status',
'ra',
'dec',
'pixscale',
'orientation',
'radius',
]
allowed_methods = ['get']
def dehydrate_url_thumb(self, bundle):
return '%s/%s/%s/rawthumb/thumb/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_gallery(self, bundle):
return '%s/%s/%s/rawthumb/gallery/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_regular(self, bundle):
return '%s/%s/%s/rawthumb/regular/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_regular_sharpened(self, bundle):
return '%s/%s/%s/rawthumb/regular_sharpened/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_hd(self, bundle):
return '%s/%s/%s/rawthumb/hd/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_hd_sharpened(self, bundle):
return '%s/%s/%s/rawthumb/hd_sharpened/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_real(self, bundle):
return '%s/%s/%s/rawthumb/real/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_duckduckgo(self, bundle):
return '%s/%s/%s/rawthumb/duckduckgo/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_duckduckgo_small(self, bundle):
return '%s/%s/%s/rawthumb/duckduckgo_small/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_histogram(self, bundle):
return '%s/%s/%s/rawthumb/histogram/' % (settings.BASE_URL, bundle.obj.image.get_id(), bundle.obj.label)
def dehydrate_url_skyplot(self, bundle):
return bundle.obj.solution.skyplot_zoom1.url \
if bundle.obj.solution and bundle.obj.solution.skyplot_zoom1 \
else None
def dehydrate_url_solution(self, bundle):
return bundle.obj.solution.image_file.url \
if bundle.obj.solution and bundle.obj.solution.image_file \
else None
def dehydrate_url_advanced_solution(self, bundle):
return bundle.obj.solution.pixinsight_svg_annotation_hd.url \
if bundle.obj.solution and bundle.obj.solution.pixinsight_svg_annotation_hd \
else None
def dehydrate_is_solved(self, bundle):
solution = bundle.obj.solution
return solution != None and solution.status >= Solver.SUCCESS
def dehydrate_solution_status(self, bundle):
solution = bundle.obj.solution
if solution is None or solution.status == Solver.MISSING:
return "MISSING"
if solution.status == Solver.PENDING:
return "PENDING"
if solution.status == Solver.FAILED:
return "FAILED"
if solution.status == Solver.SUCCESS:
return "SUCCESS"
if solution.status == Solver.ADVANCED_PENDING:
return "ADVANCED_PENDING"
if solution.status == Solver.ADVANCED_FAILED:
return "ADVANCED_FAILED"
if solution.status == Solver.ADVANCED_SUCCESS:
return "ADVANCED_SUCCESS"
def dehydrate_ra(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.ra
return None
def dehydrate_dec(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.dec
return None
def dehydrate_pixscale(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.pixscale
return None
def dehydrate_orientation(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.orientation
return None
def dehydrate_radius(self, bundle):
if bundle.obj.solution:
return bundle.obj.solution.radius
return None
