def send_message(self, content="", group=None, sent_by="", eta=None):
"""
Send SMS to an individual.
If the person is blocking us, we skip them.
"""
if not content:
# No content, skip sending a message
logger.info("Message content empty, skip api call")
return
if self.is_blocking or self.never_contact:
return
elif eta is None:
async_task("apostello.tasks.recipient_send_message_task", self.pk,
content, group, sent_by)
else:
try:
groupObj = RecipientGroup.objects.get(name=group)
except RecipientGroup.DoesNotExist as e:
groupObj = None
QueuedSms.objects.create(time_to_send=eta,
content=content,
sent_by=sent_by,
recipient_group=groupObj,
recipient=self)
def save(self, *args, **kwargs):
"""Override save method to invalidate cache."""
super(SmsInbound, self).save(*args, **kwargs)
# invalidate per person last sms cache
cache.set("last_msg__{0}".format(self.sender_num), None, 0)
# update number of matched responses caches
async_task("apostello.tasks.populate_keyword_response_count")
def spawn_eligible(self):
for fileset in self._enum_eligible_filesets():
async_task('planb.tasks.conditional_run',
fileset.pk,
broker=get_broker(settings.Q_MAIN_QUEUE),
q_options={'hook': 'planb.core.tasks.finalize_run'})
logger.info('[%s] Scheduled backup', fileset)
def handle(self, *args, **options):
d = {}
for username in ins_list:
try:
profile = instaloader.Profile.from_username(
instagram_v2.ins.context, username)
d[profile.full_name] = (profile.userid,
profile.profile_pic_url)
except Exception as e:
self.stderr.write(e)
for k, v in d.items():
m: Member = Member.objects.filter(
english_name__icontains=k).first()
if m:
user_id, profile_pic_url = v
m.instagram_id = str(user_id)
if not m.avatar:
media = Media.objects.create(original_url=profile_pic_url)
m.avatar = media
m.save()
async_task(media.download_to_local)
self.stdout.write(
f'{m.english_name} with instagram_id {m.instagram_id}')
def system_modificator(request):
""" function to modify many systems at once (helper function to call the real function) """
# form was valid to post
if request.method == "POST":
request_post = request.POST
request_user = request.user
# call async function
async_task(
"dfirtrack_main.modificator.system_modificator.system_modificator_async",
request_post,
request_user,
)
return redirect(reverse('system_list'))
# show empty form
else:
form = SystemModificatorForm(initial={
'systemstatus': 2,
'analysisstatus': 1,
})
# call logger
debug_logger(str(request.user), " SYSTEM_MODIFICATOR_ENTERED")
return render(request, 'dfirtrack_main/system/system_modificator.html',
{'form': form})
def get(self, request, torrent_id=None, *args, **kwargs):
if torrent_id == None:
async_task('subprocess.call', [secrets.transmission_sync_script])
else:
async_task('subprocess.call', [secrets.transmission_sync_script, torrent_id])
return HttpResponse()
def execute(request):
workflow_id = request.POST['workflow_id']
if workflow_id == '' or workflow_id is None:
context = {'errMsg': 'workflow_id参数为空.'}
return render(request, 'error.html', context)
workflow_id = int(workflow_id)
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
instance_name = workflow_detail.instance_name
db_name = workflow_detail.db_name
url = get_detail_url(request, workflow_id)
if can_execute(request.user, workflow_id) is False:
context = {'errMsg': '你无权操作当前工单！'}
return render(request, 'error.html', context)
# 判断是否高危SQL，禁止执行
if SysConfig().sys_config.get('critical_ddl_regex', '') != '':
if InceptionDao().critical_ddl(workflow_detail.sql_content):
context = {'errMsg': '高危语句，禁止执行！'}
return render(request, 'error.html', context)
# 将流程状态修改为执行中，并更新reviewok_time字段
workflow_detail.status = Const.workflowStatus['executing']
workflow_detail.reviewok_time = timezone.now()
workflow_detail.save()
async_task('sql.utils.execute_sql.execute',
workflow_detail.id,
hook='sql.utils.execute_sql.execute_callback')
return HttpResponseRedirect(reverse('sql:detail', args=(workflow_id, )))
def systemsorted(request):
""" exports markdown report for all systems (helper function to call the real function) """
request_user = request.user
# call logger
debug_logger(str(request_user),
" SYSTEM_EXPORTER_MARKDOWN_SYSTEMSORTED_BEGIN")
# check variables
stop_exporter_markdown = check_config(request)
# leave if variables caused errors
if stop_exporter_markdown:
return
# show immediate message for user (but only if no errors have occured before)
messages.success(request,
'System exporter markdown (sorted by system) started')
# call async function
async_task(
"dfirtrack_main.exporter.markdown.systemsorted.systemsorted_async",
request_user,
)
return
def dump_data_json(request):
async_task("logserver.tasks.dump_data_to_json",
q_options={'task_name': 'dump_to_json'})
messages.success(
request,
'Added Job to dump Messages to json. File will be stored in ./media')
return redirect("appsettings-index")
def update_payment(request):
import json
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = OrderPaymentForm(request.POST)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
order_id = form.cleaned_data['id']
payment_date = form.cleaned_data['payment_date']
payment_ref = form.cleaned_data['payment_date']
# Create Order
user = User.objects.get(username=request.user)
order = Order.objects.get(name=order_id, user=user)
# print(booking,ref,order_name,booking_obj,user)
order.paid = True
order.payment_date = ''
order.payment_ref = ''
order.save()
# Added on July 2,2021 -- To delete QRID redis
qrid = order.qrid
async_task('utility.payment.delete_payment_channel', qrid)
# redirect to a new URL:
return HttpResponseRedirect(
reverse_lazy('order:detail', kwargs={'pk': order.id}))
# if a GET (or any other method) we'll create a blank form
else:
form = CreateOrderForm()
return render(request, 'order/order_form.html', {'form': form})
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
# Added on July 5,2021 -- To delete QRID redis
qrid = self.object.qrid
async_task('utility.payment.delete_payment_channel', qrid)
self.object.delete()
return redirect(self.get_success_url())
def test_bad_secret(broker, monkeypatch):
broker.list_key = 'test_bad_secret:q'
async_task('math.copysign', 1, -1, broker=broker)
stop_event = Event()
stop_event.set()
start_event = Event()
cluster_id = uuidlib.uuid4()
s = Sentinel(stop_event,
start_event,
cluster_id=cluster_id,
broker=broker,
start=False)
Stat(s).save()
# change the SECRET
monkeypatch.setattr(Conf, "SECRET_KEY", "OOPS")
stat = Stat.get_all()
assert len(stat) == 0
assert Stat.get(pid=s.parent_pid, cluster_id=cluster_id) is None
task_queue = Queue()
pusher(task_queue, stop_event, broker=broker)
result_queue = Queue()
task_queue.put('STOP')
worker(
task_queue,
result_queue,
Value('f', -1),
)
assert result_queue.qsize() == 0
broker.delete_queue()
def request_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_string = request.POST.get("confirm")
if confirmation_string != settings.GDPR_DELETE_CONFIRMATION:
raise BadRequest(
title="Неправильная строка подтверждения",
message=
f"Вы должны в точности написать \"{settings.GDPR_DELETE_CONFIRMATION}\" "
f"чтобы запустить процедуру удаления аккаунта")
DataRequests.register_forget_request(user)
code = Code.create_for_user(user=user,
recipient=user.email,
length=settings.GDPR_DELETE_CODE_LENGTH)
async_task(send_delete_account_request_email, user=user, code=code)
return render(request, "users/messages/delete_account_requested.html",
{"user": user})
def update(self, instance, validated_data):
instance.created = validated_data.get('created', instance.created)
instance.updated = validated_data.get('updated', instance.updated)
instance.survey = validated_data.get('survey', instance.survey)
answers = self.initial_data['answers']
for answer in answers:
if answer.get('id', None):
ans = models.Answer.objects.get(id=answer['id'])
ans.body = answer['body']
ans.updated = timezone.now()
ans.save()
else:
models.Answer.objects.create(
question=answer['question'],
response=instance,
body=answer["body"],
created=timezone.now(),
updated=timezone.now(),
)
instance.photo.all().delete()
photos = validated_data.get('photo', [])
content_type = ContentType.objects.get(model='response',
app_label='lists')
for photo in photos:
models.Attachment.objects.create(object_id=instance.id,
content_type=content_type,
**photo)
async_task(tasks.basic_report, instance)
return instance
def _consume(filepath):
if os.path.isdir(filepath):
return
if not os.path.isfile(filepath):
logger.debug(f"Not consuming file {filepath}: File has moved.")
return
if not is_file_ext_supported(os.path.splitext(filepath)[1]):
logger.warning(
f"Not consuming file {filepath}: Unknown file extension.")
return
tag_ids = None
try:
if settings.CONSUMER_SUBDIRS_AS_TAGS:
tag_ids = _tags_from_path(filepath)
except Exception as e:
logger.exception("Error creating tags from path")
try:
async_task("documents.tasks.consume_file",
filepath,
override_tag_ids=tag_ids if tag_ids else None,
task_name=os.path.basename(filepath)[:100])
except Exception as e:
# Catch all so that the consumer won't crash.
# This is also what the test case is listening for to check for
# errors.
logger.exception("Error while consuming document")
def intro(request):
if (request.me.is_profile_complete and request.me.is_profile_reviewed
and not request.me.is_profile_rejected):
return redirect("profile", request.me.slug)
if request.method == "POST":
form = UserIntroForm(request.POST, request.FILES, instance=request.me)
if form.is_valid():
user = form.save(commit=False)
# send to moderation
user.is_profile_complete = True
user.is_profile_reviewed = False
user.is_profile_rejected = False
user.save()
# create intro post
intro_post = Post.upsert_user_intro(user,
form.cleaned_data["intro"],
is_visible=False)
# notify moderators to review profile
async_task(notify_profile_needs_review, user, intro_post)
return redirect("on_review")
else:
existing_intro = Post.get_user_intro(request.me)
form = UserIntroForm(
instance=request.me,
initial={"intro": existing_intro.text if existing_intro else ""},
)
return render(request, "users/intro.html", {"form": form})
def task_creator(request):
""" function to create many tasks for many systems at once (helper function to call the real function) """
# form was valid to post
if request.method == 'POST':
request_post = request.POST
request_user = request.user
# call async function
async_task(
"dfirtrack_main.creator.task_creator.task_creator_async",
request_post,
request_user,
)
return redirect(reverse('task_list'))
# show empty form
else:
form = TaskCreatorForm(initial={
'taskpriority': 2,
'taskstatus': 1,
})
# call logger
debug_logger(str(request.user), " TASK_CREATOR_ENTERED")
return render(request, 'dfirtrack_main/task/task_creator.html',
{'form': form})
def handle_irm_snapshot_post_save(sender, instance, created, raw, using,
update_fields, **kwargs):
async_task(
tasks.import_irm_snapshot,
snapshot_id=instance.id,
task_name="Import IRM Snappshot file of infrastructue projects",
)
def test_max_rss(broker, monkeypatch):
# set up the Sentinel
broker.list_key = 'test_max_rss_test:q'
async_task('django_q.tests.tasks.multiply', 2, 2, broker=broker)
start_event = Event()
stop_event = Event()
cluster_id = uuidlib.uuid4()
# override settings
monkeypatch.setattr(Conf, 'MAX_RSS', 40000)
monkeypatch.setattr(Conf, 'WORKERS', 1)
# set a timer to stop the Sentinel
threading.Timer(3, stop_event.set).start()
s = Sentinel(stop_event, start_event, cluster_id=cluster_id, broker=broker)
assert start_event.is_set()
assert s.status() == Conf.STOPPED
assert s.reincarnations == 1
async_task('django_q.tests.tasks.multiply', 2, 2, broker=broker)
task_queue = Queue()
result_queue = Queue()
# push the task
pusher(task_queue, stop_event, broker=broker)
# worker should exit on recycle
worker(task_queue, result_queue, Value('f', -1))
# check if the work has been done
assert result_queue.qsize() == 1
# save_limit test
monkeypatch.setattr(Conf, 'SAVE_LIMIT', 1)
result_queue.put('STOP')
# run monitor
monitor(result_queue)
assert Success.objects.count() == Conf.SAVE_LIMIT
broker.delete_queue()
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
letter_title = self.object.title
letter_body = render_to_string(
f"letter/{self.model.letter_type}_detail.html", context=context)
letter_send_date = self.object.send_date
letter_addresbook_ids = [
entry.id for entry in self.object.addressbooks.all()
]
async_task(
SPSender.add_campaigns,
hook=CreateCampaignView.assign_campaigns,
from_email="*****@*****.**",
from_name="ИД Животноводство",
subject=letter_title,
body=letter_body,
send_date=letter_send_date,
addressbook_ids=letter_addresbook_ids,
letter=self.object,
)
self.object.status = Letter.Status.PENDING
self.object.save()
return HttpResponseRedirect(
reverse(f"admin:letter_{self.model.letter_type}_changelist"))
def handle_irm_snapshot_post_delete(sender, instance, using, **kwargs):
async_task(
tasks.index_irm_projects,
snapshot_id=instance.id,
task_name=
"Update infrastructure projects search index following snapshot deletion",
)
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
document = serializer.validated_data['document']
document_data = serializer.validated_data['document_data']
correspondent_id = serializer.validated_data['correspondent_id']
document_type_id = serializer.validated_data['document_type_id']
tag_ids = serializer.validated_data['tag_ids']
title = serializer.validated_data['title']
t = int(mktime(datetime.now().timetuple()))
os.makedirs(settings.SCRATCH_DIR, exist_ok=True)
with tempfile.NamedTemporaryFile(prefix="paperless-upload-",
dir=settings.SCRATCH_DIR,
delete=False) as f:
f.write(document_data)
os.utime(f.name, times=(t, t))
async_task("documents.tasks.consume_file",
f.name,
override_filename=document.name,
override_title=title,
override_correspondent_id=correspondent_id,
override_document_type_id=document_type_id,
override_tag_ids=tag_ids,
task_name=os.path.basename(document.name)[:100])
return Response("OK")
def intro(request):
if request.me.moderation_status == User.MODERATION_STATUS_APPROVED:
return redirect("profile", request.me.slug)
if request.method == "POST":
form = UserIntroForm(request.POST, request.FILES, instance=request.me)
if form.is_valid():
user = form.save(commit=False)
# send to moderation
user.moderation_status = User.MODERATION_STATUS_ON_REVIEW
user.save()
# create intro post
intro_post = Post.upsert_user_intro(user,
form.cleaned_data["intro"],
is_visible=False)
Geo.update_for_user(user)
# notify moderators to review profile
async_task(notify_profile_needs_review, user, intro_post)
return redirect("on_review")
else:
existing_intro = Post.get_user_intro(request.me)
form = UserIntroForm(
instance=request.me,
initial={"intro": existing_intro.text if existing_intro else ""},
)
return render(request, "users/intro.html", {"form": form})
def block_notify(request):
"""block_notify.
:param request:
"""
async_task('registration.tasks.query_transactions')
return JsonResponse({"Transactions": "Qeuried"})
def execute(request):
workflow_id = request.POST['workflow_id']
if workflow_id == '' or workflow_id is None:
context = {'errMsg': 'workflow_id参数为空.'}
return render(request, 'error.html', context)
workflow_id = int(workflow_id)
workflow_detail = SqlWorkflow.objects.get(id=workflow_id)
if can_execute(request.user, workflow_id) is False:
context = {'errMsg': '你无权操作当前工单！'}
return render(request, 'error.html', context)
# 将流程状态修改为执行中，并更新reviewok_time字段
workflow_detail.status = 'workflow_executing'
workflow_detail.reviewok_time = timezone.now()
workflow_detail.save()
async_task('sql.utils.execute_sql.execute', workflow_detail.id, hook='sql.utils.execute_sql.execute_callback',
timeout=-1)
# 增加工单日志
audit_id = Audit.detail_by_workflow_id(workflow_id=workflow_id,
workflow_type=WorkflowDict.workflow_type['sqlreview']).audit_id
Audit.add_log(audit_id=audit_id,
operation_type=5,
operation_type_desc='执行工单',
operation_info="人工操作执行",
operator=request.user.username,
operator_display=request.user.display
)
return HttpResponseRedirect(reverse('sql:detail', args=(workflow_id,)))
def tag_creator(request):
""" function to create many tags for many systems at once (helper function to call the real function) """
# form was valid to post
if request.method == 'POST':
# get objects from request object
request_post = request.POST
request_user = request.user
# show immediate message for user
messages.success(request, 'Tag creator started')
# call async function
async_task(
"dfirtrack_main.creator.tag_creator.tag_creator_async",
request_post,
request_user,
)
# return directly to tag list
return redirect(reverse('tag_list'))
# show empty form
else:
form = TagCreatorForm()
# call logger
debug_logger(str(request.user), " TAG_CREATOR_ENTERED")
return render(request, 'dfirtrack_main/tag/tag_creator.html',
{'form': form})
def execute(request):
"""
执行SQL
:param request:
:return:
"""
# 校验多个权限
if not (request.user.has_perm('sql.sql_execute')
or request.user.has_perm('sql.sql_execute_for_resource_group')):
raise PermissionDenied
workflow_id = int(request.POST.get('workflow_id', 0))
if workflow_id == 0:
context = {'errMsg': 'workflow_id参数为空.'}
return render(request, 'error.html', context)
if can_execute(request.user, workflow_id) is False:
context = {'errMsg': '你无权操作当前工单！'}
return render(request, 'error.html', context)
if on_correct_time_period(workflow_id) is False:
context = {'errMsg': '不在可执行时间范围内，如果需要修改执行时间请重新提交工单!'}
return render(request, 'error.html', context)
# 根据执行模式进行对应修改
mode = request.POST.get('mode')
if mode == "auto":
status = "workflow_executing"
operation_type = 5
operation_type_desc = '执行工单'
operation_info = "自动操作执行"
finish_time = None
else:
status = "workflow_finish"
operation_type = 6
operation_type_desc = '手工工单'
operation_info = "确认手工执行结束"
finish_time = datetime.datetime.now()
# 将流程状态修改为对应状态
SqlWorkflow(
id=workflow_id, status=status,
finish_time=finish_time).save(update_fields=['status', 'finish_time'])
# 增加工单日志
audit_id = Audit.detail_by_workflow_id(
workflow_id=workflow_id,
workflow_type=WorkflowDict.workflow_type['sqlreview']).audit_id
Audit.add_log(audit_id=audit_id,
operation_type=operation_type,
operation_type_desc=operation_type_desc,
operation_info=operation_info,
operator=request.user.username,
operator_display=request.user.display)
if mode == "auto":
# 加入执行队列
async_task('sql.utils.execute_sql.execute',
workflow_id,
hook='sql.utils.execute_sql.execute_callback',
timeout=-1,
task_name=f'sqlreview-execute-{workflow_id}')
return HttpResponseRedirect(reverse('sql:detail', args=(workflow_id, )))
def log(
cls,
action,
model_instance,
obj_pk=None,
user=None,
remote_ip=None,
template_data=None,
changes=None,
request=None,
created_at=None,
):
"""
Usage:
>>> from hyakumori_crm.crm.models import Forest
>>> forest = Forest.objects.first()
>>> ActivityService.log(ForestActions.created, forest)
"""
if changes is None:
changes = {}
if request is not None:
if remote_ip is None:
remote_ip = get_remote_ip(request)
if user is None and request.user is not None:
user = request.user
try:
template_name = action[0] if isinstance(action, tuple) else action
template = MessageTemplate.objects.get(name=template_name)
content_type = ContentType.objects.get_for_model(model_instance)
log = ActionLog.objects.create(
content_type=content_type,
object_pk=obj_pk if obj_pk is not None else model_instance.pk,
template_name=template.name,
template_data=template_data,
changes=changes,
user=user,
remote_ip=remote_ip,
)
if created_at is not None:
log.created_at = created_at
async_task(
slack_notify,
message=template.template,
user_fullname=user.full_name,
dt=log.created_at,
obj_title=model_instance.REPR_NAME,
obj_name=model_instance.repr_name(),
ack_failure=True,
)
return log.save(update_fields=["created_at"])
except Exception as e:
cls.logger.warning(
f"Error while creating activity log for {action} {model_instance}",
exc_info=e,
)
return ActionLog.objects.none()
def retry_failed(FailAdmin, request, queryset):
"""Submit selected tasks back to the queue."""
for task in queryset:
async_task(task.func,
*task.args or (),
hook=task.hook,
**task.kwargs or {})
task.delete()
def download():
async_task(
func=get_cykliste_sobe_layer.get_cs_features_layer_func,
cache_key=get_cykliste_sobe_layer.cache_key,
cache_time=get_cykliste_sobe_layer.long_cache_time,
save_to_file=get_cykliste_sobe_layer.features_file_path,
save=True,
sync=True)
def alesco_import(self, request):
"""Displays a form prompting user to upload an Excel spreadsheet of
employee data from Alesco. Temporary measure until database link is
worked out.
"""
context = dict(
site.each_context(request),
title='Alesco data import'
)
if request.method == 'POST':
form = self.AlescoImportForm(request.POST, request.FILES)
if form.is_valid():
upload = request.FILES['spreadsheet']
# Run the task asynchronously.
async_task(alesco_data_import, upload)
messages.info(request, 'Alesco data spreadsheet uploaded successfully; data is now being processed.')
return redirect('admin:organisation_departmentuser_changelist')
else:
form = self.AlescoImportForm()
context['form'] = form
return TemplateResponse(request, 'organisation/alesco_import.html', context)
def test_cached(broker):
broker.purge_queue()
broker.cache.clear()
group = 'cache_test'
# queue the tests
task_id = async_task('math.copysign', 1, -1, cached=True, broker=broker)
async_task('math.copysign', 1, -1, cached=True, broker=broker, group=group)
async_task('math.copysign', 1, -1, cached=True, broker=broker, group=group)
async_task('math.copysign', 1, -1, cached=True, broker=broker, group=group)
async_task('math.copysign', 1, -1, cached=True, broker=broker, group=group)
async_task('math.copysign', 1, -1, cached=True, broker=broker, group=group)
async_task('math.popysign', 1, -1, cached=True, broker=broker, group=group)
iter_id = async_iter('math.floor', [i for i in range(10)], cached=True)
# test wait on cache
# test wait timeout
assert result(task_id, wait=10, cached=True) is None
assert fetch(task_id, wait=10, cached=True) is None
assert result_group(group, wait=10, cached=True) is None
assert result_group(group, count=2, wait=10, cached=True) is None
assert fetch_group(group, wait=10, cached=True) is None
assert fetch_group(group, count=2, wait=10, cached=True) is None
# run a single inline cluster
task_count = 17
assert broker.queue_size() == task_count
task_queue = Queue()
stop_event = Event()
stop_event.set()
for i in range(task_count):
pusher(task_queue, stop_event, broker=broker)
assert broker.queue_size() == 0
assert task_queue.qsize() == task_count
task_queue.put('STOP')
result_queue = Queue()
worker(task_queue, result_queue, Value('f', -1))
assert result_queue.qsize() == task_count
result_queue.put('STOP')
monitor(result_queue)
assert result_queue.qsize() == 0
# assert results
assert result(task_id, wait=500, cached=True) == -1
assert fetch(task_id, wait=500, cached=True).result == -1
# make sure it's not in the db backend
assert fetch(task_id) is None
# assert group
assert count_group(group, cached=True) == 6
assert count_group(group, cached=True, failures=True) == 1
assert result_group(group, cached=True) == [-1, -1, -1, -1, -1]
assert len(result_group(group, cached=True, failures=True)) == 6
assert len(fetch_group(group, cached=True)) == 6
assert len(fetch_group(group, cached=True, failures=False)) == 5
delete_group(group, cached=True)
assert count_group(group, cached=True) is None
delete_cached(task_id)
assert result(task_id, cached=True) is None
assert fetch(task_id, cached=True) is None
# iter cached
assert result(iter_id) is None
assert result(iter_id, cached=True) is not None
broker.cache.clear()
def confirm_account(self, template='users/email/account_confirmation.html', extra_context=None, subject=None):
"""
Sends out an account confirm email. Which contains a link to set the user's password.
This method is also used for the password_reset mechanism.
"""
async_task('users.schedule.send_confirmation_mail', self, template, extra_context, subject)
def do_sync():
async_task('django_q.tests.tasks.countdown', 1, sync=True, save=True)
def retry_failed(FailAdmin, request, queryset):
"""Submit selected tasks back to the queue."""
for task in queryset:
async_task(task.func, *task.args or (), hook=task.hook, **task.kwargs or {})
task.delete()
def ping_sweep(self, request, queryset):
for obj in queryset:
async_task('status.utils.run_scan', obj.id)
self.message_user(request, 'A ping sweep has been scheduled for these scan ranges.')
def run_full_scan(self, request, queryset):
async_task('status.utils.run_all')
self.message_user(request, 'A full scan has been scheduled.')
def run_scan_plugins(self, request, queryset):
for plugin in queryset:
async_task('status.utils.run_plugin', plugin.id)
self.message_user(request, 'The scan plugins have been scheduled to run.')
def send(self, *args, **kwargs):
# Send asynchronously via Django-Q
from django_q.tasks import async_task
async_task(self._send, *args, group='django-slack', q_options=kwargs)
