mirror of
https://gitlab.federez.net/re2o/re2o
synced 2024-06-02 16:02:16 +00:00
265 lines
8.8 KiB
Python
265 lines
8.8 KiB
Python
# -*- mode: python; coding: utf-8 -*-
|
||
# Re2o est un logiciel d'administration développé initiallement au rezometz. Il
|
||
# se veut agnostique au réseau considéré, de manière à être installable en
|
||
# quelques clics.
|
||
#
|
||
# Copyright © 2017 Gabriel Détraz
|
||
# Copyright © 2017 Goulven Kermarec
|
||
# Copyright © 2017 Augustin Lemesle
|
||
#
|
||
# This program is free software; you can redistribute it and/or modify
|
||
# it under the terms of the GNU General Public License as published by
|
||
# the Free Software Foundation; either version 2 of the License, or
|
||
# (at your option) any later version.
|
||
#
|
||
# This program is distributed in the hope that it will be useful,
|
||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
# GNU General Public License for more details.
|
||
#
|
||
# You should have received a copy of the GNU General Public License along
|
||
# with this program; if not, write to the Free Software Foundation, Inc.,
|
||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||
|
||
# -*- coding: utf-8 -*-
|
||
# David Sinquin, Gabriel Détraz, Goulven Kermarec
|
||
"""
|
||
Regroupe les fonctions transversales utiles
|
||
|
||
Fonction :
|
||
- récupérer tous les utilisateurs actifs
|
||
- récupérer toutes les machines
|
||
- récupérer tous les bans
|
||
etc
|
||
"""
|
||
|
||
|
||
from __future__ import unicode_literals
|
||
|
||
|
||
from django.utils import timezone
|
||
from django.db.models import Q
|
||
|
||
from cotisations.models import Cotisation, Facture, Paiement, Vente
|
||
from machines.models import Domain, Interface, Machine
|
||
from users.models import Adherent, User, Ban, Whitelist
|
||
from preferences.models import Service
|
||
|
||
DT_NOW = timezone.now()
|
||
|
||
|
||
def all_adherent(search_time=DT_NOW):
|
||
""" Fonction renvoyant tous les users adherents. Optimisee pour n'est
|
||
qu'une seule requete sql
|
||
Inspecte les factures de l'user et ses cotisation, regarde si elles
|
||
sont posterieur à now (end_time)"""
|
||
return User.objects.filter(
|
||
facture__in=Facture.objects.filter(
|
||
vente__in=Vente.objects.filter(
|
||
Q(type_cotisation='All') | Q(type_cotisation='Adhesion'),
|
||
cotisation__in=Cotisation.objects.filter(
|
||
vente__in=Vente.objects.filter(
|
||
facture__in=Facture.objects.all().exclude(valid=False)
|
||
)
|
||
).filter(date_end__gt=search_time)
|
||
)
|
||
)
|
||
).distinct()
|
||
|
||
|
||
def all_baned(search_time=DT_NOW):
|
||
""" Fonction renvoyant tous les users bannis """
|
||
return User.objects.filter(
|
||
ban__in=Ban.objects.filter(
|
||
date_end__gt=search_time
|
||
)
|
||
).distinct()
|
||
|
||
|
||
def all_whitelisted(search_time=DT_NOW):
|
||
""" Fonction renvoyant tous les users whitelistes """
|
||
return User.objects.filter(
|
||
whitelist__in=Whitelist.objects.filter(
|
||
date_end__gt=search_time
|
||
)
|
||
).distinct()
|
||
|
||
|
||
def all_has_access(search_time=DT_NOW):
|
||
""" Renvoie tous les users beneficiant d'une connexion
|
||
: user adherent ou whiteliste et non banni """
|
||
return User.objects.filter(
|
||
Q(state=User.STATE_ACTIVE) &
|
||
~Q(ban__in=Ban.objects.filter(date_end__gt=search_time)) &
|
||
(Q(whitelist__in=Whitelist.objects.filter(date_end__gt=search_time)) |
|
||
Q(facture__in=Facture.objects.filter(
|
||
vente__in=Vente.objects.filter(
|
||
cotisation__in=Cotisation.objects.filter(
|
||
Q(type_cotisation='All') | Q(type_cotisation='Connexion'),
|
||
vente__in=Vente.objects.filter(
|
||
facture__in=Facture.objects.all()
|
||
.exclude(valid=False)
|
||
)
|
||
).filter(date_end__gt=search_time)
|
||
)
|
||
)))
|
||
).distinct()
|
||
|
||
|
||
def filter_active_interfaces(interface_set):
|
||
"""Filtre les machines autorisées à sortir sur internet dans une requête"""
|
||
return interface_set.filter(
|
||
machine__in=Machine.objects.filter(
|
||
user__in=all_has_access()
|
||
).filter(active=True)
|
||
).select_related('domain').select_related('machine')\
|
||
.select_related('type').select_related('ipv4')\
|
||
.select_related('domain__extension').select_related('ipv4__ip_type')\
|
||
.distinct()
|
||
|
||
|
||
def all_active_interfaces():
|
||
"""Renvoie l'ensemble des machines autorisées à sortir sur internet """
|
||
return filter_active_interfaces(Interface.objects)
|
||
|
||
|
||
def all_active_assigned_interfaces():
|
||
""" Renvoie l'ensemble des machines qui ont une ipv4 assignées et
|
||
disposant de l'accès internet"""
|
||
return all_active_interfaces().filter(ipv4__isnull=False)
|
||
|
||
|
||
def all_active_interfaces_count():
|
||
""" Version light seulement pour compter"""
|
||
return Interface.objects.filter(
|
||
machine__in=Machine.objects.filter(
|
||
user__in=all_has_access()
|
||
).filter(active=True)
|
||
)
|
||
|
||
|
||
def all_active_assigned_interfaces_count():
|
||
""" Version light seulement pour compter"""
|
||
return all_active_interfaces_count().filter(ipv4__isnull=False)
|
||
|
||
class SortTable:
|
||
""" Class gathering uselful stuff to sort the colums of a table, according
|
||
to the column and order requested. It's used with a dict of possible
|
||
values and associated model_fields """
|
||
|
||
# All the possible possible values
|
||
# The naming convention is based on the URL or the views function
|
||
# The syntax to describe the sort to apply is a dict where the keys are
|
||
# the url value and the values are a list of model field name to use to
|
||
# order the request. They are applied in the order they are given.
|
||
# A 'default' might be provided to specify what to do if the requested col
|
||
# doesn't match any keys.
|
||
USERS_INDEX = {
|
||
'user_name': ['name'],
|
||
'user_surname': ['surname'],
|
||
'user_pseudo': ['pseudo'],
|
||
'user_room': ['room'],
|
||
'default': ['state', 'pseudo']
|
||
}
|
||
USERS_INDEX_BAN = {
|
||
'ban_user': ['user__pseudo'],
|
||
'ban_start': ['date_start'],
|
||
'ban_end': ['date_end'],
|
||
'default': ['-date_end']
|
||
}
|
||
USERS_INDEX_WHITE = {
|
||
'white_user': ['user__pseudo'],
|
||
'white_start': ['date_start'],
|
||
'white_end': ['date_end'],
|
||
'default': ['-date_end']
|
||
}
|
||
MACHINES_INDEX = {
|
||
'machine_name': ['name'],
|
||
'default': ['pk']
|
||
}
|
||
COTISATIONS_INDEX = {
|
||
'cotis_user': ['user__pseudo'],
|
||
'cotis_paiement': ['paiement__moyen'],
|
||
'cotis_date': ['date'],
|
||
'cotis_id': ['id'],
|
||
'default': ['-date']
|
||
}
|
||
COTISATIONS_CONTROL = {
|
||
'control_name': ['user__adherent__name'],
|
||
'control_surname': ['user__surname'],
|
||
'control_paiement': ['paiement'],
|
||
'control_date': ['date'],
|
||
'control_valid': ['valid'],
|
||
'control_control': ['control'],
|
||
'control_id': ['id'],
|
||
'control_user-id': ['user__id'],
|
||
'default': ['-date']
|
||
}
|
||
TOPOLOGIE_INDEX = {
|
||
'switch_dns': ['switch_interface__domain__name'],
|
||
'switch_ip': ['switch_interface__ipv4__ipv4'],
|
||
'switch_loc': ['location'],
|
||
'switch_ports': ['number'],
|
||
'switch_stack': ['stack__name'],
|
||
'default': ['location', 'stack', 'stack_member_id']
|
||
}
|
||
TOPOLOGIE_INDEX_PORT = {
|
||
'port_port': ['port'],
|
||
'port_room': ['room__name'],
|
||
'port_interface': ['machine_interface__domain__name'],
|
||
'port_related': ['related__switch__name'],
|
||
'port_radius': ['radius'],
|
||
'port_vlan': ['vlan_force__name'],
|
||
'default': ['port']
|
||
}
|
||
TOPOLOGIE_INDEX_ROOM = {
|
||
'room_name': ['name'],
|
||
'default': ['name']
|
||
}
|
||
TOPOLOGIE_INDEX_STACK = {
|
||
'stack_name': ['name'],
|
||
'stack_id': ['stack_id'],
|
||
'default': ['stack_id'],
|
||
}
|
||
TOPOLOGIE_INDEX_MODEL_SWITCH = {
|
||
'model_switch_name': ['reference'],
|
||
'model_switch__contructor' : ['constructor__name'],
|
||
'default': ['reference'],
|
||
}
|
||
TOPOLOGIE_INDEX_CONSTRUCTOR_SWITCH = {
|
||
'room_name': ['name'],
|
||
'default': ['name'],
|
||
}
|
||
LOGS_INDEX = {
|
||
'sum_date': ['revision__date_created'],
|
||
'default': ['-revision__date_created'],
|
||
}
|
||
LOGS_STATS_LOGS = {
|
||
'logs_author': ['user__name'],
|
||
'logs_date': ['date_created'],
|
||
'default': ['-date_created']
|
||
}
|
||
|
||
@staticmethod
|
||
def sort(request, col, order, values):
|
||
""" Check if the given values are possible and add .order_by() and
|
||
a .reverse() as specified according to those values """
|
||
fields = values.get(col, None)
|
||
if not fields:
|
||
fields = values.get('default', [])
|
||
request = request.order_by(*fields)
|
||
if values.get(col, None) and order == 'desc':
|
||
return request.reverse()
|
||
else:
|
||
return request
|
||
|
||
|
||
def remove_user_room(room):
|
||
""" Déménage de force l'ancien locataire de la chambre """
|
||
try:
|
||
user = Adherent.objects.get(room=room)
|
||
except Adherent.DoesNotExist:
|
||
return
|
||
user.room = None
|
||
user.save()
|