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