def get(self, request):
search = request.GET['name']
query = models.Spot.objects.filter(name__contains=search)
serializer = serializers.SpotSerializers(query, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def put(self, request, pk=None):
return Response({"metthod", "put"})
def delete(self, request, pk=None):
return Response({"method", "delete"})
def get(self, request, teaching, format=None):
senders = EmailSender.objects.filter(teaching=teaching, groups__in=request.user.groups.all())\
.distinct()\
.order_by('sender_email_name')
serializer = EmailSenderSerializer(senders, many=True)
return Response(serializer.data)
def put(self, request, format=None):
file_obj = request.FILES['file']
attachment = EmailAttachment(attachment=file_obj)
attachment.save()
serializer = EmailAttachmentSerializer(attachment)
return Response(data=serializer.data, status=status.HTTP_201_CREATED)
def update(self, request, pk=None):
return Response({'HTTP_method': 'PUT'})
def destroy(self, request, pk=None):
return Response({'HTTP_method': 'DELETE'})
def create(self, request, *args, **kwargs):
self.handle_sessions()
super().create(request, *args, **kwargs)
tasks = self.request.user.terminal.task_set.filter(is_finished=False)
serializer = self.task_serializer_class(tasks, many=True)
return Response(serializer.data, status=201)
def list(self, request, *args, **kwargs):
queryset = self.multi_command_storage.filter()
serializer = self.serializer_class(queryset, many=True)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
if not settings.SECURITY_SERVICE_ACCOUNT_REGISTRATION:
data = {"error": "service account registration disabled"}
return Response(data=data, status=status.HTTP_400_BAD_REQUEST)
return super().create(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
dist = {"url": get_qrcode(request.user)}
return Response(dist, status=status.HTTP_201_CREATED)
def get(self, request):
config = request.user.terminal.config
return Response(config, status=200)
def logout(request, response: Response, data: dict):
if not request.session.is_empty():
request.session.delete('user')
response.delete_cookie('sessionid')
response.data = {'login': '******'}
return response
def delete(self, request, pk):
query = models.Spot.objects.get(pk=pk)
query.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def list(self, request):
a_viewset = [
'Uses actions list, create, retrieve, update, partial_update'
]
return Response({"message": "Hello", 'aviset': a_viewset})
def post(self, request):
storage_name = str(request.data.get('name'))
Setting.delete_storage('TERMINAL_COMMAND_STORAGE', storage_name)
return Response({"msg": _('Delete succeed')}, status=200)
def retrieve(self, request, pk=None):
return Response({'HTTP_method': 'GET'})
def update(self, request, *args, **kwargs):
return Response({'info': '转换成功'}, status=status.HTTP_201_CREATED)
def partial_update(self, request, pk=None):
return Response({'HTTP_method': 'PATCH'})
def delete(self, request, pk, format=None):
access_token = request.META.get('HTTP_X_ACCESS_TOKEN')
decoded = jwt.decode(access_token, SECRET_KEY)
idea = get_object_or_404(Idea, pk=pk, user_id=decoded['id'])
idea.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request):
user = request.user
terminal = user.terminal
configs = terminal.config
return Response(configs, status=200)
def get(self, request, **kwargs):
data = {}
if request.user.is_authenticated:
data = self.serializers(request.user).data
return Response(data)
def get(self, request, format=None):
emails = EmailNotification.objects.all().order_by("-datetime_created")
serializer = EmailNotificationSerializer(emails, many=True)
return Response(serializer.data)
def put(self, request, pk=None):
return Response({'message': 'put'})
def post(self, request, *args, **kw):
email_to_sent = EmailNotification()
email_to_sent.email_from = request.data.get('email_from')
email_to_sent.to_type = request.data.get('to_type')
email_to_sent.email_to = request.data.get(
'email_to') # Come as ['group1,group2,group3'].
email_to_sent.subject = request.data.get('subject')
email_to_sent.body = request.data.get('email_content')
email_to_sent.teaching = request.data.get('teaching')
try:
template = MailTemplateModel.objects.get(
id=request.data.get('template', -1))
email_to_sent.answers = template
except ObjectDoesNotExist:
pass
email_to_sent.datetime_created = timezone.now()
email_to_sent.save()
tags = request.data.get('tags', None) # Come as ['tag1,tag2,tag3'].
if tags:
tags = EmailTag.objects.filter(name__in=tags[0].split(','))
email_to_sent.tags = tags
attachments = request.data.get('attachments', '').split(',')
if attachments[0]:
for a in attachments:
email_attach = EmailAttachment.objects.get(pk=int(a))
email_to_sent.attachments.add(email_attach)
email_to_sent.save()
email_to_sent.errors = "Prepared."
send_type = request.data.get('send_type')
responsibles = request.data.get('responsibles', 'true') == 'true'
# Render body message.
template = get_template("mail_notification/email.html")
context = {
'body': email_to_sent.body,
'to_teachers': email_to_sent.to_type == 'teachers',
}
if email_to_sent.attachments.all():
html_files = "<ul>"
file_names_urls = map(
lambda a:
(os.path.basename(a.attachment.path)[9:],
a.attachment.url.replace("local.isln.be", "app.isln.be")),
email_to_sent.attachments.all())
for name, url in file_names_urls:
html_files += '<li><a href="%s">%s</a></li>\n' % (url, name)
html_files += "</ul>"
context['files'] = html_files
# Add a link to a form if asked.
if email_to_sent.answers:
url = "https://local.isln.be/mail_answer/answer/specific_uuid/"
answers_settings = AnswersSettings.objects.first()
if answers_settings and answers_settings.use_remote:
url = url.replace("local.isln.be", "app.isln.be")
context['link_to_form'] = url
email_to_sent.body = template.render(context)
email_to_sent.save()
task = task_send_emails_notif.apply_async(countdown=5,
kwargs={
'pk': email_to_sent.pk,
'responsibles':
responsibles,
})
return Response(status=status.HTTP_201_CREATED)
def patch(self, request, pk=None):
return Response({'message': 'patch'})
def patch(self, request, pk=None):
return Response({"method", "patch"})
def delete(self, request, pk=None):
return Response({'message': 'delete'})
def retrieve(self, request, pk=None):
""" Getting data from the database """
return Response({"http_meesage": "get"})
def post(self, request):
serializer = serializers.SpotSerializers(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
