|
|
|
@ -333,554 +333,3 @@ class ObtainExpiringAuthToken(ObtainAuthToken): |
|
|
|
'token': token.key, |
|
|
|
'expiration_date': token.created + token_duration |
|
|
|
}) |
|
|
|
|
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def services(_request): |
|
|
|
# """The list of the different services and servers couples |
|
|
|
# |
|
|
|
# Return: |
|
|
|
# GET: |
|
|
|
# A JSONSuccess response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each service-server couple) |
|
|
|
# containing: |
|
|
|
# * a field `server`: the server name |
|
|
|
# * a field `service`: the service name |
|
|
|
# * a field `need_regen`: does the service need a regeneration ? |
|
|
|
# """ |
|
|
|
# |
|
|
|
# service_link = (Service_link.objects.all() |
|
|
|
# .select_related('server__domain') |
|
|
|
# .select_related('service')) |
|
|
|
# seria = ServicesSerializer(service_link, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET', 'POST']) |
|
|
|
# def services_server_service_regen(request, server_name, service_name): |
|
|
|
# """The status of a particular service linked to a particular server. |
|
|
|
# Mark the service as regenerated if POST used. |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSucess response with a field `data` containing: |
|
|
|
# * a field `need_regen`: does the service need a regeneration ? |
|
|
|
# |
|
|
|
# POST: |
|
|
|
# An empty JSONSuccess response. |
|
|
|
# """ |
|
|
|
# |
|
|
|
# query = Service_link.objects.filter( |
|
|
|
# service__in=Service.objects.filter(service_type=service_name), |
|
|
|
# server__in=Interface.objects.filter( |
|
|
|
# domain__in=Domain.objects.filter(name=server_name) |
|
|
|
# ) |
|
|
|
# ) |
|
|
|
# if not query: |
|
|
|
# return JSONError("This service is not active for this server") |
|
|
|
# |
|
|
|
# service = query.first() |
|
|
|
# if request.method == 'GET': |
|
|
|
# return JSONSuccess({'need_regen': service.need_regen()}) |
|
|
|
# else: |
|
|
|
# service.done_regen() |
|
|
|
# return JSONSuccess() |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def services_server(_request, server_name): |
|
|
|
# """The list of services attached to a specific server |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSuccess response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each service) containing: |
|
|
|
# * a field `name`: the name of a service |
|
|
|
# """ |
|
|
|
# |
|
|
|
# query = Service_link.objects.filter( |
|
|
|
# server__in=Interface.objects.filter( |
|
|
|
# domain__in=Domain.objects.filter(name=server_name) |
|
|
|
# ) |
|
|
|
# ) |
|
|
|
# if not query: |
|
|
|
# return JSONError("This service is not active for this server") |
|
|
|
# |
|
|
|
# services_objects = query.all() |
|
|
|
# seria = ServiceLinkSerializer(services_objects, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_mac_ip_dns(_request): |
|
|
|
# """The list of all active interfaces with all the associated infos |
|
|
|
# (MAC, IP, IpType, DNS name and associated zone extension) |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each interface) containing: |
|
|
|
# * a field `ipv4` containing: |
|
|
|
# * a field `ipv4`: the ip for this interface |
|
|
|
# * a field `ip_type`: the name of the IpType of this interface |
|
|
|
# * a field `ipv6` containing `null` if ipv6 is deactivated else: |
|
|
|
# * a field `ipv6`: the ip for this interface |
|
|
|
# * a field `ip_type`: the name of the IpType of this interface |
|
|
|
# * a field `mac_address`: the MAC of this interface |
|
|
|
# * a field `domain`: the DNS name for this interface |
|
|
|
# * a field `extension`: the extension for the DNS zone of this |
|
|
|
# interface |
|
|
|
# """ |
|
|
|
# |
|
|
|
# interfaces = all_active_assigned_interfaces(full=True) |
|
|
|
# seria = FullInterfaceSerializer(interfaces, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_alias(_request): |
|
|
|
# """The list of all the alias used and the DNS info associated |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each alias) containing: |
|
|
|
# * a field `name`: the alias used |
|
|
|
# * a field `cname`: the target of the alias (real name of the |
|
|
|
# interface) |
|
|
|
# * a field `cname_entry`: the entry to write in the DNS to have |
|
|
|
# the alias |
|
|
|
# * a field `extension`: the extension for the DNS zone of this |
|
|
|
# interface |
|
|
|
# """ |
|
|
|
# |
|
|
|
# alias = (Domain.objects |
|
|
|
# .filter(interface_parent=None) |
|
|
|
# .filter( |
|
|
|
# cname__in=Domain.objects.filter( |
|
|
|
# interface_parent__in=Interface.objects.exclude(ipv4=None) |
|
|
|
# ) |
|
|
|
# ) |
|
|
|
# .select_related('extension') |
|
|
|
# .select_related('cname__extension')) |
|
|
|
# seria = DomainSerializer(alias, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def accesspoint_ip_dns(_request): |
|
|
|
# """The list of all active interfaces with all the associated infos |
|
|
|
# (MAC, IP, IpType, DNS name and associated zone extension) |
|
|
|
# |
|
|
|
# Only display access points. Use to gen unifi controler names |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each interface) containing: |
|
|
|
# * a field `ipv4` containing: |
|
|
|
# * a field `ipv4`: the ip for this interface |
|
|
|
# * a field `ip_type`: the name of the IpType of this interface |
|
|
|
# * a field `ipv6` containing `null` if ipv6 is deactivated else: |
|
|
|
# * a field `ipv6`: the ip for this interface |
|
|
|
# * a field `ip_type`: the name of the IpType of this interface |
|
|
|
# * a field `mac_address`: the MAC of this interface |
|
|
|
# * a field `domain`: the DNS name for this interface |
|
|
|
# * a field `extension`: the extension for the DNS zone of this |
|
|
|
# interface |
|
|
|
# """ |
|
|
|
# |
|
|
|
# interfaces = (all_active_assigned_interfaces(full=True) |
|
|
|
# .filter(machine__accesspoint__isnull=False)) |
|
|
|
# seria = FullInterfaceSerializer(interfaces, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_corresp(_request): |
|
|
|
# """The list of the IpTypes possible with the infos about each |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each IpType) containing: |
|
|
|
# * a field `type`: the name of the type |
|
|
|
# * a field `extension`: the DNS extension associated |
|
|
|
# * a field `domain_ip_start`: the first ip to use for this type |
|
|
|
# * a field `domain_ip_stop`: the last ip to use for this type |
|
|
|
# * a field `prefix_v6`: `null` if IPv6 is deactivated else the |
|
|
|
# prefix to use |
|
|
|
# * a field `ouverture_ports_tcp_in`: the policy for TCP IN ports |
|
|
|
# * a field `ouverture_ports_tcp_out`: the policy for TCP OUT ports |
|
|
|
# * a field `ouverture_ports_udp_in`: the policy for UDP IN ports |
|
|
|
# * a field `ouverture_ports_udp_out`: the policy for UDP OUT ports |
|
|
|
# """ |
|
|
|
# |
|
|
|
# ip_type = IpType.objects.all().select_related('extension') |
|
|
|
# seria = TypeSerializer(ip_type, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_mx(_request): |
|
|
|
# """The list of MX record to add to the DNS |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each MX record) containing: |
|
|
|
# * a field `zone`: the extension for the concerned zone |
|
|
|
# * a field `priority`: the priority to use |
|
|
|
# * a field `name`: the name of the target |
|
|
|
# * a field `mx_entry`: the full entry to add in the DNS for this |
|
|
|
# MX record |
|
|
|
# """ |
|
|
|
# |
|
|
|
# mx = (Mx.objects.all() |
|
|
|
# .select_related('zone') |
|
|
|
# .select_related('name__extension')) |
|
|
|
# seria = MxSerializer(mx, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_ns(_request): |
|
|
|
# """The list of NS record to add to the DNS |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each NS record) containing: |
|
|
|
# * a field `zone`: the extension for the concerned zone |
|
|
|
# * a field `ns`: the DNS name for the NS server targeted |
|
|
|
# * a field `ns_entry`: the full entry to add in the DNS for this |
|
|
|
# NS record |
|
|
|
# """ |
|
|
|
# |
|
|
|
# ns = (Ns.objects |
|
|
|
# .exclude( |
|
|
|
# ns__in=Domain.objects.filter( |
|
|
|
# interface_parent__in=Interface.objects.filter(ipv4=None) |
|
|
|
# ) |
|
|
|
# ) |
|
|
|
# .select_related('zone') |
|
|
|
# .select_related('ns__extension')) |
|
|
|
# seria = NsSerializer(ns, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_txt(_request): |
|
|
|
# """The list of TXT record to add to the DNS |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each TXT record) containing: |
|
|
|
# * a field `zone`: the extension for the concerned zone |
|
|
|
# * a field `field1`: the first field in the record (target) |
|
|
|
# * a field `field2`: the second field in the record (value) |
|
|
|
# * a field `txt_entry`: the full entry to add in the DNS for this |
|
|
|
# TXT record |
|
|
|
# """ |
|
|
|
# |
|
|
|
# txt = Txt.objects.all().select_related('zone') |
|
|
|
# seria = TxtSerializer(txt, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_srv(_request): |
|
|
|
# """The list of SRV record to add to the DNS |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each SRV record) containing: |
|
|
|
# * a field `extension`: the extension for the concerned zone |
|
|
|
# * a field `service`: the name of the service concerned |
|
|
|
# * a field `protocole`: the name of the protocol to use |
|
|
|
# * a field `ttl`: the Time To Live to use |
|
|
|
# * a field `priority`: the priority for this service |
|
|
|
# * a field `weight`: the weight for same priority entries |
|
|
|
# * a field `port`: the port targeted |
|
|
|
# * a field `target`: the interface targeted by this service |
|
|
|
# * a field `srv_entry`: the full entry to add in the DNS for this |
|
|
|
# SRV record |
|
|
|
# """ |
|
|
|
# |
|
|
|
# srv = (Srv.objects.all() |
|
|
|
# .select_related('extension') |
|
|
|
# .select_related('target__extension')) |
|
|
|
# seria = SrvSerializer(srv, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dns_zones(_request): |
|
|
|
# """The list of the zones managed |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each zone) containing: |
|
|
|
# * a field `name`: the extension for the zone |
|
|
|
# * a field `origin`: the server IPv4 for the orgin of the zone |
|
|
|
# * a field `origin_v6`: `null` if ipv6 is deactivated else the |
|
|
|
# server IPv6 for the origin of the zone |
|
|
|
# * a field `soa` containing: |
|
|
|
# * a field `mail` containing the mail to contact in case of |
|
|
|
# problem with the zone |
|
|
|
# * a field `param` containing the full soa paramters to use |
|
|
|
# in the DNS for this zone |
|
|
|
# * a field `zone_entry`: the full entry to add in the DNS for the |
|
|
|
# origin of the zone |
|
|
|
# """ |
|
|
|
# |
|
|
|
# zones = Extension.objects.all().select_related('origin') |
|
|
|
# seria = ExtensionSerializer(zones, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def firewall_ouverture_ports(_request): |
|
|
|
# """The list of the ports authorized to be openned by the firewall |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSuccess response with a `data` field containing: |
|
|
|
# * a field `ipv4` containing: |
|
|
|
# * a field `tcp_in` containing: |
|
|
|
# * a list of port number where ipv4 tcp in should be ok |
|
|
|
# * a field `tcp_out` containing: |
|
|
|
# * a list of port number where ipv4 tcp ou should be ok |
|
|
|
# * a field `udp_in` containing: |
|
|
|
# * a list of port number where ipv4 udp in should be ok |
|
|
|
# * a field `udp_out` containing: |
|
|
|
# * a list of port number where ipv4 udp out should be ok |
|
|
|
# * a field `ipv6` containing: |
|
|
|
# * a field `tcp_in` containing: |
|
|
|
# * a list of port number where ipv6 tcp in should be ok |
|
|
|
# * a field `tcp_out` containing: |
|
|
|
# * a list of port number where ipv6 tcp ou should be ok |
|
|
|
# * a field `udp_in` containing: |
|
|
|
# * a list of port number where ipv6 udp in should be ok |
|
|
|
# * a field `udp_out` containing: |
|
|
|
# * a list of port number where ipv6 udp out should be ok |
|
|
|
# """ |
|
|
|
# |
|
|
|
# r = {'ipv4': {}, 'ipv6': {}} |
|
|
|
# for o in (OuverturePortList.objects.all() |
|
|
|
# .prefetch_related('ouvertureport_set') |
|
|
|
# .prefetch_related('interface_set', 'interface_set__ipv4')): |
|
|
|
# pl = { |
|
|
|
# "tcp_in": set(map( |
|
|
|
# str, |
|
|
|
# o.ouvertureport_set.filter( |
|
|
|
# protocole=OuverturePort.TCP, |
|
|
|
# io=OuverturePort.IN |
|
|
|
# ) |
|
|
|
# )), |
|
|
|
# "tcp_out": set(map( |
|
|
|
# str, |
|
|
|
# o.ouvertureport_set.filter( |
|
|
|
# protocole=OuverturePort.TCP, |
|
|
|
# io=OuverturePort.OUT |
|
|
|
# ) |
|
|
|
# )), |
|
|
|
# "udp_in": set(map( |
|
|
|
# str, |
|
|
|
# o.ouvertureport_set.filter( |
|
|
|
# protocole=OuverturePort.UDP, |
|
|
|
# io=OuverturePort.IN |
|
|
|
# ) |
|
|
|
# )), |
|
|
|
# "udp_out": set(map( |
|
|
|
# str, |
|
|
|
# o.ouvertureport_set.filter( |
|
|
|
# protocole=OuverturePort.UDP, |
|
|
|
# io=OuverturePort.OUT |
|
|
|
# ) |
|
|
|
# )), |
|
|
|
# } |
|
|
|
# for i in filter_active_interfaces(o.interface_set): |
|
|
|
# if i.may_have_port_open(): |
|
|
|
# d = r['ipv4'].get(i.ipv4.ipv4, {}) |
|
|
|
# d["tcp_in"] = (d.get("tcp_in", set()) |
|
|
|
# .union(pl["tcp_in"])) |
|
|
|
# d["tcp_out"] = (d.get("tcp_out", set()) |
|
|
|
# .union(pl["tcp_out"])) |
|
|
|
# d["udp_in"] = (d.get("udp_in", set()) |
|
|
|
# .union(pl["udp_in"])) |
|
|
|
# d["udp_out"] = (d.get("udp_out", set()) |
|
|
|
# .union(pl["udp_out"])) |
|
|
|
# r['ipv4'][i.ipv4.ipv4] = d |
|
|
|
# if i.ipv6(): |
|
|
|
# for ipv6 in i.ipv6(): |
|
|
|
# d = r['ipv6'].get(ipv6.ipv6, {}) |
|
|
|
# d["tcp_in"] = (d.get("tcp_in", set()) |
|
|
|
# .union(pl["tcp_in"])) |
|
|
|
# d["tcp_out"] = (d.get("tcp_out", set()) |
|
|
|
# .union(pl["tcp_out"])) |
|
|
|
# d["udp_in"] = (d.get("udp_in", set()) |
|
|
|
# .union(pl["udp_in"])) |
|
|
|
# d["udp_out"] = (d.get("udp_out", set()) |
|
|
|
# .union(pl["udp_out"])) |
|
|
|
# r['ipv6'][ipv6.ipv6] = d |
|
|
|
# return JSONSuccess(r) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def dhcp_mac_ip(_request): |
|
|
|
# """The list of all active interfaces with all the associated infos |
|
|
|
# (MAC, IP, IpType, DNS name and associated zone extension) |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSON Success response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each interface) containing: |
|
|
|
# * a field `ipv4` containing: |
|
|
|
# * a field `ipv4`: the ip for this interface |
|
|
|
# * a field `ip_type`: the name of the IpType of this interface |
|
|
|
# * a field `mac_address`: the MAC of this interface |
|
|
|
# * a field `domain`: the DNS name for this interface |
|
|
|
# * a field `extension`: the extension for the DNS zone of this |
|
|
|
# interface |
|
|
|
# """ |
|
|
|
# |
|
|
|
# interfaces = all_active_assigned_interfaces() |
|
|
|
# seria = InterfaceSerializer(interfaces, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def mailing_standard(_request): |
|
|
|
# """All the available standard mailings. |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSucess response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each mailing) containing: |
|
|
|
# * a field `name`: the name of a mailing |
|
|
|
# """ |
|
|
|
# |
|
|
|
# return JSONSuccess([ |
|
|
|
# {'name': 'adherents'} |
|
|
|
# ]) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def mailing_standard_ml_members(_request, ml_name): |
|
|
|
# """All the members of a specific standard mailing |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSucess response with a field `data` containing: |
|
|
|
# * a list if dictionnaries (one for each member) containing: |
|
|
|
# * a field `email`: the email of the member |
|
|
|
# * a field `name`: the name of the member |
|
|
|
# * a field `surname`: the surname of the member |
|
|
|
# * a field `pseudo`: the pseudo of the member |
|
|
|
# """ |
|
|
|
# |
|
|
|
# # All with active connextion |
|
|
|
# if ml_name == 'adherents': |
|
|
|
# members = all_has_access().values('email').distinct() |
|
|
|
# # Unknown mailing |
|
|
|
# else: |
|
|
|
# return JSONError("This mailing does not exist") |
|
|
|
# seria = MailingMemberSerializer(members, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def mailing_club(_request): |
|
|
|
# """All the available club mailings. |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSucess response with a field `data` containing: |
|
|
|
# * a list of dictionnaries (one for each mailing) containing: |
|
|
|
# * a field `name` indicating the name of a mailing |
|
|
|
# """ |
|
|
|
# |
|
|
|
# clubs = Club.objects.filter(mailing=True).values('pseudo') |
|
|
|
# seria = MailingSerializer(clubs, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
# |
|
|
|
# |
|
|
|
# @csrf_exempt |
|
|
|
# @login_required |
|
|
|
# @permission_required('machines.serveur') |
|
|
|
# @accept_method(['GET']) |
|
|
|
# def mailing_club_ml_members(_request, ml_name): |
|
|
|
# """All the members of a specific club mailing |
|
|
|
# |
|
|
|
# Returns: |
|
|
|
# GET: |
|
|
|
# A JSONSucess response with a field `data` containing: |
|
|
|
# * a list if dictionnaries (one for each member) containing: |
|
|
|
# * a field `email`: the email of the member |
|
|
|
# * a field `name`: the name of the member |
|
|
|
# * a field `surname`: the surname of the member |
|
|
|
# * a field `pseudo`: the pseudo of the member |
|
|
|
# """ |
|
|
|
# |
|
|
|
# try: |
|
|
|
# club = Club.objects.get(mailing=True, pseudo=ml_name) |
|
|
|
# except Club.DoesNotExist: |
|
|
|
# return JSONError("This mailing does not exist") |
|
|
|
# members = club.administrators.all().values('email').distinct() |
|
|
|
# seria = MailingMemberSerializer(members, many=True) |
|
|
|
# return JSONSuccess(seria.data) |
|
|
|
|
Maël Kervella
8 years ago