def get_context_data(self, **kwargs):
context = super(DashboardView, self).get_context_data(**kwargs)
context['list_fournisseur'] = self.model.objects.values(
'lignes__produit__fournis',
'lignes__produit__fournis__user__last_name',
'lignes__produit__fournis__user__first_name').annotate(
chiffre_affaire=Sum(
ExpressionWrapper(F('lignes__qte') *
F('lignes__produit__prix'),
output_field=fields.FloatField())))
print(context['list_fournisseur'])
context['table_fournisseur'] = ChiffreFournisseurTab(
context['list_fournisseur'])
context['list_client'] = self.model.objects.all().values(
'client', 'client__user__last_name',
'client__user__first_name').annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('lignes__qte') *
F('lignes__produit__prix'),
output_field=fields.FloatField()))).order_by(
'-chiffre_affaire')
context['table_client'] = ChiffreClientTab(context['list_client'])
print(context['list_client'])
context['chart_jour'] = JourChart()
context['chart_categorie'] = CategorieChart()
return context
def _add_quality_relevance(self, qs):
"""Annotates query with relevance based on quality score.
It is calculated by a formula:
R = log(Q + 1) + 0.1 * v
Where:
R - Relevance;
Q - Quality score (0 to 5);
v - 1 if collection belongs to a partner namespace, otherwise 0.
"""
quality_rank_expr = (
Func(Coalesce(F('latest_version__quality_score'), 0) + 1,
function='log') * CONTENT_SCORE_MULTIPLIER)
vendor_rank_expr = Case(
When(namespace__is_vendor=True, then=Value(VENDOR_RANK)),
When(namespace__is_vendor=False, then=Value(0)),
)
relevance_expr = F('quality_rank') + F('vendor_rank')
return qs.annotate(
quality_rank=Expr(quality_rank_expr,
output_field=db_fields.FloatField()),
vendor_rank=Expr(vendor_rank_expr,
output_field=db_fields.FloatField()),
relevance=Expr(relevance_expr,
output_field=db_fields.FloatField()),
)
def get_queryset(self):
active = Count("optionwheel", filter=Q(optionwheel__is_active=True))
completed = Count("optionwheel",
filter=Q(optionwheel__is_active=False))
profit = Sum(F("optionwheel__total_profit") *
F("optionwheel__quantity"),
filter=Q(optionwheel__is_active=False),
output_field=fields.DecimalField())
collateral = Sum(F("optionwheel__collatoral") *
F("optionwheel__quantity"),
filter=Q(optionwheel__is_active=False),
output_field=fields.DecimalField())
total_wheels = Sum(F("optionwheel__quantity"),
filter=Q(optionwheel__is_active=False))
total_days_active_weighted_by_collateral = Sum(
F("optionwheel__total_days_active") * F("optionwheel__quantity") *
F("optionwheel__collatoral"),
filter=Q(optionwheel__is_active=False))
average_days = Cast(total_days_active_weighted_by_collateral,
fields.FloatField()) / Cast(
collateral, fields.FloatField())
annualized_rate_of_return = Power(
1 + profit / collateral,
BUSINESS_DAYS_IN_YEAR / Coalesce(average_days, 252))
users = User.objects.annotate(
active=active,
completed=completed,
profit=Round(100 * Coalesce(profit, 0)),
collateral=Round(100 * Coalesce(collateral, 0)),
return_percentage=Coalesce(profit / collateral, 0),
total_wheels=Coalesce(total_wheels, 0),
average_days=Coalesce(average_days, 0),
annualized_rate_of_return=Coalesce(annualized_rate_of_return, 0),
)
return users
class Game(models.Model):
guid = fields.UUIDField(primary_key=True)
n_cells = fields.PositiveIntegerField()
cell_area = fields.FloatField()
temperature = fields.FloatField(blank=True, null=True)
months_elapsed = fields.PositiveIntegerField(blank=True, null=True)
arrays = models.FileField(blank=True, null=True, upload_to=arrays_upload_location)
def _front_page(
paging_size=settings.PAGING_SIZE,
page=0,
add_filter={},
add_q=[],
as_of=None,
days_back=50,
):
# TODO: weighting https://medium.com/hacking-and-gonzo/how-hacker-news-ranking-algorithm-works-1d9b0cf2c08d
# (P-1) / (T+2)^G
if as_of is None:
now = timezone.now()
else:
now = as_of
if connection.vendor == "postgresql":
now_value = Value(now, output_field=fields.DateTimeField())
submission_age_float = ExpressionWrapper(
(now_value - F("created_at")), output_field=fields.DurationField())
submission_age_hours = ExpressionWrapper(
Extract(F("tf"), "epoch") / 60 / 60 + 2.1,
output_field=fields.FloatField())
real_p = ExpressionWrapper(F("points") - 1,
output_field=fields.FloatField())
formula = ExpressionWrapper(F("p") / (Power(F("tfh"), F("g")) + 0.001),
output_field=fields.FloatField())
return (Story.objects.select_related("user").filter(
duplicate_of__isnull=True).filter(points__gte=1).filter(
created_at__gte=now -
datetime.timedelta(days=days_back)).filter(
created_at__lte=now).filter(**add_filter).annotate(
tf=submission_age_float).
annotate(tfh=submission_age_hours).annotate(p=real_p).annotate(
g=Value(1.8, output_field=fields.FloatField())).annotate(
formula=formula).order_by("-formula")[(
page * paging_size):(page + 1) * (paging_size)])
elif connection.vendor == "sqlite":
now_value = Value(now, output_field=fields.DateTimeField())
submission_age_float = ExpressionWrapper(
(now_value - F("created_at")), output_field=fields.FloatField())
submission_age_hours = ExpressionWrapper(
F("tf") / 60 / 60 / 1000000 + 2.1,
output_field=fields.FloatField())
real_p = ExpressionWrapper(F("points") - 1,
output_field=fields.FloatField())
formula = ExpressionWrapper(F("p") / (Power(F("tfh"), F("g")) + 0.001),
output_field=fields.FloatField())
return (Story.objects.select_related("user").filter(
duplicate_of__isnull=True).filter(points__gte=1).filter(
created_at__gte=now -
datetime.timedelta(days=days_back)).filter(
created_at__lte=now).filter(**add_filter).annotate(
tf=submission_age_float).
annotate(tfh=submission_age_hours).annotate(p=real_p).annotate(
g=Value(1.8, output_field=fields.FloatField())).annotate(
formula=formula).order_by("-formula")[(
page * paging_size):(page + 1) * (paging_size)])
else:
raise NotImplementedError(
"No frontpage magic for database engine %s implemented" %
(connection.vendor))
def add_relevance(queryset):
c = 'repository__community_score'
d = 'repository__download_count'
# ln((MOD*c + MIN) * d + 1)
# where c = community_score and d = download_count
# We're using the community_score as a modifier to the download count
# instead of just allocating a certain number of points based on the
# score. The reason for this is that the download score is
# a logaritmic scale so adding a fixed number of points ended up
# boosting scores way too much for content with low numbers of
# downloads. This system allows for the weight of the community score
# to scale with the number of downloads
download_count_ln_expr = Func(
(((Coalesce(F(c), 0) * COMMUNITY_SCORE_MODIFIER) +
COMMUNITY_SCORE_MODIFIER_MIN)
* F(d)) + 1,
function='ln'
)
download_rank_expr = (
F('download_count_ln')
/ (1 + F('download_count_ln'))
* DOWNLOAD_RANK_MULTIPLIER
)
q = 'repository__quality_score'
# This function is better than using a linear function because it
# makes it so that the effect of losing the first few points is
# relatively minor, which reduces the impact of errors in scoring.
quality_rank_expr = (
Func(Coalesce(F(q), 0) + 1, function='log')
* CONTENT_SCORE_MULTIPLIER
)
relevance_expr = (
F('search_rank') + F('download_rank') + F('quality_rank')
)
return queryset.annotate(
download_count_ln=ExpressionWrapper(
download_count_ln_expr,
output_field=db_fields.FloatField()),
download_rank=ExpressionWrapper(
download_rank_expr,
output_field=db_fields.FloatField()),
quality_rank=ExpressionWrapper(
quality_rank_expr,
output_field=db_fields.FloatField()),
relevance=ExpressionWrapper(
relevance_expr,
output_field=db_fields.FloatField()),
)
def add_keywords_filter(queryset, keywords):
if not keywords:
return queryset.annotate(
search_rank=Value(0.0, output_field=db_fields.FloatField()))
tsquery = six.moves.reduce(
operator.and_,
(psql_search.SearchQuery(kw) for kw in keywords))
search_rank_fn = Func(
F('search_vector'), tsquery, RANK_NORMALIZATION,
function=RANK_FUNCTION, output_field=db_fields.FloatField())
return (queryset.annotate(search_rank=search_rank_fn)
.filter(search_vector=tsquery))
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data(**kwargs)
if self.request.user.has_perm('bill.add_client'):
print("add yes ")
else:
print("no")
if self.request.user.has_perm('bill.change_client'):
print("change yes")
else:
print("no")
if self.request.user.has_perm('bill.delete_client'):
print("delete client")
else:
print("no")
if self.request.user.has_perm('bill.view_client'):
print("view yes ")
else:
print("no")
data_filtred = ClientFilter(self.request.GET,
queryset=self.model.objects.all())
data_filtredQs = data_filtred.qs
context["object_list"] = data_filtredQs.annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('facture__lignes__qte') *
F('facture__lignes__produit__prix'),
output_field=fields.FloatField())))
context['object_table'] = self.table_class(context["object_list"])
context['title'] = "Liste des clients"
context['option'] = "Ajouter Client"
context['ajouter_url'] = reverse('client_create')
context['object_name'] = "Client"
return context
def add_relevance(queryset):
download_count_ln_expr = Func(F('repository__download_count') + 1,
function='ln')
download_rank_expr = (F('download_count_ln') /
(1 + F('download_count_ln')) *
DOWNLOAD_RANK_MULTIPLIER)
relevance_expr = ExpressionWrapper(F('search_rank') +
F('download_rank'),
output_field=db_fields.FloatField())
return queryset.annotate(
download_count_ln=download_count_ln_expr,
download_rank=ExpressionWrapper(
download_rank_expr, output_field=db_fields.FloatField()),
relevance=relevance_expr,
)
class DeliveryPack(Model):
pack_id = fields.AutoField(primary_key=True)
courier = ForeignKey(Courier,
on_delete=CASCADE,
default=None,
blank=True,
null=True)
assign_time = fields.DateTimeField()
delivery_type = fields.CharField(max_length=4,
choices=Courier.COURIER_TYPE_CHOICES,
default='foot')
delivery_ended = fields.BooleanField(default=False)
last_complete_time = fields.DateTimeField()
total_weight = fields.FloatField(default=0)
def orders(self):
return self.order_set.all()
def assign_order(self, order):
order.delivery_pack = self
self.total_weight += order.weight
order.save()
self.save()
def make_order_free(self, order):
if order not in self.orders():
return
order.delivery_pack = None
order.delivery_time = None
self.total_weight -= order.weight
order.save()
self.save()
class Order(models.Model):
order_id = fields.IntegerField(primary_key=True)
weight = fields.FloatField()
region = fields.IntegerField()
delivery_hours = pg_fields.ArrayField(fields.CharField(max_length=12))
delivery_pack = ForeignKey(DeliveryPack, on_delete=CASCADE, default=None, blank=True, null=True)
delivery_time = fields.IntegerField(default=None, blank=True, null=True)
def is_completed(self):
return self.delivery_time is not None
def set_completed(self, seconds: int):
if not self.is_completed():
self.delivery_time = seconds
def is_inside_working_time(self, courier: Courier):
for available_period in self.delivery_hours:
for delivery_period in courier.working_hours:
result = time_utils.inside_bounds(available_period, delivery_period)
if result:
return True
return False
def __getitem__(self, item):
return getattr(self, item)
def __setitem__(self, key, value):
setattr(self, key, value)
def get_list_of_fields(self):
return self._meta.get_fields()
def getFivedayWeightList(self):
#class_name = ['サービス業','情報・通信']
basic_company = self.getBasicCompany()
day = self.getBasicDay()
result = DailyData.objects.select_related('company_code').all().values(
'company_code__company_name',
'company_code__address',
'company_code__address_url',
).annotate(
company_code=F('company_code'),
company_name=F('company_code__company_name'),
feature=F('company_code__feature'),
fiveday_weight=F('fiveday_weight'),
class_name=F('company_code__class_name'),
address=F('company_code__address'),
address_url=F('company_code__address_url'),
price=F('finish_value') / 10,
daily_per=F('daily_per'),
baisu=ExpressionWrapper(
F('company_code__kabu_sum_number') * Decimal('1.0') *
F('finish_value') /
(basic_company.kabu_sum_number * basic_company.finish_value),
output_field=fields.FloatField()),
nikkeichart_url=Concat(
Value("https://www.nikkei.com/smartchart/?code="),
F('company_code')),
localchart_url=Concat(Value("/front/companyinfo/"),
F('company_code')),
).filter(
day=day,
buy_signal=1,
#daily_per__lte=30,daily_per__gte=0.01,
).order_by('daily_per')
return result
def _add_search_rank(self, qs):
"""Annotates query with search rank value.
Search rank is calculated as result of `ts_rank` PostgreSQL
function, which ranks vectors based on the frequency of their matching
lexemes. Search rank is normalized by dividing it by itself + 1:
"""
keywords = self.filters.get('keywords')
if not keywords:
return qs.annotate(
search_rank=Value(0.0, output_field=db_fields.FloatField()))
search_rank_fn = Func(F('search_vector'),
psql_search.SearchQuery(keywords),
RANK_NORMALIZATION,
function=RANK_FUNCTION,
output_field=db_fields.FloatField())
return qs.annotate(search_rank=search_rank_fn)
class Random(Expression):
output_field = fields.FloatField()
def __repr__(self):
return "Random()"
def as_sql(self, compiler, connection):
return connection.ops.random_function_sql(), []
def ranking_algorithm():
# Based on Hacker News' post rank formula
time_diff = functions.Cast(functions.Now() - F('created_time'),
fields.DurationField())
hours = dtime.duration_to_hours(duration=time_diff)
rank = ExpressionWrapper(
(F('upvote') - F('devote') + 1) / ((hours + 2)**1.8),
output_field=fields.FloatField())
return hours, rank
def get_context_data(self, **kwargs):
context = super(FactureView, self).get_context_data(**kwargs)
table = LigneFactureTable(
LigneFacture.objects.all().annotate(total=Sum(
ExpressionWrapper(F('qte') * F('produit__prix'),
output_field=fields.FloatField()))))
RequestConfig(self.request, paginate={"per_page": 5}).configure(table)
context['table'] = table
return context
class Address(Model):
text = fields.CharField(max_length=50, blank=True, null=True)
phone = fields.CharField(max_length=15, blank=True, null=True)
city = fields.CharField(max_length=50, blank=True, null=True)
state = fields.CharField(max_length=50, blank=True, null=True)
zip_code = fields.CharField(max_length=10, blank=True, null=True)
country = fields.CharField(max_length=50, blank=True, null=True)
latitude = fields.FloatField(blank=True, null=True)
longitude = fields.FloatField(blank=True, null=True)
def save(self, *args, **kwargs):
res = requests.get(
'https://maps.googleapis.com/maps/api/geocode/json?address={},{},{},{}&key={}'
.format(self.text, self.city, self.country, self.zip_code,
API_KEY))
location = res.json()['results'][0]['geometry']['location']
self.latitude = location['lat']
self.longitude = location['lng']
super().save(*args, **kwargs)
def __init__(self,
value: Union[Value, str],
*expressions,
output_field=None,
**extra):
if value is not Value:
value = Value(value)
if output_field is None:
output_field = fields.FloatField()
expressions = value, *expressions
super().__init__(*expressions, output_field=output_field, **extra)
def get_context_data(self, **kwargs):
context = super(ClientDetailView, self).get_context_data(**kwargs)
table = LigneClientTable(
Client.objects.all().annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('facture__lignes__qte') *
F('facture__lignes__produit__prix'),
output_field=fields.FloatField()))))
context['table'] = table
return context
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
data_filtred = FactureFilter(
self.request.GET,
queryset=self.model.objects.filter(client=self.kwargs.get('pk')))
data_filtredQs = data_filtred.qs
context['object_list'] = data_filtredQs.annotate(total=Sum(
ExpressionWrapper(F('lignes__qte') * F('lignes__produit__prix'),
output_field=fields.FloatField())))
context['object_table'] = self.table_class(context['object_list'])
context['title'] = 'Liste des factures'
context['object_name'] = "Facture"
return context
def get_context_data(self, **kwargs):
context = super(DashboardView, self).get_context_data(**kwargs)
fournisseur_qs = models.Fournisseur.objects.annotate(
chiffre_affaire=Sum(
ExpressionWrapper(F('produits_forni__lignefacture__qte') *
F('produits_forni__prix'),
output_field=fields.FloatField())))
client_qs = models.Client.objects.annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('facture__lignes__qte') *
F('facture__lignes__produit__prix'),
output_field=fields.FloatField()))).order_by(
"-chiffre_affaire")
context[
"fournisseur_table"] = tables.FournisseurWithChiffreAffaireTable(
fournisseur_qs)
context["client_table"] = tables.ClientWithChiffreAffaireTable(
client_qs)
context["daily_stat"] = charts.DailyStatChart()
context["category_stat"] = charts.CategoryStatChart()
return context
class ExchangeRate(models.Model):
# NOTE: again, there is a lot of ways to implement a table for exchange rate montiring
primary = CurrencyField()
secondary = CurrencyField()
rate = fields.FloatField(null=False, blank=False)
last_update_date_time = fields.DateTimeField(null=False,
blank=False,
auto_now=True)
class Meta:
constraints = (models.UniqueConstraint(
fields=('primary', 'secondary'),
name='db_exchange_rate_primary_secondary_unique'), )
index_together = ('primary', 'secondary')
class DailyStatChart(Chart):
chart_type = 'line'
qs = Facture.objects.values('date').annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('lignes__qte') * F('lignes__produit__prix'),
output_field=fields.FloatField())))
def get_datasets(self, **kwargs):
return [
DataSet(color=(60, 170, 20),
data=list(self.qs.values_list('chiffre_affaire',
flat=True)),
label="l'évolution du chiffre d'affaire")
]
def get_labels(self, **kwargs):
return list(self.qs.values_list('date', flat=True))
class CategoryStatChart(Chart):
chart_type = 'radar'
qs = Category.objects.values('nom').annotate(chiffre_affaire=Sum(
ExpressionWrapper(F('produit__lignefacture__qte') * F('produit__prix'),
output_field=fields.FloatField())))
def get_datasets(self, **kwargs):
return [
DataSet(color=(245, 66, 170),
data=list(self.qs.values_list('chiffre_affaire',
flat=True)),
label="chiffre d'affaire par Categorie")
]
def get_labels(self, **kwargs):
return list(self.qs.values_list('nom', flat=True))
class CategorieChart(Chart):
chart_type = 'radar'
queryset = Facture.objects.values('lignes__produit__categorie').annotate(
chiffre_affaire=Sum(
ExpressionWrapper(F('lignes__qte') * F('lignes__produit__prix'),
output_field=fields.FloatField())))
def get_datasets(self, **kwargs):
return [
DataSet(color=(13, 200, 56),
data=list(
self.queryset.values_list('chiffre_affaire',
flat=True)),
label="chiffre d'affaire par Categorie")
]
def get_labels(self, **kwargs):
return list(
self.queryset.values_list('lignes__produit__categorie', flat=True))
class Transaction(Model):
account = ForeignKey(Account, on_delete=CASCADE)
date = fields.DateTimeField('date')
label = fields.CharField(max_length=1000)
value = fields.FloatField()
category = ForeignKey(Category, null=True)
def categorize(self, category_matching):
for m, c in category_matching:
if m in self.label:
self.category = c
self.save()
break
class Meta:
unique_together = (('account', 'date', 'label', 'value'), )
def __str__(self):
return 'Transaction: {date} {value} {label}'.format(date=self.date,
label=self.label,
value=self.value)
def filter_by_q(self, queryset, name, value):
"""
Full text search provided by the 'q' option.
Args:
queryset: The query to add the additional full-text search filtering onto
name: The name of the option specified, i.e. 'q'
value: The string to search on
Returns:
The Django queryset that was passed in, additionally filtered by full-text search.
"""
search_query = SearchQuery(value)
qs = queryset.filter(search_vector=search_query)
ts_rank_fn = Func(
F("search_vector"),
search_query,
32, # RANK_NORMALIZATION = 32
function="ts_rank",
output_field=db_fields.FloatField(),
)
return qs.annotate(rank=ts_rank_fn).order_by("-rank")
def _resolve_output_field(self):
if isinstance(self.value, str):
return fields.CharField()
if isinstance(self.value, bool):
return fields.BooleanField()
if isinstance(self.value, int):
return fields.IntegerField()
if isinstance(self.value, float):
return fields.FloatField()
if isinstance(self.value, datetime.datetime):
return fields.DateTimeField()
if isinstance(self.value, datetime.date):
return fields.DateField()
if isinstance(self.value, datetime.time):
return fields.TimeField()
if isinstance(self.value, datetime.timedelta):
return fields.DurationField()
if isinstance(self.value, Decimal):
return fields.DecimalField()
if isinstance(self.value, bytes):
return fields.BinaryField()
if isinstance(self.value, UUID):
return fields.UUIDField()
def __init__(self):
super(Random, self).__init__(output_field=fields.FloatField())
class Activity(OrderedModel):
"""General entity which represents problem/text/video material."""
TYPES = (
('G', _('generic')),
('A', _('pre-assessment')),
('Z', _('post-assessment')),
)
order_with_respect_to = 'atype', 'collection'
name = models.CharField(max_length=255)
collection = models.ForeignKey('Collection',
related_name='activities',
null=True,
on_delete=models.CASCADE)
tags = fields.CharField(
max_length=255,
help_text="Provide your tags separated by a comma.",
blank=True,
null=True,
)
atype = fields.CharField(
verbose_name="type",
choices=TYPES,
default='G',
max_length=1,
help_text=
"Choose 'pre/post-assessment' activity type to pin Activity to the start or the end of "
"the Collection.")
difficulty = fields.FloatField(
default='0.5',
help_text="Provide float number in the range 0.0 - 1.0",
validators=[MinValueValidator(0.0),
MaxValueValidator(1.0)],
)
points = models.FloatField(blank=True, default=1)
lti_consumer = models.ForeignKey(LtiConsumer,
null=True,
on_delete=models.CASCADE)
source_launch_url = models.URLField(max_length=255, null=True)
source_name = fields.CharField(max_length=255, blank=True, null=True)
source_context_id = fields.CharField(max_length=255, blank=True, null=True)
# NOTE(wowkalucky): extra field 'order' is available (inherited from OrderedModel)
# `stype` - means source_type or string_type.
stype = models.CharField("Type of the activity",
help_text="(problem, video, html, etc.)",
max_length=25,
blank=True,
null=True)
# Number of possible repetition of the activity in the sequence
repetition = models.PositiveIntegerField(
default=1,
help_text=
"The number of possible repetition of the Activity in the sequence.")
@property
def is_problem(self):
return self.stype in settings.PROBLEM_ACTIVITY_TYPES
class Meta:
verbose_name_plural = 'Activities'
unique_together = ("source_launch_url", "collection")
ordering = 'atype', 'order'
def __str__(self):
return '<Activity: {}>'.format(self.name)
def get_absolute_url(self):
return reverse('module:collection-detail',
kwargs={'pk': self.collection.pk})
def save(self, *args, **kwargs):
"""Extension which sends notification to the Adaptive engine that Activity is created/updated."""
initial_id = self.id
if initial_id:
Log.objects.create(log_type=Log.ADMIN,
action=Log.ACTIVITY_UPDATED,
data=self.get_research_data())
else:
Log.objects.create(log_type=Log.ADMIN,
action=Log.ACTIVITY_CREATED,
data=self.get_research_data())
super().save(*args, **kwargs)
self.collection.save()
def delete(self, *args, **kwargs):
"""Extension which sends notification to the Adaptive engine that Activity is deleted."""
Log.objects.create(log_type=Log.ADMIN,
action=Log.ACTIVITY_DELETED,
data=self.get_research_data())
super().delete(*args, **kwargs)
self.collection.save()
@property
def last_pre(self):
"""
Has Activity last order number position in certain type sub-collection.
:return: (bool)
"""
last_pre = Activity.objects.filter(collection=self.collection,
atype='A').last()
return self.id == last_pre.id
def get_research_data(self):
return {'collection_id': self.collection_id, 'activity_id': self.id}
