def get_statistics(self,
time: tuple = None,
temperature: tuple = None,
identifiers: list = None,
devices: list = None
):
"""
:param time: (start, end)
:param temperature: (min, max)
:param identifiers: list[int]
:param devices: list[int]
:return: list[models.Statistics]
"""
with models.get_session() as session:
query = session.query(models.Statistic)
if time:
query = query.filter(models.Statistic.time >= time[0],
models.Statistic.time <= time[1])
if temperature:
query = query.filter(models.Statistic.temperature >= temperature[0],
models.Statistic.temperature <= temperature[1])
if identifiers:
query = query.filter(models.Statistic.id_profile.in_(identifiers))
if devices:
query = query.filter(models.Statistic.id_device.in_(devices))
self._statistics = query.all()
return self._statistics
def get_profile_name(self, identifier: int):
with models.get_session() as session:
profile_name = session.query(models.Profile.name) \
.filter(models.Profile.id == identifier) \
.scalar()
self._profile_name = profile_name
return profile_name
def get_profiles(self, *identifiers: int):
with models.get_session() as session:
query = session.query(models.Profile)
if identifiers:
query = query.filter(models.Profile.id.in_(identifiers))
self._profiles = query.all()
return self._profiles
def get_number_statistics(self,
time: tuple = None,
temperature: tuple = None,
name: str = None,
identifiers: list = None,
devices: list = None
):
"""
:param time: (start, end)
:param temperature: (min, max)
:param name: example, 'Name' from ['Nma', 'Name1, 1_Name, Name], result is ['Name1, 1_Name, Name]
:param identifiers: list[int]
:param devices: list[int]
:return: (int, int)
"""
with models.get_session() as session:
query = session.query(models.Statistic, models.Profile.name) \
.join(models.Profile, models.Profile.id == models.Statistic.id_profile, isouter=True)
if name:
query = query.filter(models.Profile.name.like(f'%{name}%'))
if time:
query = query.filter(models.Statistic.time >= time[0],
models.Statistic.time <= time[1])
if temperature:
query = query.filter(models.Statistic.temperature >= temperature[0],
models.Statistic.temperature <= temperature[1])
if identifiers:
query = query.filter(models.Statistic.id_profile.in_(identifiers))
if devices:
query = query.filter(models.Statistic.id_device.in_(devices))
self._number_profile_passages = query.filter(models.Statistic.id_profile.isnot(None)).count()
self._number_stranger_passages = query.filter(models.Statistic.id_profile.is_(None)).count()
return self._number_profile_passages, self._number_stranger_passages
def get_departments(self, *identifiers: int):
with models.get_session() as session:
query = session.query(models.Department)
if identifiers:
query = query.filter(models.Department.id.in_(identifiers))
self._departments = query.all()
return self._departments
def get_gender(identifier: Union[int, str]):
with models.get_session() as session:
if isinstance(identifier, int):
query = session.query(models.Gender).filter(models.Gender.id == identifier)
elif isinstance(identifier, str):
query = session.query(models.Gender).filter(models.Gender.value == identifier)
gender = query.scalar()
return gender
def is_passport_duplicate(self, passport: str):
with models.get_session() as session:
profile = session.query(models.Profile) \
.filter(models.Profile.passport == passport) \
.first()
if profile:
self._profiles = profile
return True
return False
def is_personnel_number_duplicate(self, personnel_number: str):
with models.get_session() as session:
profile = session.query(models.Profile) \
.filter(models.Profile.personnel_number == personnel_number) \
.first()
if profile:
self._profiles = profile
return True
return False
def is_id_profile_duplicate(self, identifier: int):
with models.get_session() as session:
profile = session.query(models.Profile) \
.filter(models.Profile.id == identifier) \
.first()
if profile:
self._profiles = profile
return True
return False
def get_statistic(self,
time: str,
temperature: float = None):
with models.get_session() as session:
query = session.query(models.Statistic)
query = query.filter(models.Statistic.time == time)
if temperature:
query = query.filter(models.Statistic.temperature == temperature)
self._statistics = query.scalar()
return self._statistics
def is_department_duplicate(self, department: Union[models.Department, str]):
with models.get_session() as session:
query = session.query(models.Department)
if isinstance(department, models.Department):
query = query.filter(models.Department.name == department.name)
else:
query = query.filter(models.Department.name == department)
self._departments = query.first()
if self._departments:
return True
return False
def remove_profiles(self, *identifiers: int):
profiles = self.get_profiles(*identifiers)
path = os.path.dirname(os.path.abspath(__file__))
for profile in profiles:
if os.path.exists(f'{path}\\nginx\\html{profile.face}'):
os.remove(f'{path}\\nginx\\html{profile.face}')
with models.get_session() as session:
session.query(models.Profile) \
.filter(models.Profile.id.in_(identifiers)) \
.delete(synchronize_session=False)
self._profiles = None
def update_department(self, identifier, new_department: models.Department):
with models.get_session() as session:
session.query(models.Department) \
.filter(models.Department.id == identifier) \
.update(
{
models.Department.id: new_department.id,
models.Department.name: new_department.name,
models.Department.location: new_department.location
}
)
self._departments = None
def get_profile(self, **kwargs):
with models.get_session() as session:
for key, value in kwargs.items():
if key == 'identifier':
query = session.query(models.Profile).filter(models.Profile.id == value)
elif key == 'personnel_number':
query = session.query(models.Profile).filter(models.Profile.personnel_number == value)
elif key == 'passport':
query = session.query(models.Profile).filter(models.Profile.passport == value)
elif key == 'name':
query = session.query(models.Profile).filter(models.Profile.name == value)
self._profiles = query.scalar()
return self._profiles
def update_config(identifier: int, config: models.SMTPConfig):
with models.get_session() as session:
session.query(models.SMTPConfig) \
.filter(models.SMTPConfig.id == identifier) \
.update(
{
models.SMTPConfig.id: config.id,
models.SMTPConfig.created_at: config.created_at,
models.SMTPConfig.modified_at: config.modified_at,
models.SMTPConfig.host: config.host,
models.SMTPConfig.port: config.port,
models.SMTPConfig.user: config.user,
models.SMTPConfig.password: config.password,
models.SMTPConfig.default_sender: config.default_sender,
models.SMTPConfig.use_tls: config.use_tls,
models.SMTPConfig.use_ehlo: config.use_ehlo,
models.SMTPConfig.use_ssl: config.use_ssl
}
)
def remove_statistics(self, *times: tuple):
"""
:param times: tuple[profile_identifier, datetime]
:return: None
"""
path = os.path.dirname(os.path.abspath(__file__))
with models.get_session() as session:
for time in times:
statistic = session.query(models.Statistic) \
.filter(models.Statistic.time == time[1],
models.Statistic.id_profile == time[0]) \
.scalar()
if statistic.face is not None and os.path.exists(f'{path}/snapshot{statistic.face}'):
os.remove(f'{path}/snapshot{statistic.face}')
session.query(models.Statistic) \
.filter(models.Statistic.time == time[1],
models.Statistic.id_profile == time[0]
) \
.delete(synchronize_session=False)
self._statistics = None
def update_device(self, identifier: int, new_device: Union[models.Device, dict]):
with models.get_session() as session:
if isinstance(new_device, models.Device):
session.query(models.Device) \
.filter(models.Device.id == identifier) \
.update(
{
models.Device.serial_number: new_device.serial_number,
models.Device.name: new_device.name,
models.Device.model: new_device.model,
models.Device.mac_address: new_device.mac_address,
models.Device.ip_address: new_device.ip_address,
models.Device.firmware_version: new_device.firmware_version,
models.Device.token: new_device.token
}
)
elif isinstance(new_device, dict):
session.query(models.Device) \
.filter(models.Device.id == identifier) \
.update(new_device)
self._devices = new_device
def update_profile(self, identifier: int, new_profile: Union[models.Profile, dict]):
with models.get_session() as session:
if isinstance(new_profile, models.Profile):
session.query(models.Profile) \
.filter(models.Profile.id == identifier) \
.update(
{
models.Profile.id: new_profile.id,
models.Profile.personnel_number: new_profile.personnel_number,
models.Profile.name: new_profile.name,
models.Profile.passport: new_profile.passport,
models.Profile.visitor: new_profile.visitor,
models.Profile.face: new_profile.face,
models.Profile.id_department: new_profile.id_department,
models.Profile.gender: new_profile.gender,
models.Profile.information: new_profile.information
}
)
elif isinstance(new_profile, dict):
session.query(models.Profile) \
.filter(models.Profile.id == identifier) \
.update(new_profile)
self._profiles = new_profile
def add_devices(self, *devices: models.Device):
with models.get_session() as session:
session.add_all(devices)
self._devices = devices
def get_device_id(self, serial_number: str):
with models.get_session() as session:
self._device_id = session.query(models.Device.id) \
.filter(models.Device.serial_number == serial_number) \
.scalar()
return self._device_id
def get_device_serial_number(self, identifier: int):
with models.get_session() as session:
self._device_serial_number = session.query(models.Device.serial_number) \
.filter(models.Device.id == identifier) \
.scalar()
return self._device_serial_number
def remove_departments(self, *identifiers: int):
with models.get_session() as session:
session.query(models.Department) \
.filter(models.Department.id.in_(identifiers)) \
.delete(synchronize_session=False)
self._departments = None
def get_devices(self):
with models.get_session() as session:
self._devices = session.query(models.Device) \
.all()
return self._devices
def reset_department_autoincrement():
with models.get_session() as session:
session.execute('ALTER TABLE thermalcamera.departments AUTO_INCREMENT = 1;')
def add_statistics(self, *statistics: models.Statistic):
with models.get_session() as session:
session.add_all(statistics)
self._statistics = statistics
def get_profiles_by_department(self, department: int):
with models.get_session() as session:
query = session.query(models.Profile).filter(models.Profile.id_department == department)
self._profiles = query.all()
return self._profiles
def add_smtp_config(config: models.SMTPConfig):
with models.get_session() as session:
session.add(config)
def add_profiles(self, *profiles: models.Profile):
with models.get_session() as session:
session.add_all(profiles)
self._profiles = profiles
def get_smtp_config(sender: str):
with models.get_session() as session:
config = session.query(models.SMTPConfig).filter(models.SMTPConfig.default_sender == sender).scalar()
return config
def reset_profile_autoincrement():
with models.get_session() as session:
session.execute('ALTER TABLE thermalcamera.profiles AUTO_INCREMENT = 1;')
