class Lock(models.Model):
lock_id = models.CharField(editable=True, max_length=255)
lock_type = models.CharField(max_length=2,
choices=lock_type_choices,
default='CL')
mac_address = MACAddressField(null=True, blank=True)
unlock_key = models.CharField(editable=True, max_length=255, blank=True)
def __str__(self):
return str(self.lock_id)
class Location(models.Model):
time = models.DateTimeField(verbose_name='Timestamp')
source_address = MACAddressField(verbose_name='Source address',
integer=False)
x = models.IntegerField(verbose_name='x-coordinate')
y = models.IntegerField(verbose_name='y-coordinate')
def __unicode__(self):
return 'Time: %s | SA: %s | x: %s | y: %s' % (
self.time, self.source_address, self.x, self.y)
class DeviceInfo(models.Model):
identity = models.CharField(verbose_name='Identity', max_length=100)
mac_address = MACAddressField(verbose_name='Mac address', integer=False)
def __unicode__(self):
return 'Identity: %s | Mac address: %s' % (self.identity,
self.mac_address)
class Meta:
unique_together = ["identity", "mac_address"]
class Device(models.Model):
name = models.CharField(max_length=100, default='Computer')
mac = MACAddressField(default='00:12:3c:37:64:8f')
secret = models.CharField(max_length=12, default='0a1b3c4d5e6f')
description = models.TextField(default='This is a dank-ass description for a dank-af device')
target_address = models.GenericIPAddressField(default="255.255.255.255")
target_port = models.SmallIntegerField(default=9)
listener = models.BooleanField(default=False)
def __str__(self):
return self.name
class Network(models.Model):
machine = models.ForeignKey('Machine')
model = models.ForeignKey('NetworkModel', null=True, blank=True)
mac = MACAddressField(unique=True)
location = models.CharField(max_length=255, null=True, blank=True)
def __unicode__(self):
return self.mac
def __str__(self):
return self.__unicode__()
class Hosts_Allow(models.Model): class Meta: verbose_name = '\"Доступные/Зарезервированные ip\"' verbose_name_plural = 'Доступные/Зарезервированные ip' hostname = models.CharField(max_length=30, blank=False, verbose_name='Имя хоста') mac_addr = MACAddressField(max_length=17, blank=False, verbose_name='mac адрес') ip_addr = models.GenericIPAddressField(protocol='IPv4', blank=False, verbose_name='ip адрес') description = models.CharField(max_length=100, verbose_name='Описание') def __str__(self): return 'hostname: ' + self.hostname
class AppiumDevices(models.Model):
device_name = models.CharField(max_length=255, null=True)
device_mac = MACAddressField(integer=False, null=True, blank=True)
device_serial = models.CharField(max_length=255, unique=True)
device_type = models.ForeignKey(DeviceType, null=True)
device_version = models.ForeignKey(AppiumOS, null=True)
device_env = models.ForeignKey(EnvironmentType, null=True)
def get_absolute_url(self):
return reverse_lazy('appium_device_list')
def __unicode__(self):
return self.device_name
class Machine(ExportModelOperationsMixin('machine'), models.Model):
proprio = models.ForeignKey('User', on_delete=models.PROTECT)
mac_address = MACAddressField(integer=False, unique=True)
def add_to_set(self):
command_to_execute = ["sudo",
"-n"] + CaptivitateConfig.generic_ipset_command.split() + [
"add", CaptivitateConfig.ipset_name,
str(self.mac_address)]
apply(command_to_execute)
def del_to_set(self):
command_to_execute = ["sudo",
"-n"] + CaptivitateConfig.generic_ipset_command.split() + [
"del", CaptivitateConfig.ipset_name,
str(self.mac_address)]
apply(command_to_execute)
class DhcpTable(models.Model):
ip_add = models.GenericIPAddressField(default='127.0.0.1')
mac = MACAddressField(null=True, blank=True)
mac_txt = models.CharField("Mac txt", max_length=50, null=True, blank=True)
dns_name = models.CharField("DNS имя",
max_length=50,
null=True,
blank=True)
fl = models.IntegerField(default=1)
class Meta:
ordering = ['ip_add']
verbose_name = "DNS адрес"
verbose_name_plural = "DNS адреса"
def __str__(self):
return self.ip_add
class Host(models.Model):
''' Модель содержащая хосты встречающиеся в сети '''
ip = models.GenericIPAddressField('IP address', db_index=True)
mac = MACAddressField(null=True, blank=True)
vendor = models.CharField('Производитель',
max_length=255,
null=True,
blank=True)
active = models.BooleanField('Active host', default=False)
creation_date = models.DateTimeField(auto_now_add=True)
update_date = models.DateTimeField(auto_now=True)
def __str__(self):
return '{} {} {}'.format(self.ip, self.mac, self.vendor)
class Meta:
ordering = ["ip"]
class Device(models.Model):
MAC = MACAddressField(null=True, unique=True)
location = models.ForeignKey('Location', verbose_name='Расположение', on_delete=models.PROTECT, null=True,
blank=True)
has_temp_sensor = models.BooleanField(verbose_name='Датчик температуры', null=False, default=True)
has_CO2_sensor = models.BooleanField(verbose_name='Датчик углек. газа', null=False, default=False)
has_humid_sensor = models.BooleanField(verbose_name='Датчик влажности', null=False, default=False)
has_motion_sensor = models.BooleanField(verbose_name='Датчик движения', null=False, default=False)
charge = models.FloatField(verbose_name='Заряд батареи', help_text="Текущий ровень заряда батареи", null=True)
battery_capacity = models.FloatField(verbose_name='Макс. заряд',
help_text="Максимальный уровень заряда (см на аккумуляторе)", null=True)
sleep_period = models.IntegerField(verbose_name='Время сна',
help_text="Время Deep Sleep в мс (по умолчанию %d мс или %d мин)"
% (DEVICE_DEFAULT_SLEEP_TIME, DEVICE_DEFAULT_SLEEP_TIME / 60000),
default=DEVICE_DEFAULT_SLEEP_TIME)
last_connection = models.DateTimeField(verbose_name='Последнее подключение',
help_text="Когда было последнее подключение", null=True, blank=True)
allow_untrusted = models.BooleanField(verbose_name='Разрешить всё',
help_text="Принимать все запросы с этого устройства, игнорируя проверку "
"времени (ТОЛЬКО ДЛЯ ОБСЛУЖИВАНИЯ)",
default=False)
#last_readout = models.ForeignKey('Readout', related_name='readout', null=True, blank=True, on_delete=models.SET_NULL)
warning = models.IntegerField(default=0)
def __str__(self):
descr = "%s (%1.1f%%) %s%s%s%s" % (
self.location, self.battery_level(), ("ТЕМП " if self.has_temp_sensor else ""),
("C02 " if self.has_CO2_sensor else ""),
("ВЛАЖН " if self.has_humid_sensor else ""), ("ДВИЖ" if self.has_motion_sensor else ""))
return descr
def alert(self):
alerts = Alert.objects.filter(location=self.location)
return True if alerts else False
def battery_level(self):
if self.charge is None or self.battery_capacity is None:
return -1
return self.charge / self.battery_capacity * 100
class Meta:
ordering = ('location',)
verbose_name = 'устройство'
verbose_name_plural = 'устройства'
class Lock(models.Model):
lock_id = models.CharField(editable=True, max_length=255)
lock_type = models.CharField(max_length=2,
choices=lock_type_choices,
default='CL')
mac_address = MACAddressField(null=True, blank=True)
unlock_key = models.CharField(editable=True, max_length=255, blank=True)
def __str__(self):
return "#{lock_id} ({lock_type})".format(lock_id=self.lock_id,
lock_type=self.lock_type)
def __repr__(self):
return "#{lock_id} ({lock_type}) mac_address={mac_address} unlock_key={unlock_key}".format(
lock_id=self.lock_id,
lock_type=self.lock_type,
mac_address=self.mac_address,
unlock_key=self.unlock_key,
)
class Interface(models.Model):
origin = models.ForeignKey('config.Origin', null=True, blank=True)
system = models.ForeignKey('System', null=True, blank=True)
net = models.ForeignKey('Net', null=True, blank=True)
address_ether = MACAddressField(integer=False, null=True, blank=True)
address_inet = models.GenericIPAddressField(null=True, blank=True)
distance = models.IntegerField(default=-1)
protocol_l3 = models.IntegerField(default=0)
tx_pkts = models.BigIntegerField(default=0)
tx_bytes = models.BigIntegerField(default=0)
rx_pkts = models.BigIntegerField(default=0)
rx_bytes = models.BigIntegerField(default=0)
ttl_seen = models.IntegerField(default=0)
first_seen = models.DateTimeField(auto_now=False, null=True)
last_seen = models.DateTimeField(auto_now=True, null=True)
class Meta:
unique_together = (('address_ether', 'address_inet', 'origin',
'ttl_seen'), )
class Scan(models.Model):
lat = models.FloatField(null=True, blank=True)
lon = models.FloatField(null=True, blank=True)
time = models.DateTimeField()
ssid = models.CharField(max_length=255, default='')
mac = MACAddressField(null=True, blank=True)
type = models.SlugField(max_length=32, default='wifi')
class Meta:
app_label = 'locman'
verbose_name = 'scan'
verbose_name_plural = 'scans'
indexes = [
models.Index(fields=['lat', 'lon']),
models.Index(fields=['ssid']),
models.Index(fields=['mac']),
models.Index(fields=['type']),
models.Index(fields=['time'])
]
constraints = [
models.UniqueConstraint(fields=['mac', 'time'], name='unique_mac_time')
]
class RegisteredHost(models.Model):
''' Модель содержащая хосты зарегистрированные в конфиге DHCP сервера '''
ip = models.GenericIPAddressField('IP address', db_index=True)
mac = MACAddressField(null=True, blank=True)
hostname = models.CharField('Host name',
max_length=255,
null=True,
blank=True)
subnet = models.GenericIPAddressField('Subnet mask', null=True, blank=True)
routes = models.GenericIPAddressField('Routes', null=True, blank=True)
dns = models.GenericIPAddressField('DNS', null=True, blank=True)
creation_date = models.DateTimeField(auto_now_add=True)
def __str__(self):
return f'{self.ip} {self.hostname}'
def dt_row_id(self):
return self.id
class Meta:
ordering = ["ip"]
class Authorization(models.Model):
user = models.ForeignKey(get_user_model(), on_delete=models.PROTECT, null=True)
mac_address = MACAddressField(verbose_name='MAC address',
help_text='A device\'s MAC address can be found on a sticker attached to the device.')
timestamp = models.DateTimeField(auto_now_add=True)
authorized_until = models.DateTimeField()
class Meta:
ordering = '-timestamp', '-authorized_until'
def __str__(self):
if self.user is None:
return f'Guest authorization for {self.mac_address}'
return f'Authorization for {self.user} {self.mac_address}'
@property
def timeago(self):
return timeago.format(self.timestamp, timezone.now())
@property
def timeago_authorized_until(self):
return timeago.format(self.authorized_until, timezone.now())
class Computer(models.Model):
ip_address = models.GenericIPAddressField(_('IP address'),
protocol='IPv4',
primary_key=True)
mac_address = MACAddressField(_('MAC address'), null=True, blank=True)
nice_name = models.SlugField(
_('Internal hostname'),
null=True,
blank=True,
help_text=
_('This will be used to generate SSH client configuration to make it easier to connect for troubleshooting.'
))
tags = models.ManyToManyField(
Tag,
blank=True,
verbose_name=_('Groups'),
help_text=
_('This will be used to generate Ansible host groups for easier managing. Groups are also printed on participant printouts. For locations with multiple participant rooms it is recommended to at least create a group for every room and assign it to the computers in that room to make printout delivery easier.'
))
def __str__(self) -> str:
return '{name} ({ip_address})'.format(
name=self.nice_name if self.nice_name else '<unknown>',
ip_address=self.ip_address)
@property
def hostname(self) -> str:
if self.nice_name:
return 'c' + self.nice_name
return None
@property
def ansible_name(self) -> str:
return self.hostname or '{}.in-addr.arpa'.format('.'.join(
self.ip_address.split('.')[::-1]))
class Meta:
verbose_name = _('computer')
verbose_name_plural = _('computers')
class ip(models.Model):
tarih = models.DateTimeField('date published')
ip = models.GenericIPAddressField(db_index=True, primary_key=True)
birim = models.ForeignKey(birim, on_delete=models.PROTECT)
#eposta = models.EmailField(max_length=50)
eposta = models.CharField(max_length=50)
aciklama = models.CharField(max_length=250)
mac = MACAddressField(blank=True, integer=False)
kisisel = models.BooleanField(default=False)
elle_binding = models.BooleanField(default=False)
kablosuz = models.BooleanField(default=False)
aktif = models.BooleanField(default=True)
def publish(self):
self.tarih = timezone.now()
self.save()
def detay(self):
return '{} - {} - {} - {}'.format(self.ip, self.mac, self.eposta,
self.birim)
def __str__(self):
return self.detay()
class Node(models.Model):
project = InheritanceForeignKey(verbose_name=_('project'),
to=Project,
on_delete=models.CASCADE)
gns3_id = models.UUIDField(verbose_name=_('node id'),
unique=True,
editable=False)
name = models.CharField(verbose_name=_('name'), max_length=50)
mac_address = MACAddressField(verbose_name=_('MAC fix_address'))
objects = InheritanceManager()
class Meta:
verbose_name = _('node')
verbose_name_plural = _('nodes')
ordering = ('project__name', 'name')
unique_together = (
('project', 'gns3_id'),
('project', 'mac_address'),
)
def __str__(self):
return self.name
class DeviceSignalStrength(models.Model):
time = models.DateTimeField(verbose_name='Timestamp')
mac_address = MACAddressField(verbose_name='Mac address', integer=False)
signal_strength_hg655d = models.IntegerField(
verbose_name='Signal strength',
validators=[MinValueValidator(-100),
MaxValueValidator(0)])
signal_strength_710nr = models.IntegerField(
verbose_name='Signal strength',
validators=[MinValueValidator(-100),
MaxValueValidator(0)])
signal_strength_710nm = models.IntegerField(
verbose_name='Signal strength',
validators=[MinValueValidator(-100),
MaxValueValidator(0)])
def __unicode__(self):
return 'Time: %s | Mac address: %s | Signal strength (HG655D, 710Nr, 710Nm): (%s, %s, %s) ' % (
self.time, self.mac_address, self.signal_strength_hg655d,
self.signal_strength_710nr, self.signal_strength_710nm)
class Meta:
unique_together = ["time", "mac_address"]
class Clients(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL,
related_name='client')
ip_address = models.GenericIPAddressField(verbose_name='IP адрес клиена')
ipv6_address = models.GenericIPAddressField(
verbose_name='IPv6 адрес клиена',
default="2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d")
send_sms = models.BooleanField(verbose_name='Желание получать смс',
default=False)
select_tarif = models.ForeignKey(Tarifs, verbose_name='Выбор тарифа')
select_clients_group = models.ForeignKey(
ClientsGroups, verbose_name='Выбор группы клиентов')
create_date = models.DateField(verbose_name='Дата подключения',
auto_now_add=True)
end_used_date = models.DateField(
verbose_name='Дата окончяния услуги',
default=(datetime.datetime.now() +
datetime.timedelta(days=settings.NEW_CLIENT_DAYS)))
select_street = models.ForeignKey(Streets,
verbose_name='Выбор улицы',
blank=True,
null=True)
mobile_phone = models.CharField(
max_length=50,
verbose_name='Мобильный телефон',
blank=True,
null=True,
)
home_address = models.CharField(
max_length=50,
verbose_name='Домашний адрес',
blank=True,
null=True,
)
network_traffic_per_day = models.IntegerField(
verbose_name='Сетевой трафик за день', null=True, default=0)
network_traffic_for_the_month = models.IntegerField(
verbose_name='Сетевой трафик за месяц', null=True, default=0)
balance = models.IntegerField(verbose_name='Баланс', default=0)
internet_status = models.BooleanField(
verbose_name='Статус клиента, доступ разрешен/запрещен', default=True)
error_card = models.IntegerField(
verbose_name='Ошибки пополнения карточкой', null=True, default=0)
deleted_user = models.BooleanField(
default=False, verbose_name='Статус удаления пользователя')
key = models.CharField(max_length=50)
login = models.CharField(max_length=50, verbose_name='Логин', default='')
exemption = models.BooleanField(default=False)
# Период работы клиентов с первого по первое True, с дня пополнения False
fix_work_period = models.BooleanField(
default=False, verbose_name='Работает с первого по первое')
vk = models.CharField(max_length=255,
verbose_name='Профиль Вконтакте',
default='',
blank=True,
null=True)
facebook = models.CharField(max_length=255,
verbose_name='Профиль в facebook',
default='',
blank=True,
null=True)
mac_address = MACAddressField(null=True,
blank=True,
integer=False,
verbose_name='МАС адрес клиента')
onu_mac_address = MACAddressField(null=True,
blank=True,
integer=False,
verbose_name='МАС адрес ONU')
class Meta:
verbose_name = "Клиент"
verbose_name_plural = "Клиенты"
db_table = "clients"
def __str__(self):
return '{} {} {} {}'.format(self.login, self.select_clients_group,
self.ip_address, self.deleted_user)
class EtherOUI(models.Model):
oui = MACAddressField(null=True, blank=True, db_index=True)
vendor = models.CharField(max_length=253)
class NetworkThingy(models.Model):
mac = MACAddressField()
def __unicode__(self):
return "%s" % self.mac
class Controller(models.Model):
"""A component of the hydroponic system that can be commanded (e.g., pump, dosage, camera or
sensor controller)"""
objects = ControllerManager()
PUMP_TYPE = "PUM"
DOSAGE_TYPE = "DOS"
CAMERA_TYPE = "CAM"
SENSOR_TYPE = "SEN"
UNKNOWN_TYPE = "UNK"
CONTROLLER_TYPE_CHOICES = [(PUMP_TYPE, "Pump controller"),
(DOSAGE_TYPE, "Dosage controller"),
(CAMERA_TYPE, "Camera controller"),
(SENSOR_TYPE, "Sensor controller"),
(UNKNOWN_TYPE, "Unknown controller")]
id = models.UUIDField(
primary_key=True,
default=uuid.uuid4,
editable=False,
help_text="The UUID to identify the controller.",
)
name = models.CharField(
max_length=30,
null=True,
blank=True,
help_text="The name of the controller",
)
coordinator = models.ForeignKey(
Coordinator,
on_delete=models.CASCADE,
null=True,
help_text="The coordinator with which the controller is connected to.",
)
wifi_mac_address = MACAddressField(
help_text="The Wifi MAC address of the controller.")
external_ip_address = models.GenericIPAddressField(
help_text="The external IP address of the controller.")
controller_type = models.CharField(
max_length=3,
choices=CONTROLLER_TYPE_CHOICES,
default=UNKNOWN_TYPE,
help_text=
"The main function of the controller (e.g., pump or sensor controller).",
)
created_at = models.DateTimeField(
auto_now_add=True,
help_text="The date and time when the controller was first registered.",
)
modified_at = models.DateTimeField(
auto_now=True,
help_text="The date and time when the controller was last updated.",
)
def __str__(self):
if self.name:
return self.get_controller_type_display() + " (" + self.name + ")"
else:
return self.get_controller_type_display(
) + " (" + self.id.hex + ")"
class HostMac(models.Model):
host = models.ForeignKey(Host, on_delete=models.CASCADE)
ipmiMac = MACAddressField(null=True, blank=True, unique=True)
pxeMac = MACAddressField(null=True, blank=True, unique=True)
class Device(models.Model):
"""All information about devices_farm that we have"""
objects = models.Manager()
ANDROID = 'Android'
IOS = 'iOS'
WIN_MOBILE = 'Windows Mobile'
PLATFORMS = ((IOS, IOS), (ANDROID, ANDROID), (WIN_MOBILE, WIN_MOBILE))
device_platform = models.CharField(
name='platform',
max_length=20,
choices=PLATFORMS,
)
device_name = models.CharField(max_length=20, )
PHONE = 'Phone'
TABLET = 'Tablet'
TYPES = (
(PHONE, PHONE),
(TABLET, TABLET),
)
device_type = models.CharField(
name='type',
max_length=20,
choices=TYPES,
default=PHONE,
)
# TODO: needs to use version library
# os_version = VersionField(
# default=''
# )
os_version = models.CharField(
max_length=10,
default=None,
)
device_gpu = models.CharField(
max_length=20,
blank=True,
help_text='Only required if Platform is "Android".',
)
device_owner = models.ForeignKey(User,
name='owner',
on_delete=models.SET_NULL,
null=True,
related_name='user_owner')
current_holder = models.ForeignKey(User,
name='holder',
on_delete=models.SET_NULL,
null=True,
related_name='user_holder')
company_number = models.CharField(
max_length=20,
blank=True,
default='',
)
serial_number = models.CharField(max_length=20, )
mac_address = MACAddressField(
null=True,
blank=True,
integer=False,
default='',
)
imei_number = models.CharField(
name='imei',
max_length=20,
blank=True,
default='',
)
sim_card = models.BooleanField(default=True, )
sd_card = models.BooleanField(default=False, )
screen_resolution = models.CharField(
max_length=20,
blank=True,
default='',
)
screen_diagonal = models.CharField(
max_length=20,
blank=True,
default='',
)
memory_size = models.IntegerField(help_text='Size in GB.', )
device_color = models.CharField(
name='color',
max_length=20,
blank=True,
default='',
)
is_active = models.BooleanField(default=True, )
characteristics_url = models.URLField(
default='',
blank=True,
)
class Meta:
ordering = ['platform', 'type', 'device_name']
def get_absolute_url(self):
return reverse('devices_farm:device', args=[str(self.id)])
def get_fields(self):
return [(field.name, field.value_to_string(self))
for field in Device._meta.fields]
def __str__(self):
return self.device_name
class Vendor(models.Model):
name = models.CharField(max_length=127)
address_ether = MACAddressField(null=True)
class WirelessClient(models.Model):
id = models.AutoField(primary_key=True)
first_detection = models.DateTimeField()
last_detection = models.DateTimeField()
mac_address = MACAddressField(null=True, blank=True, integer=False)
class Lock(models.Model):
mac_address = MACAddressField(null=True)
unlock_key = models.BinaryField(editable=True)
def __str__(self):
return str(self.mac_address)
class Arp(models.Model):
ip = models.ForeignKey(Ip, on_delete=models.CASCADE)
mac = MACAddressField(null=True)
date = models.DateTimeField(null=True)