def update(self, instance, validated_data):
old_file_name = instance.file_object.name
updated_instance = super().update(instance, validated_data)
# force to delete old file;
add_post_transaction_success_operation(
instance.file_object.storage.delete, old_file_name)
return updated_instance
def remove_stripe_customer_handler(sender, instance, **kwargs):
if instance.customer_id:
add_post_transaction_success_operation(
remove_stripe_customer.delay,
instance.admin_id,
instance.customer_id
)
def create_stripe_customer_handler(sender, instance, created, **kwargs):
if created and not instance.customer_id:
add_post_transaction_success_operation(
create_stripe_customer.delay,
instance.pk,
email=instance.admin.email
)
def post(self, request, *args, **kwargs):
"""Log Admin in if right email and password are provided.
Returns data about user and `account_key`.
"""
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
email = serializer.validated_data['email']
password = serializer.validated_data['password']
try:
admin = Admin.objects.select_for_update().get(email=email)
if admin.check_password(password):
admin_data = AdminFullSerializer(admin).data
admin_data['account_key'] = admin.key
admin.last_login = timezone.now()
admin.update_last_access(save=False)
admin.save(update_fields=('last_login', 'noticed_at',
'last_access'))
add_post_transaction_success_operation(
NotifyAboutLogIn.delay, admin.id, email, 'password')
return Response(admin_data, status=status.HTTP_200_OK)
NotifyAboutLogInFailure.delay(admin.id, email, 'password')
raise WrongPassword()
except Admin.DoesNotExist:
raise AdminNotFound()
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def charge_succeeded(event, **kwargs):
reference, processed = process_charge(event, Invoice.STATUS_CHOICES.PAYMENT_SUCCEEDED)
if processed:
add_post_transaction_success_operation(
NotifyAboutPaymentReceived.delay,
reference,
event.created_at.strftime(settings.ANALYTICS_DATE_FORMAT))
def post(self, request, *args, **kwargs):
"""Create admin.
Requires:
email,
password,
invitation_key - optional invitation key
"""
if not settings.REGISTRATION_ENABLED:
if not request.user.is_authenticated or not request.user.is_superuser:
raise RegistrationDisabled()
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
admin = serializer.save()
admin_data = AdminFullSerializer(admin).data
admin_data['account_key'] = admin.key
context = self.get_task_context(admin, request.data)
add_post_transaction_success_operation(
NotifyAboutAdminSignup.delay, admin.id, admin.email,
admin.created_at.strftime(settings.DATETIME_FORMAT), **context)
return Response(admin_data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def hosting_post_save_handler(sender, instance, created, using, **kwargs):
syncano_instance_pk = get_current_instance().pk
new_cname = Hosting.find_cname(instance.domains)
if created:
old_cname = None
else:
old_cname = Hosting.find_cname(instance.old_value('domains'))
if new_cname != old_cname:
with transaction.atomic():
syncano_instance = Instance.objects.select_for_update().get(pk=syncano_instance_pk)
if new_cname is not None:
add_domains_to_syncano_instance(syncano_instance, domains=[new_cname])
if old_cname is not None:
remove_domains_from_syncano_instance(syncano_instance, domains=[old_cname])
syncano_instance.save(update_fields=['domains'])
if instance.ssl_status == Hosting.SSL_STATUSES.CHECKING:
add_post_transaction_success_operation(
HostingAddSecureCustomDomainTask.delay,
using=using,
hosting_pk=instance.id,
domain=instance.get_cname(),
instance_pk=syncano_instance_pk,
)
def socket_environment_post_save_handler(sender, instance, created, using, **kwargs):
if instance.is_live:
if instance.has_changed('zip_file') and instance.old_value('zip_file'):
instance.old_value('zip_file').delete(save=False)
if instance.status == SocketEnvironment.STATUSES.PROCESSING:
add_post_transaction_success_operation(SocketEnvironmentProcessorTask.delay,
using=using,
instance_pk=get_current_instance().pk,
environment_pk=instance.pk)
def send_activation_email(self, token_generator):
from apps.analytics.tasks import NotifyAboutResendAdminActivationEmail
token = token_generator.make_token(self)
uid = urlsafe_base64_encode(force_bytes(self.pk)).decode()
context = {
'admin_id': self.id,
'uid': uid,
'token': token,
}
add_post_transaction_success_operation(
NotifyAboutResendAdminActivationEmail.delay, **context)
def livemodel_post_soft_delete_handler(sender, instance, using, **kwargs):
sender_meta = sender._meta
instance_pk = None
if is_model_in_tenant_apps(sender):
instance_pk = get_current_instance().pk
# queue actual cleanup job
add_post_transaction_success_operation(DeleteLiveObjectTask.delay,
using=using,
model_class_name='%s.%s' % (sender_meta.app_label, sender_meta.model_name),
object_pk=instance.pk,
instance_pk=instance_pk)
def launch_trigger(instance, serializer_class, event, signal, changes=None, **context):
instance_pk = get_current_instance().pk
if Trigger.match(instance_pk, event, signal):
data = serializer_class(instance, excluded_fields=('links',), context=context).data
if changes is not None:
changes = changes.intersection(set(data.keys()))
add_post_transaction_success_operation(HandleTriggerEventTask.delay,
using=router.db_for_write(instance.__class__),
instance_pk=instance_pk,
event=event,
signal=signal,
data=data,
changes=list(changes) if changes else None)
def perform_create(self, serializer):
instance = self.request.instance
admin = None
try:
admin = Admin.objects.get(email=serializer.validated_data['email'])
if instance.owner == admin or AdminInstanceRole.objects.filter(admin=admin, instance=instance).exists():
raise InstanceRoleAlreadyExists()
except Admin.DoesNotExist:
pass
invitation = Invitation.objects.select_for_update().filter(instance=instance,
email=serializer.validated_data['email']).first()
if invitation:
if invitation.state not in [Invitation.STATE_CHOICES.DECLINED, Invitation.STATE_CHOICES.ACCEPTED]:
raise InvitationAlreadyExists()
invitation.delete()
invitation = serializer.save(admin=admin, inviter=self.request.user, instance=instance)
add_post_transaction_success_operation(NotifyAboutInvitation.delay, invitation_id=invitation.id)
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
admin = serializer.admin
admin.is_active = True
admin.last_login = timezone.now()
admin.save(update_fields=(
'last_login',
'is_active',
))
add_post_transaction_success_operation(
NotifyAboutAdminActivation.delay,
admin_id=admin.id,
email=admin.email,
**serializer.data)
admin_data = AdminFullSerializer(admin).data
admin_data['account_key'] = admin.key
return Response(admin_data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, backend):
"""Log Admin using social credentials.
Available backends are now:
`facebook`
`google-oauth2`
`github`
"""
serializer = self.get_serializer(data=request.data)
if not serializer.is_valid():
raise WrongTokenCredentials()
# Use access token to get info about the user
helper = AdminSocialHelper()
admin, was_created = helper.register_by_access_token(
serializer.data['access_token'], backend)
if admin is None:
raise WrongTokenCredentials()
if was_created:
context = self.get_task_context(admin, backend, request.data)
add_post_transaction_success_operation(
NotifyAboutAdminSignup.delay, admin.id, admin.email,
admin.created_at.strftime(settings.DATETIME_FORMAT), **context)
admin_data = AdminFullSerializer(admin).data
admin_data['account_key'] = admin.key
admin_data['created'] = was_created
admin.last_login = timezone.now()
admin.update_last_access(save=False)
admin.save(update_fields=('last_login', 'noticed_at', 'last_access'))
add_post_transaction_success_operation(NotifyAboutLogIn.delay,
admin.id, admin.email, backend)
return Response(admin_data, status=status.HTTP_200_OK)
def notify_about_aggregate(self, instance_name, group):
task_kwargs = {}
for obj in group:
if not obj.value:
continue
task_kwargs['admin_id'] = obj.admin_id
if obj.source == HourAggregate.SOURCES.API_CALL:
task_kwargs['api_calls'] = obj.value
task_class = NotifyAboutApiCalls
else:
task_kwargs['codebox_runs'] = obj.value
task_class = NotifyAboutCodeBoxSeconds
add_post_transaction_success_operation(task_class.delay,
admin_id=obj.admin_id,
instance_name=instance_name,
value=obj.value)
if task_kwargs:
add_post_transaction_success_operation(
NotifyAboutApiAndCodeBoxSeconds.delay,
instance_name=instance_name,
**task_kwargs)
def cleanup_data_klass_ref(klass, save=False, using=None):
# If klass is no longer managed by any socket, delete it.
if 'managed_by' in klass.refs and not klass.refs['managed_by']:
if klass.is_locked:
add_post_transaction_success_operation(
KlassOperationQueue.delay,
using=using,
instance_pk=get_current_instance().pk,
klass_pk=klass.pk,
op='delete')
else:
klass.delete()
return
if klass.is_locked:
add_post_transaction_success_operation(
KlassOperationQueue.delay,
using=using,
instance_pk=get_current_instance().pk,
klass_pk=klass.pk,
op='cleanup_refs')
return
klass.cleanup_refs(save=save)
def delete(self, name):
add_post_transaction_success_operation(super().delete,
name,
using=self._get_current_db())
def charge_failed(event, **kwargs):
# Invoice is not required for payment failed as it may not be existing anymore (e.g. when it was a temporary
# invoice created during creation of subscription)
reference, processed = process_charge(event, Invoice.STATUS_CHOICES.PAYMENT_FAILED, required=False)
if processed:
add_post_transaction_success_operation(NotifyAboutPaymentFailure.delay, reference)
def notify_about_pricing_plan_change(sender, instance, created, **kwargs):
add_post_transaction_success_operation(NotifyAboutPlanChange.delay,
subscription_pk=instance.pk)
def klass_post_save_handler(sender, instance, using, **kwargs):
if instance.index_changes:
add_post_transaction_success_operation(IndexKlassTask.delay,
using=using,
instance_pk=get_current_instance().pk)
def klass_post_delete_handler(sender, instance, using, **kwargs):
add_post_transaction_success_operation(DeleteKlassIndexesTask.delay,
using=using,
instance_pk=get_current_instance().pk,
klass_pk=instance.pk)
def resend(self, *args, **kwargs):
invitation = self.get_object()
if invitation.state == Invitation.STATE_CHOICES.NEW:
add_post_transaction_success_operation(NotifyAboutInvitation.delay, invitation_id=invitation.id)
return Response(status=status.HTTP_204_NO_CONTENT)
