Exemple #1
0
    def update(self, request, pk=None):
        if not request.user or request.user.organization is None:
            return Response(status=403)

        dropoff = get_object_or_404(
            DropoffCall,
            pk=pk,
            building__organization=request.user.organization)

        if dropoff.datetime_dropoff:
            return ValidationError('Already dropped off')

        if not dropoff.is_sent:
            d = date.today()
            t = time(19, 00)
            next_run = datetime.combine(d, t)
            schedule('views.call_dropoff',
                     dropoff,
                     schedule_type=Schedule.ONCE,
                     next_run=next_run)

        else:
            dropoff.is_dropped = True  # Такого параметра нет у модели, зачем эта строчка?
            dropoff.datetime_dropoff = timezone.make_aware(datetime.today())
            dropoff.save()
            for dropofflog in list(DropoffLog.objects.filter(call=dropoff)):
                dropofflog.box.fullness = 0
                dropofflog.box.save()
        return Response(status=status.HTTP_200_OK)
Exemple #2
0
def add_sql_schedule(name, run_date, workflow_id):
    """添加/修改sql定时任务"""
    del_schedule(name)
    schedule('sql.utils.execute_sql.execute', workflow_id,
             hook='sql.utils.execute_sql.execute_callback',
             name=name, schedule_type='O', next_run=run_date, repeats=1, timeout=-1)
    logger.debug(f"添加SQL定时执行任务:{name} 执行时间:{run_date}")
Exemple #3
0
    def create_django_q_scheduled_tasks():
        from datetime import datetime
        from django.db import IntegrityError, ProgrammingError, OperationalError
        from django_q.tasks import schedule, Schedule

        _date = datetime.now()
        date = datetime(_date.year, _date.month, _date.day)

        tasks = [
            {
                'func': 'django.core.management.call_command',
                'args': 'sendemails',
                'name': "Send Pending Emails",  # Must be unique
                'schedule_type': Schedule.MINUTES,
                'minutes': 1,
                'next_run': date,
                'repeats': -1,
            },
        ]

        for task in tasks:
            try:
                schedule(task['func'],
                         task['args'],
                         name=task['name'],
                         schedule_type=task['schedule_type'],
                         minutes=task['minutes'],
                         next_run=task['next_run'],
                         repeats=task['repeats'])
            except (ProgrammingError, IntegrityError, OperationalError):
                pass
Exemple #4
0
def schedule_delivery(sender, instance: Transaction, **kwargs):
    """Adds a task to schedule delivery at the correct date"""
    delivery_date = get_delivery_date(
        instance.contract)[0]  # get first delivery date for simplicity
    schedule('apps.salam.clearing.delivery',
             instance.uid,
             next_run=delivery_date)
Exemple #5
0
def replicate_file(f):
    file_servers = f.storage.filter(status='UP')

    if file_servers.count() >= settings.NUM_OF_REPLICAS:
        logger.info(f'ENOUGH COPIES {f.file_path}')
        return

    logger.info(f'REPLICATING {f.file_path}')

    init_server = file_servers.first()
    copy_to = Storage.objects.filter(
        status='UP').difference(file_servers).first()

    if init_server is None or copy_to is None:
        return

    try:
        requests.post(
            f'http://{init_server.private_ip}:{STORAGE_SERVER_PORT}/replicate',
            data={
                'file_path': f.file_path,
                'dest_ip': copy_to.private_ip
            })
    except:
        pass

    # Schedule replication check
    next_run = datetime.now() + timedelta(seconds=5)
    schedule(
        'name_server.tasks.file_replication_check',
        f.pk,
        copy_to.pk,
        next_run=next_run,
        repeats=1,
    )
Exemple #6
0
    def start_bg_tasks(self):
        """
        Kick off background tasks for each message.

        Starts tasks to:
            * Log the message in the db
            * Post the message to slack
            * Send blacklist warnings if required
            * Ask the contact for their name if we don't have it
            * Schedules a task to check the outgoing log one minute from now
        """
        async_task("apostello.tasks.log_msg_in", self.msg_params,
                   timezone.now(), self.contact.pk)
        async_task("apostello.tasks.sms_to_slack", self.sms_body,
                   str(self.contact), str(self.keyword))
        async_task("apostello.tasks.blacklist_notify", self.contact.pk,
                   self.sms_body, self.keyword)
        async_task("apostello.tasks.ask_for_name", self.contact.pk,
                   self.sms_body, self.send_name_sms)
        # update outgoing log 1 minute from now:
        schedule(
            "apostello.tasks.check_outgoing_log",
            schedule_type=Schedule.ONCE,
            next_run=timezone.now() + timedelta(minutes=1),
        )
Exemple #7
0
def generate_data_archive(user, save_path=settings.GDPR_ARCHIVE_STORAGE_PATH):
    with tempfile.TemporaryDirectory() as tmp_dir:
        user_dir = os.path.join(tmp_dir, user.slug)
        os.makedirs(user_dir)

        # dump data
        dump_user_profile(user_dir, user)
        dump_user_posts(user_dir, user)
        dump_user_comments(user_dir, user)

        # save zip archive
        archive_path = shutil.make_archive(
            os.path.join(save_path, str(user.slug)), "zip", tmp_dir)

        # remove archive after timeout
        schedule(delete_data_archive,
                 archive_path,
                 next_run=datetime.utcnow() +
                 settings.GDPR_ARCHIVE_DELETE_TIMEDELTA)

        # notify the user
        send_data_archive_ready_email(
            user=user,
            url=settings.GDPR_ARCHIVE_URL + os.path.basename(archive_path),
        )
Exemple #8
0
def generate_data_archive(user, save_path=settings.GDPR_ARCHIVE_STORAGE_PATH):
    with tempfile.TemporaryDirectory() as tmp_dir:
        user_dir = os.path.join(tmp_dir, user.slug)
        os.makedirs(user_dir)

        # dump data
        dump_user_profile(user_dir, user)
        dump_user_posts(user_dir, user)
        dump_user_comments(user_dir, user)
        dump_user_bookmarks(user_dir, user)

        # save zip archive
        archive_name = f"{user.slug}-{datetime.utcnow().strftime('%Y-%m-%d-%H-%M')}"
        archive_path = shutil.make_archive(
            os.path.join(save_path, archive_name), "zip", tmp_dir)

        # schedule a task to remove archive after timeout
        schedule("gdpr.archive.delete_data_archive",
                 archive_path,
                 next_run=datetime.utcnow() +
                 settings.GDPR_ARCHIVE_DELETE_TIMEDELTA)

        # notify the user
        send_data_archive_ready_email(
            user=user,
            url=settings.GDPR_ARCHIVE_URL + os.path.basename(archive_path),
        )
Exemple #9
0
def follow_up_emails(signal, sender, instance, created, **kwargs):
    """When a test list is completed, create Schedule objects any follow up
    notifications that need to be scheduled"""

    from qatrack.notifications.models import QCCompletedNotice

    notices = QCCompletedNotice.objects.filter(
        notification_type=QCCompletedNotice.FOLLOW_UP,
        follow_up_days__isnull=False,
        test_lists__test_lists__id=instance.test_list.id,
    ).filter(
        Q(units__units=None)
        | Q(units__units=instance.unit_test_collection.unit))

    if not notices or instance.in_progress:
        return

    if not created:
        # clear any existing scheduled notices before rescheduling
        Schedule.objects.filter(name__contains="follow-up-for-tli-%d-" %
                                instance.pk).delete()

    for notice in notices:
        follow_up = instance.work_completed + timezone.timedelta(
            days=notice.follow_up_days)
        name = "follow-up-for-tli-%d-notice-%d" % (instance.pk, notice.pk)
        schedule(
            "qatrack.notifications.qccompleted.tasks.send_follow_up_email",
            name=name,
            schedule_type=Schedule.ONCE,
            next_run=follow_up,
            test_list_instance_id=instance.pk,
            notification_id=notice.id,
        )
Exemple #10
0
def add_schedules(apps, schema_editor):
    schedule('documents.tasks.train_classifier',
             name="Train the classifier",
             schedule_type=Schedule.HOURLY)
    schedule('documents.tasks.index_optimize',
             name="Optimize the index",
             schedule_type=Schedule.DAILY)
Exemple #11
0
def add_sync_ding_user_schedule():
    """添加钉钉同步用户定时任务"""
    del_schedule(name='同步钉钉用户ID')
    schedule('common.utils.ding_api.sync_ding_user_id',
             name='同步钉钉用户ID',
             schedule_type='D',
             repeats=-1,
             timeout=-1)
def create_subscriptions_tasks():
    """
    task_name = "az-sync-resource-type"
    func = 'mce_tasks_djq.azure.sync_resource_type'

    _filter = dict(name=task_name, func=func)
    if Schedule.objects.filter(**_filter).first():
        continue

    schedule(
        func,
        subscription_id,
        name=task_name,
        schedule_type=Schedule.DAILY,
        #minutes=86400,
    )
    """

    subscriptions = models.Subscription.objects.filter(active=True)

    for subscription in subscriptions:

        subscription_id = subscription.subscription_id

        task_name = f"{subscription_id} : az-sync-resource-group"
        func = 'mce_tasks_djq.azure.sync_resource_group'

        _filter = dict(name=task_name, func=func)
        if Schedule.objects.filter(**_filter).first():
            # TODO: update schedule_type and minutes
            continue

        # TODO: settings

        # "('54d87296-b91a-47cd-93dd-955bd57b3e9a',)"
        schedule(
            func,
            subscription_id,
            name=task_name,
            schedule_type=Schedule.MINUTES,
            minutes=60,
        )

        task_name = f"{subscription_id} : az-sync-resources"
        func = 'mce_tasks_djq.azure.sync_resource'

        _filter = dict(name=task_name, func=func)
        if Schedule.objects.filter(**_filter).first():
            # TODO: update schedule_type and minutes
            continue

        # TODO: settings
        # TODO: il faut que ce soit après les groups !!!
        schedule(func,
                 subscription_id,
                 name=task_name,
                 schedule_type=Schedule.MINUTES,
                 minutes=30)
Exemple #13
0
 def delay_and_make_request(self, now=False):
     if self.total_timeshift() and not now:
         schedule('core.models.make_request',
                  self.id,
                  name=self.path,
                  next_run=self.added + self.total_timeshift())
     else:
         async_task('core.models.make_request',
                    self.id,
                    task_name=self.path)
Exemple #14
0
    def handle(self, *args, **options):

        date = datetime.datetime.now() + datetime.timedelta(days=1)
        schedule('core.djangoapps.subscription.tasks.update_statuses',
            schedule_type=Schedule.DAILY,
            next_run=datetime.datetime(date.year, date.month, date.day, 00, 00, 00, 000000))

        schedule('core.djangoapps.subscription.tasks.send_expiry_emails',
            schedule_type=Schedule.DAILY,
            next_run=datetime.datetime(date.year, date.month, date.day, 00, 00, 00, 000000))
    def handle(self, *args, **options):

        date = timezone.now() + datetime.timedelta(days=1)
        date = date.replace(hour=0, minute=0, second=0, microsecond=0)
        schedule('coldfront.core.allocation.tasks.update_statuses',
                 schedule_type=Schedule.DAILY,
                 next_run=date)

        schedule('coldfront.core.allocation.tasks.send_expiry_emails',
                 schedule_type=Schedule.DAILY,
                 next_run=date)
Exemple #16
0
def add_sqlcronjob(job_id, run_date, workflow_id, url):
    del_sqlcronjob(job_id)
    schedule('sql.utils.execute_sql.execute',
             workflow_id,
             hook='sql.utils.execute_sql.execute_callback',
             name=job_id,
             schedule_type='O',
             next_run=run_date,
             repeats=1)
    logger.debug('add_sqlcronjob:' + job_id + " run_date:" +
                 run_date.strftime('%Y-%m-%d %H:%M:%S'))
Exemple #17
0
def add_kill_conn_schedule(name, run_date, instance_id, thread_id):
    """添加/修改终止数据库连接的定时任务"""
    del_schedule(name)
    schedule('sql.query.kill_query_conn',
             instance_id,
             thread_id,
             name=name,
             schedule_type='O',
             next_run=run_date,
             repeats=1,
             timeout=-1)
    def generate_update_schedule(apps, schema_editor):
        from django_q.tasks import schedule

        schedule(
            'django.core.management.call_command',
            'background_sync',
            '--download',
            name='Sync all podcasts',
            schedule_type='D',
            repeats=-1,
        )
Exemple #19
0
 def handle(self, *args, **options):
     if Schedule.objects.count() != 0:
         Schedule.objects.all().delete()
         schedule(
             'covid_gandaki.form.management.commands.report_generate.dash_generate',
             schedule_type=Schedule.HOURLY)
         self.stdout.write('Added Successfully the dashboard tasks')
     else:
         schedule(
             'covid_gandaki.form.management.commands.report_generate.dash_generate',
             schedule_type=Schedule.HOURLY)
         self.stdout.write('The scheduled queues was added already')
def video_post_save(sender, instance, created, **kwargs):
    is_closed = False
    if created:
        schedule('apps.core.tasks.close_room',
                 instance.videoId,
                 name=instance.videoId,
                 schedule_type='I')

    if instance.closed_date is not None:
        is_closed = True

    instance.send_notification(is_closed=is_closed)
def confirm_delete_account(request, user_slug):
    if request.method != "POST":
        return redirect("edit_account", user_slug, permanent=False)

    user = get_object_or_404(User, slug=user_slug)
    if user.id != request.me.id and not request.me.is_god:
        raise Http404()

    confirmation_hash = request.POST.get("secret_hash")
    code = request.POST.get("code")
    if confirmation_hash != user.secret_hash or not code:
        raise AccessDenied(
            title="Что-то не сходится",
            message=
            "Проверьте правильность кода и попробуйте запросить удаление аккаунта еще раз"
        )

    # verify code (raises an exception)
    Code.check_code(recipient=user.email, code=code)

    # cancel payments
    cancel_all_stripe_subscriptions(user.stripe_id)

    # mark user for deletion
    user.deleted_at = datetime.utcnow()
    user.save()

    # remove sessions
    Session.objects.filter(user=user).delete()

    # schedule data cleanup task
    schedule("gdpr.forget.delete_user_data",
             user,
             next_run=datetime.utcnow() + settings.GDPR_DELETE_TIMEDELTA)

    # notify user
    async_task(
        send_delete_account_confirm_email,
        user=user,
    )

    # notify admins
    async_task(
        send_telegram_message,
        chat=ADMIN_CHAT,
        text=f"💀 Юзер удалился: {settings.APP_HOST}/user/{user.slug}/",
    )

    return render(
        request,
        "users/messages/delete_account_confirmed.html",
    )
Exemple #22
0
def welcome_mail(user):
    msg = 'Welcome to our website'
    # send this message right away
    async_task('django.core.mail.send_mail', 'Welcome', msg,
               '*****@*****.**', [user.email])
    # and this follow up email in one hour
    msg = 'Here are some tips to get you started...'
    schedule('django.core.mail.send_mail',
             'Follow up',
             msg,
             '*****@*****.**', [user.email],
             schedule_type=Schedule.ONCE,
             next_run=timezone.now() + timedelta(hours=1))
Exemple #23
0
    def schedule_email(self, subject=None, message_data=None, to_emails=[],
                       schedule_datetime=None):

        from_email = '*****@*****.**'

        # Schedule an email reminder
        schedule(
            'django.core.mail.send_mail',
            subject,
            message_data,
            from_email,
            to_emails,
            schedule_type='O',
            next_run=schedule_datetime)
Exemple #24
0
def schedule_report(s, send_time):

    logger.info("Scheduling report %s for %s" % (s.report_id, send_time))
    name = "Send report %d %s" % (s.report_id, send_time.isoformat())
    schedule(
        "qatrack.reports.tasks.send_report",
        s.id,
        name,
        name=name,
        schedule_type=Schedule.ONCE,
        repeats=1,
        next_run=send_time,
        task_name=name,
    )
Exemple #25
0
def schedule_qcreview_notice(notice, send_time):

    logger.info("Scheduling notification %s for %s" % (notice.pk, send_time))
    name = "Send notification %d %s" % (notice.pk, send_time.isoformat())

    schedule(
        "qatrack.notifications.qcreview.tasks.send_qcreview_notice",
        notice.id,
        name,
        name=name,
        schedule_type=Schedule.ONCE,
        repeats=1,
        next_run=send_time,
        task_name=name,
    )
Exemple #26
0
 def setup_mail_sending(self, subject, message, dispatch_date):
     if dispatch_date:
         Event.objects.create(context=self,
                              subject=subject,
                              run_date=dispatch_date)
         schedule(
             name=f"event_{self.slug}",
             func="core.tasks.async_send_mails",
             context_id=self.id,
             subject=subject,
             message=message,
             next_run=dispatch_date,
             schedule_type="O",
         )
     else:
         self.send_mails(subject=subject, message=message)
Exemple #27
0
    def save(self, *args, **kwargs):
        newsletter = super(MarketingEditScheduleForm, self).save(*args, **kwargs)
        if newsletter.schedule_type == 'O':
            newsletter.repeats = 0
        newsletter.save()

        # update a schedule
        repeats = newsletter.repeats
        if repeats == 0:
            # set it to 1 otherwise django-q wont run
            repeats = 1
        if newsletter.schedule:
            s = newsletter.schedule
            s.schedule_type = newsletter.schedule_type
            s.next_run = newsletter.schedule_send_dt
            s.repeats = repeats
            s.save()
        else:
            s = schedule(
                    'django.core.management.call_command',
                    'send_newsletter',
                    newsletter.id,
                    schedule_type=newsletter.schedule_type,
                    next_run=newsletter.schedule_send_dt,
                    repeats=repeats)
            newsletter.schedule = s
            newsletter.save()

        return newsletter
Exemple #28
0
    def save(self, *args, **kwargs):
        create_article = self.cleaned_data.get('create_article', False)
        newsletter = super(MarketingStepFiveForm, self).save(*args, **kwargs)
        newsletter.date_submitted = datetime.datetime.now()
        if newsletter.schedule_type == 'O':
            newsletter.repeats = 0
        newsletter.save()

        if create_article:
            newsletter.generate_article(newsletter.email.creator)

        schedule_send = self.cleaned_data.get('schedule_send', False)
        if not schedule_send:
            # not scheduled - send immediately
            newsletter.send_to_recipients()
        else:
            # make a schedule
            repeats = newsletter.repeats
            if repeats == 0:
                # set it to 1 otherwise django-q wont run
                repeats = 1
            s = schedule(
                    'django.core.management.call_command',
                    'send_newsletter',
                    newsletter.id,
                    schedule_type=newsletter.schedule_type,
                    next_run=newsletter.schedule_send_dt,
                    repeats=repeats)
            newsletter.schedule = s
            newsletter.save()

        return newsletter
Exemple #29
0
def schedule_service_event_scheduling_notice(notice, send_time):

    logger.info("Service Event Scheduling notification %s for %s" %
                (notice.pk, send_time))
    name = "Send notification %d %s" % (notice.pk, send_time.isoformat())

    schedule(
        "qatrack.notifications.service_log_scheduling.tasks.send_scheduling_notice",
        notice.id,
        name,
        name=name,
        schedule_type=Schedule.ONCE,
        repeats=1,
        next_run=send_time,
        task_name=name,
    )
Exemple #30
0
def setup():
    try:
        if settings.DEBUG:
            schedule("hyakumori_crm.contracts.tasks.update_status_task",
                     name="debug_update_status_task",
                     schedule_type=Schedule.MINUTES,
                     minutes=5,
                     repeats=5)

        schedule("hyakumori_crm.contracts.tasks.update_status_task",
                 schedule_type=Schedule.DAILY,
                 name="daily_update_status_task",
                 next_run=arrow.utcnow().to("Asia/Tokyo").replace(
                     hour=23, minute=30).datetime)
    except IntegrityError:
        print("tasks already existed")
        pass
Exemple #31
0
def test_admin_views(admin_client):
    s = schedule('sched.test')
    tag = uuid()
    f = Task.objects.create(
        id=tag[1],
        name=tag[0],
        func='test.fail',
        started=timezone.now(),
        stopped=timezone.now(),
        success=False)
    tag = uuid()
    t = Task.objects.create(
        id=tag[1],
        name=tag[0],
        func='test.succes',
        started=timezone.now(),
        stopped=timezone.now(),
        success=True)
    admin_urls = (
        # schedule
        reverse('admin:django_q_schedule_changelist'),
        reverse('admin:django_q_schedule_add'),
        reverse('admin:django_q_schedule_change', args=(s.id,)),
        reverse('admin:django_q_schedule_history', args=(s.id,)),
        reverse('admin:django_q_schedule_delete', args=(s.id,)),
        # success
        reverse('admin:django_q_success_changelist'),
        reverse('admin:django_q_success_change', args=(t.id,)),
        reverse('admin:django_q_success_history', args=(t.id,)),
        reverse('admin:django_q_success_delete', args=(t.id,)),
        # failure
        reverse('admin:django_q_failure_changelist'),
        reverse('admin:django_q_failure_change', args=(f.id,)),
        reverse('admin:django_q_failure_history', args=(f.id,)),
        reverse('admin:django_q_failure_delete', args=(f.id,)),

    )
    for url in admin_urls:
        response = admin_client.get(url)
        assert response.status_code == 200

    # resubmit the failure
    url = reverse('admin:django_q_failure_changelist')
    data = {'action': 'retry_failed',
            '_selected_action': [f.pk]}
    response = admin_client.post(url, data)
    assert response.status_code == 302
    assert Failure.objects.filter(name=f.id).exists() is False
Exemple #32
0
def test_admin_views(admin_client, monkeypatch):
    monkeypatch.setattr(Conf, 'ORM', 'default')
    s = schedule('schedule.test')
    tag = uuid()
    f = Task.objects.create(
        id=tag[1],
        name=tag[0],
        func='test.fail',
        started=timezone.now(),
        stopped=timezone.now(),
        success=False)
    tag = uuid()
    t = Task.objects.create(
        id=tag[1],
        name=tag[0],
        func='test.success',
        started=timezone.now(),
        stopped=timezone.now(),
        success=True)
    q = OrmQ.objects.create(
        key='test',
        payload=SignedPackage.dumps({'id': 1, 'func': 'test', 'name': 'test'}))
    admin_urls = (
        # schedule
        reverse('admin:django_q_schedule_changelist'),
        reverse('admin:django_q_schedule_add'),
        reverse('admin:django_q_schedule_change', args=(s.id,)),
        reverse('admin:django_q_schedule_history', args=(s.id,)),
        reverse('admin:django_q_schedule_delete', args=(s.id,)),
        # success
        reverse('admin:django_q_success_changelist'),
        reverse('admin:django_q_success_change', args=(t.id,)),
        reverse('admin:django_q_success_history', args=(t.id,)),
        reverse('admin:django_q_success_delete', args=(t.id,)),
        # failure
        reverse('admin:django_q_failure_changelist'),
        reverse('admin:django_q_failure_change', args=(f.id,)),
        reverse('admin:django_q_failure_history', args=(f.id,)),
        reverse('admin:django_q_failure_delete', args=(f.id,)),
        # orm queue
        reverse('admin:django_q_ormq_changelist'),
        reverse('admin:django_q_ormq_change', args=(q.id,)),
        reverse('admin:django_q_ormq_history', args=(q.id,)),
        reverse('admin:django_q_ormq_delete', args=(q.id,)),

    )
    for url in admin_urls:
        response = admin_client.get(url)
        assert response.status_code == 200

    # resubmit the failure
    url = reverse('admin:django_q_failure_changelist')
    data = {'action': 'retry_failed',
            '_selected_action': [f.pk]}
    response = admin_client.post(url, data)
    assert response.status_code == 302
    assert Failure.objects.filter(name=f.id).exists() is False
    # change q
    url = reverse('admin:django_q_ormq_change', args=(q.id,))
    data = {'key': 'default', 'payload': 'test', 'lock_0': '2015-09-17', 'lock_1': '14:31:51', '_save': 'Save'}
    response = admin_client.post(url, data)
    assert response.status_code == 302
    # delete q
    url = reverse('admin:django_q_ormq_delete', args=(q.id,))
    data = {'post': 'yes'}
    response = admin_client.post(url, data)
    assert response.status_code == 302