rezometz/re2o
8
0
Fork 0
mirror of https://gitlab2.federez.net/re2o/re2o synced 2024-11-25 22:22:26 +00:00
Code Issues Releases Wiki Activity

Fix history inheritence

Browse source
This commit is contained in:
Jean-Romain Garnier 2020-04-23 15:46:30 +00:00 committed by Supelec Rezo Rennes
parent 8b83f9f4bc
commit 9a88fe1d08
1 changed files with 50 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
logs/models.py
View file

@ -79,7 +79,7 @@ class MachineHistorySearchEvent:
class MachineHistorySearch:
def __init__(self):
self.events = []
self.__last_evt = None
self._last_evt = None
def get(self, search, params):
"""
@ -93,13 +93,13 @@ class MachineHistorySearch:
self.events = []
if search_type == "ip":
return self.__get_by_ip(search)[::-1]
return self._get_by_ip(search)[::-1]
elif search_type == "mac":
return self.__get_by_mac(search)[::-1]
return self._get_by_mac(search)[::-1]
return None
def __add_revision(self, user, machine, interface):
def _add_revision(self, user, machine, interface):
"""
Add a new revision to the chronological order
:param user: User, The user owning the maching at the time of the event
@ -110,16 +110,16 @@ class MachineHistorySearch:
evt.start_date = interface.revision.date_created
# Try not to recreate events if it's unnecessary
if evt.is_similar(self.__last_evt):
if evt.is_similar(self._last_evt):
return
# Mark the end of validity of the last element
if self.__last_evt and not self.__last_evt.end_date:
self.__last_evt.end_date = evt.start_date
if self._last_evt and not self._last_evt.end_date:
self._last_evt.end_date = evt.start_date
# If the event ends before the given date, remove it
if self.start and evt.start_date.date() < self.start:
self.__last_evt = None
self._last_evt = None
self.events.pop()
# Make sure the new event starts before the given end date
@ -128,9 +128,9 @@ class MachineHistorySearch:
# Save the new element
self.events.append(evt)
self.__last_evt = evt
self._last_evt = evt
def __get_interfaces_for_ip(self, ip):
def _get_interfaces_for_ip(self, ip):
"""
:param ip: str
:return: An iterable object with the Version objects
@ -147,7 +147,7 @@ class MachineHistorySearch:
Version.objects.get_for_model(Interface).order_by("revision__date_created")
)
def __get_interfaces_for_mac(self, mac):
def _get_interfaces_for_mac(self, mac):
"""
:param mac: str
:return: An iterable object with the Version objects
@ -158,7 +158,7 @@ class MachineHistorySearch:
Version.objects.get_for_model(Interface).order_by("revision__date_created")
)
def __get_machines_for_interface(self, interface):
def _get_machines_for_interface(self, interface):
"""
:param interface: Version, the interface for which to find the machines
:return: An iterable object with the Version objects of Machine to
@ -170,7 +170,7 @@ class MachineHistorySearch:
Version.objects.get_for_model(Machine).order_by("revision__date_created")
)
def __get_user_for_machine(self, machine):
def _get_user_for_machine(self, machine):
"""
:param machine: Version, the machine of which the owner must be found
:return: The user to which the given machine belongs
@ -179,35 +179,35 @@ class MachineHistorySearch:
user_id = machine.field_dict["user_id"]
return User.objects.get(id=user_id)
def __get_by_ip(self, ip):
def _get_by_ip(self, ip):
"""
:param ip: str, The IP to lookup
:returns: list, a list of MachineHistorySearchEvent
"""
interfaces = self.__get_interfaces_for_ip(ip)
interfaces = self._get_interfaces_for_ip(ip)
for interface in interfaces:
machines = self.__get_machines_for_interface(interface)
machines = self._get_machines_for_interface(interface)
for machine in machines:
user = self.__get_user_for_machine(machine)
self.__add_revision(user, machine, interface)
user = self._get_user_for_machine(machine)
self._add_revision(user, machine, interface)
return self.events
def __get_by_mac(self, mac):
def _get_by_mac(self, mac):
"""
:param mac: str, The MAC address to lookup
:returns: list, a list of MachineHistorySearchEvent
"""
interfaces = self.__get_interfaces_for_mac(mac)
interfaces = self._get_interfaces_for_mac(mac)
for interface in interfaces:
machines = self.__get_machines_for_interface(interface)
machines = self._get_machines_for_interface(interface)
for machine in machines:
user = self.__get_user_for_machine(machine)
self.__add_revision(user, machine, interface)
user = self._get_user_for_machine(machine)
self._add_revision(user, machine, interface)
return self.events
@ -226,7 +226,7 @@ class HistoryEvent:
self.performed_by = version.revision.user
self.comment = version.revision.get_comment() or None
def __repr(self, name, value):
def _repr(self, name, value):
"""
Returns the best representation of the given field
:param name: the name of the field
@ -253,8 +253,8 @@ class HistoryEvent:
else:
edits.append((
field,
self.__repr(field, self.previous_version.field_dict[field]),
self.__repr(field, self.version.field_dict[field])
self._repr(field, self.previous_version.field_dict[field]),
self._repr(field, self.version.field_dict[field])
))
return edits
@ -263,9 +263,9 @@ class HistoryEvent:
class History:
def __init__(self):
self.events = []
self.__last_version = None
self._last_version = None
def __compute_diff(self, v1, v2, ignoring=[]):
def _compute_diff(self, v1, v2, ignoring=[]):
"""
Find the edited field between two versions
:param v1: Version
@ -290,10 +290,10 @@ class UserHistoryEvent(HistoryEvent):
:param previous_version: Version, the version of the user before this event
:param edited_fields: list, The list of modified fields by this event
"""
super(UserHistoryEvent, self).init(version, previous_version, edited_fields)
super(UserHistoryEvent, self).__init__(version, previous_version, edited_fields)
self.user = user
def __repr(self, name, value):
def _repr(self, name, value):
"""
Returns the best representation of the given field
:param name: the name of the field
@ -386,7 +386,7 @@ class UserHistoryEvent(HistoryEvent):
class UserHistory(History):
def __init__(self):
super(UserHistory, self).init()
super(UserHistory, self).__init__()
def get(self, user):
"""
@ -402,24 +402,24 @@ class UserHistory(History):
obj = Club.objects.get(user_ptr_id=user.id)
# Get all the versions for this user, with the oldest first
self.__last_version = None
self._last_version = None
user_versions = filter(
lambda x: x.field_dict["id"] == user.id,
Version.objects.get_for_model(User).order_by("revision__date_created")
)
for version in user_versions:
self.__add_revision(user, version)
self._add_revision(user, version)
# Do the same thing for the Adherent of Club
self.__last_version = None
self._last_version = None
obj_versions = filter(
lambda x: x.field_dict["id"] == obj.id,
Version.objects.get_for_model(type(obj)).order_by("revision__date_created")
)
for version in obj_versions:
self.__add_revision(user, version)
self._add_revision(user, version)
# Remove duplicates and sort
self.events = list(dict.fromkeys(self.events))
@ -429,28 +429,28 @@ class UserHistory(History):
reverse=True
)
def __add_revision(self, user, version):
def _add_revision(self, user, version):
"""
Add a new revision to the chronological order
:param user: User, The user displayed in this history
:param version: Version, The version of the user for this event
"""
diff = None
if self.__last_version is not None:
diff = self.__compute_diff(
if self._last_version is not None:
diff = self._compute_diff(
version,
self.__last_version,
self._last_version,
ignoring=["last_login", "pwd_ntlm", "email_change_date"]
)
# Ignore "empty" events like login
if not diff:
self.__last_version = version
self._last_version = version
return
evt = UserHistoryEvent(user, version, self.__last_version, diff)
evt = UserHistoryEvent(user, version, self._last_version, diff)
self.events.append(evt)
self.__last_version = version
self._last_version = version
class InterfaceHistoryEvent(HistoryEvent):
@ -466,31 +466,31 @@ class InterfaceHistory:
self.events = []
# Get all the versions for this interface, with the oldest first
self.__last_version = None
self._last_version = None
user_versions = filter(
lambda x: x.field_dict["id"] == interface_id,
Version.objects.get_for_model(Interface).order_by("revision__date_created")
)
for version in user_versions:
self.__add_revision(version)
self._add_revision(version)
return self.events[::-1]
def __add_revision(self, version):
def _add_revision(self, version):
"""
Add a new revision to the chronological order
:param version: Version, The version of the interface for this event
"""
diff = None
if self.__last_version is not None:
diff = self.__compute_diff(version, self.__last_version)
if self._last_version is not None:
diff = self._compute_diff(version, self._last_version)
# Ignore "empty" events
if not diff:
self.__last_version = version
self._last_version = version
return
evt = InterfaceHistoryEvent(version, self.__last_version, diff)
evt = InterfaceHistoryEvent(version, self._last_version, diff)
self.events.append(evt)
self.__last_version = version
self._last_version = version