def subscription_signed_up(sender, **kwargs):
subscription = kwargs.get('subscription')
user_subscription = kwargs.get('usersubscription')
user = kwargs.get('user')
if 'premium' in subscription.category:
if user_subscription.expires is None:
user_subscription.expires = DateTimeService.today()
user_subscription.extend(datetime.timedelta(days=365.2425))
user_subscription.save()
# Invalidate other premium subscriptions
UserSubscription.active_objects \
.filter(user=user_subscription.user,
subscription__category__startswith='premium') \
.exclude(pk=user_subscription.pk) \
.update(active=False)
if Transaction.objects.filter(user=user,
event='new usersubscription',
timestamp__gte=DateTimeService.now() -
datetime.timedelta(minutes=5)):
push_notification([user], 'new_subscription',
{'BASE_URL': settings.BASE_URL})
else:
push_notification([user], 'new_payment',
{'BASE_URL': settings.BASE_URL})
def get_next_available_selection_time_for_judge(self, judge):
# type: (User) -> datetime
today = DateTimeService.today() # date
now = DateTimeService.now() # datetime
next_time_due_to_max_per_day = \
DateTimeService.next_midnight() if \
Iotd.objects.filter(
judge=judge,
date=today).count() >= settings.IOTD_JUDGEMENT_MAX_PER_DAY \
else now # datetime
latest_scheduled = Iotd.objects.filter(
judge=judge).order_by('-date').first() # Iotd
next_time_due_to_max_scheduled_per_judge = \
DateTimeService.next_midnight(latest_scheduled.date) if \
Iotd.objects.filter(
judge=judge,
date__gt=today).count() >= settings.IOTD_JUDGEMENT_MAX_FUTURE_PER_JUDGE \
else now
next_time_due_to_max_scheduled = \
DateTimeService.next_midnight() if \
Iotd.objects.filter(date__gte=today).count() >= settings.IOTD_JUDGEMENT_MAX_FUTURE_DAYS \
else now
return max(next_time_due_to_max_per_day,
next_time_due_to_max_scheduled_per_judge,
next_time_due_to_max_scheduled)
def _compute_queue(reviewer: User):
days = settings.IOTD_REVIEW_WINDOW_DAYS
cutoff = datetime.now() - timedelta(days)
return Image.objects.annotate(
num_submissions=Count('iotdsubmission', distinct=True),
num_dismissals=Count('iotddismissedimage', distinct=True),
last_submission_timestamp=Subquery(IotdSubmission.last_for_image(OuterRef('pk')).values('date'))
).filter(
Q(deleted__isnull=True) &
Q(last_submission_timestamp__gte=cutoff) &
Q(designated_iotd_reviewers=reviewer) &
Q(num_submissions__gte=settings.IOTD_SUBMISSION_MIN_PROMOTIONS) &
Q(num_dismissals__lt=settings.IOTD_MAX_DISMISSALS) &
Q(
Q(iotd__isnull=True) |
Q(iotd__date__gt=datetime.now().date())
)
).exclude(
Q(iotdsubmission__submitter=reviewer) |
Q(user=reviewer) |
Q(iotddismissedimage__user=reviewer) |
Q(
Q(iotdvote__reviewer=reviewer) &
Q(iotdvote__date__lt=DateTimeService.today())
)
)
def send_notifications_when_promoted_image_becomes_iotd():
try:
iotd = Iotd.objects.get(date=DateTimeService.today())
except Iotd.DoesNotExist:
logger.error(
"send_notifications_when_promoted_image_becomes_iotd: Iotd not found"
)
return
image = iotd.image
thumb = image.thumbnail_raw('gallery', None, sync=True)
submitters = [
x.submitter for x in IotdSubmission.objects.filter(image=image)
]
push_notification(submitters, None, 'image_you_promoted_is_iotd', {
'image': image,
'image_thumbnail': thumb.url if thumb else None
})
reviewers = [x.reviewer for x in IotdVote.objects.filter(image=image)]
push_notification(reviewers, None, 'image_you_promoted_is_iotd', {
'image': image,
'image_thumbnail': thumb.url if thumb else None
})
push_notification([image.user], None, 'your_image_is_iotd', {
'image': image,
'image_thumbnail': thumb.url if thumb else None
})
def get_inactive_submitter_and_reviewers(self, days):
inactive_members = []
members = User.objects.filter(
groups__name__in=['iotd_submitters', 'iotd_reviewers'])
for member in members.iterator():
if member.is_superuser:
continue
if 'iotd_reviewers' in member.groups.all().values_list('name',
flat=True):
actions = IotdVote.objects.filter(
reviewer=member).order_by('-date')
action_count = actions.count()
last_action = actions.first(
).date if action_count > 0 else None
elif 'iotd_submitters' in member.groups.all().values_list(
'name', flat=True):
actions = IotdSubmission.objects.filter(
submitter=member).order_by('-date')
action_count = actions.count()
last_action = actions.first(
).date if action_count > 0 else None
else:
continue
if last_action is None or last_action.date(
) == DateTimeService.today() - timedelta(days=days):
inactive_members.append(member)
return inactive_members
def show_10_year_anniversary_logo() -> bool:
today = DateTimeService.today()
first_code_anniversary = datetime(2020, 11, 27).date()
publication_anniversary = datetime(2021, 11, 27).date()
return today in (first_code_anniversary, publication_anniversary)
def judge_cannot_select_now_reason(self, judge):
# type: (User) -> Union[str, None]
if Iotd.objects.filter(
judge=judge,
date=DateTimeService.today()).count() >= settings.IOTD_JUDGEMENT_MAX_PER_DAY:
return gettext("you already selected %s IOTD today (UTC)" % settings.IOTD_JUDGEMENT_MAX_PER_DAY)
if Iotd.objects.filter(
judge=judge,
date__gt=DateTimeService.today()).count() >= settings.IOTD_JUDGEMENT_MAX_FUTURE_PER_JUDGE:
return gettext("you already selected %s scheduled IOTDs" % settings.IOTD_JUDGEMENT_MAX_FUTURE_PER_JUDGE)
if Iotd.objects.filter(date__gte=DateTimeService.today()).count() >= settings.IOTD_JUDGEMENT_MAX_FUTURE_DAYS:
return gettext("there are already %s scheduled IOTDs" % settings.IOTD_JUDGEMENT_MAX_FUTURE_DAYS)
return None
def has_an_expired_premium_subscription(user):
if is_any_premium_subscription(user):
return False
return UserSubscription.objects.filter(
user=user,
expires__lt=DateTimeService.today(),
subscription__category__contains="premium"
).exists()
def has_premium_subscription_near_expiration(user, days):
cache_key = "has_premium_subscription_near_expiration_%d" % user.pk
cached = cache.get(cache_key)
if cached is not None:
return cached
if has_an_expired_premium_subscription(user):
result = False
else:
result = UserSubscription.objects.filter(
Q(user=user) & Q(active=True)
& Q(expires__lt=DateTimeService.today() + datetime.timedelta(days))
& Q(expires__gt=DateTimeService.today())
& Q(subscription__category__contains="premium")).exists()
cache.set(cache_key, result, 300)
return result
def is_remote_source_affiliate(code):
# type: (unicode) -> bool
remote_source = get_object_or_None(RemoteSourceAffiliate, code=code) # type: RemoteSourceAffiliate
if remote_source is None:
return False
return remote_source.affiliation_start is not None and \
remote_source.affiliation_expiration >= DateTimeService.today()
def create(self, validated_data):
if 'judge' not in validated_data:
validated_data['judge'] = self.context['request'].user
latest_iotd = self.Meta.model.objects.first()
validated_data['date'] = latest_iotd.date + timedelta(1) \
if latest_iotd \
else DateTimeService.today()
return super().create(validated_data)
def show_10_year_anniversary_logo():
# type: () -> bool
today = DateTimeService.today()
first_code_anniversary = datetime(2020, 11, 27).date()
publication_anniversary = datetime(2021, 11, 27).date()
one_week = timedelta(days=7)
return \
first_code_anniversary <= today < first_code_anniversary + one_week or \
publication_anniversary <= today < publication_anniversary + one_week
def has_an_expired_premium_subscription(user):
cache_key = "has_an_expired_premium_subscription_%d" % user.pk
cached = cache.get(cache_key)
if cached is not None:
return cached
if is_any_premium_subscription(user):
result = False
else:
result = UserSubscription.objects.filter(
user=user,
expires__lt=DateTimeService.today(),
subscription__category__contains="premium").exists()
cache.set(cache_key, result, 300)
return result
def get_queryset(self):
return self.serializer_class.Meta.model.objects.filter(
date__gt=DateTimeService.today()).order_by('date')