134 lines
4.9 KiB
Python
134 lines
4.9 KiB
Python
from functools import cached_property
|
|
from uuid import uuid4
|
|
|
|
from django.contrib import messages
|
|
from django.http import Http404
|
|
from django.shortcuts import redirect
|
|
from django.urls import reverse
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.views.generic import FormView, ListView, TemplateView
|
|
|
|
from c3nav.mesh.forms import MeshMessageFilterForm, MeshMessageForm
|
|
from c3nav.mesh.messages import MeshMessage, MeshMessageType
|
|
from c3nav.mesh.models import MeshNode, NodeMessage
|
|
from c3nav.mesh.utils import get_node_names, group_msg_type_choices
|
|
from c3nav.mesh.views.base import MeshControlMixin
|
|
|
|
|
|
class MeshMessageListView(MeshControlMixin, ListView):
|
|
model = NodeMessage
|
|
template_name = "mesh/mesh_messages.html"
|
|
ordering = "-datetime"
|
|
paginate_by = 20
|
|
context_object_name = "mesh_messages"
|
|
|
|
def get_queryset(self):
|
|
qs = super().get_queryset()
|
|
|
|
self.form = MeshMessageFilterForm(self.request.GET)
|
|
if self.form.is_valid():
|
|
if self.form.cleaned_data['message_types']:
|
|
qs = qs.filter(message_type__in=self.form.cleaned_data['message_types'])
|
|
if self.form.cleaned_data['src_nodes']:
|
|
qs = qs.filter(src_node__in=self.form.cleaned_data['src_nodes'])
|
|
|
|
return qs
|
|
|
|
def get_context_data(self, *args, **kwargs):
|
|
ctx = super().get_context_data(*args, **kwargs)
|
|
|
|
form_data = self.request.GET.copy()
|
|
form_data.pop('page', None)
|
|
|
|
ctx.update({
|
|
"node_names": get_node_names(),
|
|
"send_msg_types": group_msg_type_choices({msg_type for msg_type in MeshMessageForm.msg_types.keys()}),
|
|
'form': self.form,
|
|
'form_data': form_data.urlencode(),
|
|
})
|
|
return ctx
|
|
|
|
def post(self, request):
|
|
return redirect(
|
|
reverse("mesh.send", kwargs={"msg_type": request.POST.get("send_msg_type", "")})
|
|
)
|
|
|
|
|
|
class MeshMessageSendView(MeshControlMixin, FormView):
|
|
template_name = "mesh/mesh_message_send.html"
|
|
|
|
@cached_property
|
|
def msg_type(self):
|
|
return MeshMessageType[self.kwargs['msg_type']]
|
|
|
|
def get_form_class(self):
|
|
try:
|
|
return MeshMessageForm.get_form_for_type(self.msg_type)
|
|
except KeyError:
|
|
raise Http404('unknown message type')
|
|
|
|
def get_form_kwargs(self):
|
|
return {
|
|
**super().get_form_kwargs(),
|
|
'recipient': self.kwargs.get('recipient', None),
|
|
}
|
|
|
|
def get_initial(self):
|
|
if 'recipient' in self.kwargs and self.msg_type.name.startswith('CONFIG_'):
|
|
try:
|
|
node = MeshNode.objects.get(address=self.kwargs['recipient'])
|
|
except MeshNode.DoesNotExist:
|
|
pass
|
|
else:
|
|
initial = node.last_messages[self.msg_type].parsed.content.model_dump(mode="json")
|
|
while keys := tuple(key for key, value in initial.items() if isinstance(value, dict)):
|
|
for key in keys:
|
|
subdict = initial.pop(key)
|
|
for subkey, value in subdict.items():
|
|
initial[key+"_"+subkey.removeprefix(key).lstrip('_')] = value
|
|
return initial
|
|
|
|
if 'address' in self.request.GET and self.msg_type == MeshMessageType.MESH_ROUTE_REQUEST:
|
|
return {"address": self.request.GET["address"]}
|
|
|
|
return {}
|
|
|
|
def get_success_url(self):
|
|
if 'recipient' in self.kwargs and False:
|
|
return reverse('mesh.node.detail', kwargs={'pk': self.kwargs['recipient']})
|
|
else:
|
|
return self.request.path
|
|
|
|
def form_valid(self, form):
|
|
if 'noscript' in self.request.POST:
|
|
form.send()
|
|
messages.success(self.request, _('Message sent successfully(?)'))
|
|
return super().form_valid(form)
|
|
uuid = uuid4()
|
|
self.request.session["mesh_msg_%s" % uuid] = {
|
|
"success_url": self.get_success_url(),
|
|
"recipients": form.get_recipients(),
|
|
"msg_data": form.get_msg_data(),
|
|
}
|
|
return redirect(reverse('mesh.sending', kwargs={'uuid': uuid}))
|
|
|
|
|
|
class MeshMessageSendingView(MeshControlMixin, TemplateView):
|
|
template_name = "mesh/mesh_message_sending.html"
|
|
|
|
def get_context_data(self, uuid):
|
|
try:
|
|
data = self.request.session["mesh_msg_%s" % uuid]
|
|
except KeyError:
|
|
raise Http404
|
|
node_names = get_node_names()
|
|
return {
|
|
**super().get_context_data(),
|
|
"node_names": node_names,
|
|
"send_uuid": uuid,
|
|
**data,
|
|
"node_name": node_names.get(data["msg_data"]["content"].get("address"), ""),
|
|
"recipients": [(address, node_names[address]) for address in data["recipients"]],
|
|
"msg_type": MeshMessageType[data["msg_data"]["content"]["msg_type"]].pretty_name,
|
|
"msg_type_raw": MeshMessageType[data["msg_data"]["content"]["msg_type"]],
|
|
}
|