Revize 0fcb708f

re #9846 Changed keyman devices, body devices views. Added Head devices view. Changed filtering of logs, ldlogs, body devices, head devices and keyman devices. Changed HTML tables style and few labels.

server/doc/sql_app/crud.html

@@ -47 +47 @@
     return db.query(models.Device).offset(skip).limit(limit).all()
 
 
-def find_device(db: Session, device: schemas.DeviceBase):
+def find_device(db: Session, device: schemas.DeviceTemp):
     """
-    finds one device with product_id, vendor_id and serial_number same as in given DeviceBase object
+    finds one device with  serial_number same as in given DeviceBase object
     """
-    return db.query(models.Device).filter(and_(models.Device.product_id == device.product_id,
-                                               models.Device.vendor_id == device.vendor_id,
-                                               models.Device.serial_number == device.serial_number)).first()
+    return db.query(models.Device).filter(and_(models.Device.serial_number == device.serial_number)).first()
 
 
-def create_device(db: Session, device: schemas.DeviceBase):
+def find_device_by_serial(db: Session, ser: str):
+    """
+    finds one device with serial_number same as in given DeviceBase object
+    """
+    return db.query(models.Device).filter(and_(models.Device.serial_number == ser)).first()
+
+
+def get_devices_with_ids(db: Session, ids: []):
+    """
+    returns all devices with given ids
+    """
+    return db.query(models.Device).filter(models.Device.id.in_(ids)).all()
+
+
+def get_bodydevices_with_ids(db: Session, ids: []):
+    """
+    returns all bodydevices with given ids
+    """
+    return db.query(models.BodyDevice).filter(models.BodyDevice.id.in_(ids)).all()
+
+
+def get_headdevices_with_ids(db: Session, ids: []):
+    """
+    returns all headdevices with given ids
+    """
+    return db.query(models.HeadDevice).filter(models.HeadDevice.id.in_(ids)).all()
+
+
+def find_headdevices_by_team(db: Session, team_id: int):
+    """
+    Returns all head devices in specific team
+    """
+    return db.query(models.HeadDevice).filter(models.HeadDevice.team_id == team_id).all()
+
+
+def find_bodydevices_by_team(db: Session, team_id: int):
+    """
+    Returns all body devices in specific team
+    """
+    return db.query(models.BodyDevice).filter(models.BodyDevice.team_id == team_id).all()
+
+
+def find_headdevices_by_license(db: Session, lic_id: int):
+    """
+    Returns all head devices with specific license
+    """
+    return db.query(models.HeadDevice).filter(models.HeadDevice.license_id == lic_id).all()
+
+
+def find_bodydevices_by_license(db: Session, lic_id: int):
+    """
+    Returns all body devices with specific license
+    """
+    return db.query(models.BodyDevice).filter(models.BodyDevice.license_id == lic_id).all()
+
+
+def get_devices_by_team(db: Session, team: int):
+    """
+    returns all devices with same team
+    """
+    return db.query(models.Device).filter(models.Device.team_id == team).all()
+
+
+def create_device(db: Session, device: schemas.DeviceTemp):
     """
     creates new device with data from given DeviceBase object
     """
     db_device = models.Device(vendor_id=device.vendor_id, product_id=device.product_id,
-                              serial_number=device.serial_number, assigned=False)
+                              serial_number=device.serial_number, inventory_number="", comment="")
     db.add(db_device)
     db.commit()
     db.refresh(db_device)
@@ -86 +147 @@
     """
     finds one license by given string name
     """
-    return db.query(models.License).filter(models.License.name == name).first()
+    return db.query(models.License).filter(models.License.license_id == name).first()
 
 
-def create_license(db: Session, name: str, expdate: date):
+def get_licenses_by_name(db: Session, name: str):
+    return db.query(models.License).filter(models.License.name == name).all()
+
+
+def create_license(db: Session, name: str, lic_id: str, expdate: date):
     """
     creates new license with given name and expiration date
     """
-    db_license = models.License(name=name, expiration_date=expdate)
+    db_license = models.License(name=name, license_id=lic_id, expiration_date=expdate)
     db.add(db_license)
     db.commit()
     db.refresh(db_license)
@@ -102 +167 @@
 
 def get_license_devices(db: Session, license_id: int):
     """
-    returns all entries in devices_licenses table
+    returns all entries in devices_licenses table with given license_id
     """
     return db.query(models.DeviceLicense).filter(models.DeviceLicense.license_id == license_id).all()
 
 
+def find_devicelicenses_by_licid_array(db: Session, lcs: []):
+    """
+    Finds all device_licenses with license_id in given id array
+    """
+    return db.query(models.DeviceLicense).filter(models.DeviceLicense.license_id.in_(lcs)).all()
+
+
+def get_device_licenses(db: Session, device_id: int):
+    """
+    returns all entries in devices_licenses table with given device_id
+    """
+    return db.query(models.DeviceLicense).filter(models.DeviceLicense.device_id == device_id).all()
+
+
+def get_devicelicense_by_devicelicense(db: Session, device_id: int, license_id: int):
+    """
+    returns entry in devices_licenses table with given device id and license id
+    """
+    return db.query(models.DeviceLicense).filter(and_(models.DeviceLicense.device_id == device_id,
+                                                      models.DeviceLicense.license_id == license_id)).first()
+
+
 def create_device_license(db: Session, device: int, license: int, time: datetime):
     """
     creates new entry in devices_licenses table with device id, license id and time.
@@ -119 +206 @@
     return db_device_license
 
 
+def delete_device_license(db: Session, device: int, license: int):
+    """
+    deletes entry in devices_licenses table with device id, license id and time.
+    """
+    db_device_license = get_devicelicense_by_devicelicense(db, device, license)
+    db_lic = db.delete(db_device_license)
+    db.commit()
+    return db_lic
+
+
 def find_pc_by_username(db: Session, name: str):
     """
     Finds one pc by given username
@@ -133 +230 @@
     return db.query(models.PC).filter(models.PC.id == pc_id).first()
 
 
-def update_pc(db: Session, pc_id: int, team: str):
+def update_device(db: Session, device_id: int, team: str):
     """
-    Function updates team of one specific pc
+    Updates team of one specific pc
     """
-    old_pc = get_pc(db, pc_id)
+    old_dev = get_device(db, device_id)
     team = get_team(db, int(team))
-    new = {'id': old_pc.id, 'username': old_pc.username, 'hostname': old_pc.hostname, 'assigned': True,
-           'team_id': team.id}
+    new = {'id': old_dev.id, 'vendor_id': old_dev.vendor_id, 'product_id': old_dev.product_id,
+           'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': old_dev.comment, 'team_id': team.id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_device_inv(db: Session, device_id: int, inv: str):
+    """
+    Updates inventory number of one specific pc
+    """
+    old_dev = get_device(db, device_id)
+    if old_dev.team_id != None:
+        team = get_team(db, int(old_dev.team_id))
+        teamid = team.id
+    else:
+        teamid = None
+    new = {'id': old_dev.id, 'vendor_id': old_dev.vendor_id, 'product_id': old_dev.product_id,
+           'serial_number': old_dev.serial_number, 'inventory_number': inv,
+           'comment': old_dev.comment, 'team_id': teamid}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_device_com(db: Session, device_id: int, comm: str):
+    """
+    Updates team of one specific pc
+    """
+    old_dev = get_device(db, device_id)
+    if old_dev.team_id != None:
+        team = get_team(db, int(old_dev.team_id))
+        teamid = team.id
+    else:
+        teamid = None
+    new = {'id': old_dev.id, 'vendor_id': old_dev.vendor_id, 'product_id': old_dev.product_id,
+           'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': comm, 'team_id': teamid}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def change_role(db: Session, usr_id: int, role: str):
+    """
+    Updates team of one specific pc
+    """
+    old_usr = find_user_byid(db, usr_id)
+    new = {'id': old_usr.id, 'username': old_usr.username, 'password': old_usr.password, 'role': role}
     for key, value in new.items():
-        setattr(old_pc, key, value)
+        setattr(old_usr, key, value)
     db.commit()
-    db.refresh(old_pc)
-    return old_pc
+    db.refresh(old_usr)
+    return old_usr
 
 
 def get_pcs(db: Session, skip: int = 0, limit: int = 100):
@@ -184 +335 @@
     return db.query(models.PC).filter(models.PC.id.in_(pcs)).all()
 
 
-def get_pcs_by_team(db: Session, team_id: int):
-    """
-    returns all pcs in given team by team id
-    """
-    return db.query(models.PC).filter(models.PC.team_id == team_id).all()
-
-
 def create_pc(db: Session, user: str, host: str):
     """
     creates new pc with given username and hostname
     """
-    db_pc = models.PC(username=user, hostname=host, assigned=False)
+    db_pc = models.PC(username=user, hostname=host)
     db.add(db_pc)
     db.commit()
     db.refresh(db_pc)
@@ -234 +378 @@
     return db_team
 
 
+def change_team(db: Session, team_id: int, name: str):
+    """
+    Updates name of one specific team
+    """
+    old_team = get_team(db, team_id)
+    new = {'id': old_team.id, 'name': name}
+    for key, value in new.items():
+        setattr(old_team, key, value)
+    db.commit()
+    db.refresh(old_team)
+    return old_team
+
+
 def get_head_device(db: Session, head_id: int):
     """
     Returns one specific head device by given id
@@ -248 +405 @@
     return db.query(models.HeadDevice).offset(skip).limit(limit).all()
 
 
-def find_head_device(db: Session, serial: schemas.HeadDeviceBase):
+def find_head_device(db: Session, serial: schemas.HeadDeviceTemp):
     """
     Finds one head device by its serial number
     """
     return db.query(models.HeadDevice).filter(models.HeadDevice.serial_number == serial.serial_number).first()
 
 
-def create_head_device(db: Session, log: schemas.HeadDeviceBase):
+def create_head_device(db: Session, log: schemas.HeadDeviceTemp):
     """
     Creates new head device
     """
@@ -280 +437 @@
     return db.query(models.BodyDevice).offset(skip).limit(limit).all()
 
 
-def find_body_device(db: Session, serial: schemas.BodyDeviceBase):
+def find_body_device(db: Session, serial: schemas.BodyDeviceTemp):
     """
     Finds one body device by its serial number
     """
     return db.query(models.BodyDevice).filter(models.BodyDevice.serial_number == serial.serial_number).first()
 
 
-def create_body_device(db: Session, log: schemas.BodyDeviceBase):
+def find_bodydevice_by_serial(db: Session, serial: str):
+    """
+    Finds one specific body device by given serial number
+    """
+    return db.query(models.BodyDevice).filter(models.BodyDevice.serial_number == serial).first()
+
+
+def find_headdevice_by_serial(db: Session, serial: str):
+    """
+    Finds one specific head device by given serial number
+    """
+    return db.query(models.HeadDevice).filter(models.HeadDevice.serial_number == serial).first()
+
+
+def create_body_device(db: Session, log: schemas.BodyDeviceTemp):
     """
     Creates new Body device
     """
-    db_body = models.BodyDevice(serial_number=log.serial_number)
+    db_body = models.BodyDevice(serial_number=log.serial_number, inventory_number="", comment="")
     db.add(db_body)
     db.commit()
     db.refresh(db_body)
     return db_body
 
 
+def update_bodydevice_license(db: Session, device_id: int, lic_id: int):
+    """
+    Updates body devices license with one given by user
+    """
+    old_dev = get_body_device(db, device_id)
+    lic = get_license(db, lic_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': old_dev.comment, 'team_id': old_dev.team_id, 'license_id': lic.id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_bodydevice_team(db: Session, device_id: int, team_id: int):
+    """
+    Updates body devices team with one given by user
+    """
+    old_dev = get_body_device(db, device_id)
+    team = get_team(db, team_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': old_dev.comment, 'team_id': team.id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_bodydevice_inv(db: Session, device_id: int, dev_inv: str):
+    """
+    Updates body devices inventory number with new one given by user
+    """
+    old_dev = get_body_device(db, device_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': dev_inv,
+           'comment': old_dev.comment, 'team_id': old_dev.team_id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_bodydevice_comm(db: Session, device_id: int, comm: str):
+    """
+    Updates body devices comment with new one given by user
+    """
+    old_dev = get_body_device(db, device_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': comm, 'team_id': old_dev.team_id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_headdevice_license(db: Session, device_id: int, lic_id: int):
+    """
+    Updates head devices license with one given by user
+    """
+    old_dev = get_head_device(db, device_id)
+    lic = get_license(db, lic_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': old_dev.comment, 'team_id': old_dev.team_id, 'license_id': lic.id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_headdevice_team(db: Session, device_id: int, team_id: int):
+    """
+    Updates head devices team with one given by user
+    """
+    old_dev = get_head_device(db, device_id)
+    team = get_team(db, team_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': old_dev.comment, 'team_id': team.id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_headdevice_inv(db: Session, device_id: int, dev_inv: str):
+    """
+    Updates head devices inventory number with new one given by user
+    """
+    old_dev = get_head_device(db, device_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': dev_inv,
+           'comment': old_dev.comment, 'team_id': old_dev.team_id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
+def update_headdevice_comm(db: Session, device_id: int, comm: str):
+    """
+    Updates head devices comment with new one given by user
+    """
+    old_dev = get_head_device(db, device_id)
+    new = {'id': old_dev.id, 'serial_number': old_dev.serial_number, 'inventory_number': old_dev.inventory_number,
+           'comment': comm, 'team_id': old_dev.team_id, 'license_id': old_dev.license_id}
+    for key, value in new.items():
+        setattr(old_dev, key, value)
+    db.commit()
+    db.refresh(old_dev)
+    return old_dev
+
+
 def get_ld_logs(db: Session, skip: int = 0, limit: int = 100):
     """
     Returns all ld debugger logs in database
     """
-    return db.query(models.LDLog).offset(skip).limit(limit).all()
+    return db.query(models.LDLog).order_by(desc(models.LDLog.timestamp)).offset(skip).limit(limit).all()
 
 
 def create_ld_logs(db: Session, item: schemas.LDTempBase, head_id: int, body_id: int, pc_id: int, date: datetime):
@@ -337 +624 @@
     return db.query(models.USBLog).filter(models.USBLog.id.in_(logs)).order_by(desc(models.USBLog.timestamp)).all()
 
 
+def find_filtered_ldlogs(db: Session, logs: []):
+    """
+    Returns all ld logs with ids in given id array.
+    """
+    return db.query(models.LDLog).filter(models.LDLog.id.in_(logs)).order_by(desc(models.LDLog.timestamp)).all()
+
+
+def get_filtered_ldlogs(db: Session, pc: str, tema: str, lic: str):
+    """
+    Function creates query string used for filtering by pc username, team name and license name.
+    Depending on selected filters assembles query string for database
+    """
+    execute_string = "SELECT * FROM ld_logs AS logs WHERE"
+    before_me = False
+    all_all = True
+    if pc != "all":
+        all_all = False
+        pc = find_pc_by_username(db, pc)
+        if pc != None:
+            if before_me:
+                execute_string += " AND logs.pc_id = " + str(pc.id)
+            else:
+                before_me = True
+                execute_string += " logs.pc_id = " + str(pc.id)
+    if tema != "all":
+        all_all = False
+        team = find_team(db, tema)
+        if team != None:
+            head_devices = find_headdevices_by_team(db, team.id)
+            body_devices = find_bodydevices_by_team(db, team.id)
+            if len(head_devices) > 0 and len(body_devices) > 0:
+                h_ids = "("
+                for h in head_devices:
+                    h_ids += str(h.id) + ", "
+                def_h_ids = h_ids[:-2] + ")"
+                b_ids = "("
+                for b in body_devices:
+                    b_ids += str(b.id) + ", "
+                def_b_ids = b_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND (logs.head_id IN " + def_h_ids + " OR logs.body_id IN " + def_b_ids + ")"
+                else:
+                    before_me = True
+                    execute_string += " (logs.head_id IN " + def_h_ids + " OR logs.body_id IN " + def_b_ids + ")"
+            elif len(head_devices) == 0 and len(body_devices) > 0:
+                b_ids = "("
+                for b in body_devices:
+                    b_ids += str(b.id) + ", "
+                def_b_ids = b_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND logs.body_id IN " + def_b_ids
+                else:
+                    before_me = True
+                    execute_string += " logs.body_id IN " + def_b_ids
+            elif len(head_devices) > 0 and len(body_devices) == 0:
+                h_ids = "("
+                for h in head_devices:
+                    h_ids += str(h.id) + ", "
+                def_h_ids = h_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND logs.head_id IN " + def_h_ids
+                else:
+                    before_me = True
+                    execute_string += " logs.head_id IN " + def_h_ids
+            else:
+                if before_me:
+                    execute_string += " AND (logs.head_id = -1 OR logs.body_id = -1)"
+                else:
+                    before_me = True
+                    execute_string += " (logs.head_id = -1 OR logs.body_id = -1)"
+    if lic != "all":
+        all_all = False
+        license = find_license(db, lic)
+        if license != None:
+            head_devices = find_headdevices_by_license(db, license.id)
+            body_devices = find_bodydevices_by_license(db, license.id)
+            if len(head_devices) > 0 and len(body_devices) > 0:
+                h_ids = "("
+                for h in head_devices:
+                    h_ids += str(h.id) + ", "
+                def_h_ids = h_ids[:-2] + ")"
+                b_ids = "("
+                for b in body_devices:
+                    b_ids += str(b.id) + ", "
+                def_b_ids = b_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND (logs.head_id IN " + def_h_ids + " OR logs.body_id IN " + def_b_ids + ")"
+                else:
+                    before_me = True
+                    execute_string += " (logs.head_id IN " + def_h_ids + " OR logs.body_id IN " + def_b_ids + ")"
+            elif len(head_devices) == 0 and len(body_devices) > 0:
+                b_ids = "("
+                for b in body_devices:
+                    b_ids += str(b.id) + ", "
+                def_b_ids = b_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND logs.body_id IN " + def_b_ids
+                else:
+                    before_me = True
+                    execute_string += " logs.body_id IN " + def_b_ids
+            elif len(head_devices) > 0 and len(body_devices) == 0:
+                h_ids = "("
+                for h in head_devices:
+                    h_ids += str(h.id) + ", "
+                def_h_ids = h_ids[:-2] + ")"
+                if before_me:
+                    execute_string += " AND logs.head_id IN " + def_h_ids
+                else:
+                    before_me = True
+                    execute_string += " logs.head_id IN " + def_h_ids
+            else:
+                if before_me:
+                    execute_string += " AND (logs.head_id = -1 OR logs.body_id = -1)"
+                else:
+                    before_me = True
+                    execute_string += " (logs.head_id = -1 OR logs.body_id = -1)"
+    if all_all:
+        before_me = True
+        execute_string = "SELECT * FROM ld_logs AS logs"
+
+    if not before_me:
+        execute_string = "SELECT * FROM ld_logs AS logs WHERE logs.id = -1"
+    result = db.execute(execute_string)
+    return result
+
+
 def get_filtered_logs(db: Session, pc: str, tema: str, lic: str):
     """
     Function creates query string used for filtering by pc username, team name and license name.
     Depending on selected filters assembles query string for database
     """
     execute_string = "SELECT * FROM usb_logs AS logs"
+    pcs = find_pc_by_username(db, pc)
     if pc != "all":
-        pcs = find_pc_by_username(db, pc)
-        execute_string += "  WHERE logs.pc_id = " + str(pcs.id)
+        if pcs is not None:
+            execute_string += "  WHERE logs.pc_id = " + str(pcs.id)
     if tema != "all":
         team = find_team(db, tema)
-        pcs = get_pcs_by_team(db, team.id)
-        pc_ids = "("
-        for p in pcs:
-            pc_ids += str(p.id) + ", "
-        def_pc_ids = pc_ids[:-2] + ")"
-        if pc != "all":
-            execute_string += " AND logs.pc_id IN " + def_pc_ids
-        else:
-            execute_string += " WHERE logs.pc_id IN " + def_pc_ids
+        if team is not None:
+            devs = get_devices_by_team(db, team.id)
+            d_ids = "("
+            for p in devs:
+                d_ids += str(p.id) + ", "
+            def_d_ids = d_ids[:-2] + ")"
+            if pc != "all" and pcs is not None:
+                if len(def_d_ids) > 1:
+                    execute_string += " AND logs.device_id IN " + def_d_ids
+            else:
+                if len(def_d_ids) > 1:
+                    execute_string += " WHERE logs.device_id IN " + def_d_ids
     if lic != "all":
-        license = find_license(db, lic)
-        device_licenses = get_license_devices(db, license.id)
-        dev_ids = "("
-        for dev in device_licenses:
-            dev_ids += str(dev.device_id) + ", "
-        defin_ids = dev_ids[:-2] + ")"
-        if pc != "all" or tema != "all":
-            execute_string += " AND logs.device_id IN " + defin_ids
-        else:
-            execute_string += " WHERE logs.device_id IN " + defin_ids
+        license = get_licenses_by_name(db, lic)
+        if license is not None:
+            device_licenses = get_license_devices(db, license.id)
+            dev_ids = "("
+            for dev in device_licenses:
+                dev_ids += str(dev.device_id) + ", "
+            defin_ids = dev_ids[:-2] + ")"
+            if pc != "all" or tema != "all":
+                if len(defin_ids) > 1:
+                    execute_string += " AND logs.device_id IN " + defin_ids
+            else:
+                if len(defin_ids) > 1:
+                    execute_string += " WHERE logs.device_id IN " + defin_ids
 
     # executing assembled query string
     result = db.execute(execute_string)
     return result
 
 
+def get_filtered_bodydevices(db: Session, body_id: str, license_id: str, team: str):
+    """
+    returns filtered body devices based on given attributes
+    """
+    execute_string = "SELECT * FROM body_devices AS device WHERE"
+    before_me = False
+    all_all = True
+    if body_id != "all":
+        all_all = False
+        body_dev = find_bodydevice_by_serial(db, body_id)
+        if body_dev != None:
+            if before_me:
+                execute_string += " AND device.id = " + str(body_dev.id)
+            else:
+                before_me = True
+                execute_string += " device.id = " + str(body_dev.id)
+    if license_id != "all":
+        all_all = False
+        license = find_license(db, license_id)
+        if license != None:
+            if before_me:
+                execute_string += " AND device.license_id = " + str(license.id)
+            else:
+                before_me = True
+                execute_string += " device.license_id = " + str(license.id)
+    if team != "all":
+        all_all = False
+        tem = find_team(db, team)
+        if tem != None:
+            if before_me:
+                execute_string += " AND device.team_id = " + str(tem.id)
+            else:
+                before_me = True
+                execute_string += " device.team_id = " + str(tem.id)
+    if all_all:
+        before_me = True
+        execute_string = "SELECT * FROM body_devices AS devices"
+
+    if not before_me:
+        execute_string = "SELECT * FROM body_devices AS devices WHERE devices.id = -1"
+    result = db.execute(execute_string)
+    return result
+
+
+def get_filtered_headdevices(db: Session, body_id: str, license_id: str, team: str):
+    """
+    returns filtered head devices based on given attributes
+    """
+    execute_string = "SELECT * FROM head_devices AS device WHERE"
+    before_me = False
+    all_all = True
+    if body_id != "all":
+        all_all = False
+        head_dev = find_headdevice_by_serial(db, body_id)
+        if head_dev != None:
+            if before_me:
+                execute_string += " AND device.id = " + str(head_dev.id)
+            else:
+                before_me = True
+                execute_string += " device.id = " + str(head_dev.id)
+    if license_id != "all":
+        all_all = False
+        license = find_license(db, license_id)
+        if license != None:
+            if before_me:
+                execute_string += " AND device.license_id = " + str(license.id)
+            else:
+                before_me = True
+                execute_string += " device.license_id = " + str(license.id)
+    if team != "all":
+        all_all = False
+        tem = find_team(db, team)
+        if tem != None:
+            if before_me:
+                execute_string += " AND device.team_id = " + str(tem.id)
+            else:
+                before_me = True
+                execute_string += " device.team_id = " + str(tem.id)
+    if all_all:
+        before_me = True
+        execute_string = "SELECT * FROM body_devices AS devices"
+
+    if not before_me:
+        execute_string = "SELECT * FROM body_devices AS devices WHERE devices.id = -1"
+    result = db.execute(execute_string)
+    return result
+
+
+def get_filtered_devices(db: Session, keyman_id: str, license_name: str, license_id: str, team: str):
+    """
+    returns filtered keyman devices based on given attributes
+    """
+    execute_string = "SELECT * FROM devices AS device WHERE"
+    before_me = False
+    all_all = True
+    if keyman_id != "all":
+        all_all = False
+        keyman_dev = find_device_by_serial(db, keyman_id)
+        if keyman_dev != None:
+            if before_me:
+                execute_string += " AND device.id = " + str(keyman_dev.id)
+            else:
+                before_me = True
+                execute_string += " device.id = " + str(keyman_dev.id)
+    if license_name != "all":
+        all_all = False
+        license = get_licenses_by_name(db, license_name)
+        if len(license) > 0:
+            lic_ids = []
+            for l in license:
+                lic_ids.append(l.id)
+            dev_lics = find_devicelicenses_by_licid_array(db, lic_ids)
+            lic_ids = "("
+            for l in dev_lics:
+                lic_ids += str(l.device_id) + ", "
+            def_lic_ids = lic_ids[:-2] + ")"
+            if before_me:
+                execute_string += " AND device.id IN " + def_lic_ids
+            else:
+                before_me = True
+                execute_string += " device.id IN " + def_lic_ids
+    if license_id != "all":
+        all_all = False
+        license = find_license(db, license_id)
+        licen_devs = get_license_devices(db, license.id)
+        ids = "("
+        for lic in licen_devs:
+            ids += str(lic.device_id) + ", "
+        def_ids = ids[:-2] + ")"
+        if license != None:
+            if before_me:
+                execute_string += " AND device.id IN " + def_ids
+            else:
+                before_me = True
+                execute_string += " device.id IN " + def_ids
+    if team != "all":
+        all_all = False
+        tem = find_team(db, team)
+        if tem != None:
+            if before_me:
+                execute_string += " AND device.team_id = " + str(tem.id)
+            else:
+                before_me = True
+                execute_string += " device.team_id = " + str(tem.id)
+    if all_all:
+        before_me = True
+        execute_string = "SELECT * FROM devices AS devices"
+
+    if not before_me:
+        execute_string = "SELECT * FROM devices AS devices WHERE devices.id = -1"
+    result = db.execute(execute_string)
+    return result
+
+
 def create_device_logs(db: Session, item: schemas.USBTempBase, dev_id: int, pc_id: int, date: datetime):
     """
     Creates new USB log for usb_logs database table
@@ -382 +956 @@
     db.add(db_log)
     db.commit()
     db.refresh(db_log)
-    return db_log</code></pre>
+    return db_log
+
+
+def get_users(db: Session, skip: int = 0, limit: int = 100):
+    &#34;&#34;&#34;
+    Returns all users saved in database
+    &#34;&#34;&#34;
+    return db.query(models.User).offset(skip).limit(limit).all()
+
+
+def find_user(db: Session, name: str):
+    &#34;&#34;&#34;
+    Finds one user by given username
+    &#34;&#34;&#34;
+    return db.query(models.User).filter(models.User.username == name).first()
+
+
+def find_user_byid(db: Session, id: int):
+    &#34;&#34;&#34;
+    Finds one user by given id
+    &#34;&#34;&#34;
+    return db.query(models.User).filter(models.User.id == id).first()
+
+
+def create_user(db: Session, name: str, passw: str, rol: str):
+    &#34;&#34;&#34;
+    Creates new user
+    &#34;&#34;&#34;
+    db_user = models.User(username=name, password=passw, role=rol)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user</code></pre>
 </details>
 </section>
 <section>
@@ -392 +998 @@
 <section>
 <h2 class="section-title" id="header-functions">Functions</h2>
 <dl>
+<dt id="sql_app.crud.change_role"><code class="name flex">
+<span>def <span class="ident">change_role</span></span>(<span>db: sqlalchemy.orm.session.Session, usr_id: int, role: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Updates team of one specific pc</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def change_role(db: Session, usr_id: int, role: str):
+    &#34;&#34;&#34;
+    Updates team of one specific pc
+    &#34;&#34;&#34;
+    old_usr = find_user_byid(db, usr_id)
+    new = {&#39;id&#39;: old_usr.id, &#39;username&#39;: old_usr.username, &#39;password&#39;: old_usr.password, &#39;role&#39;: role}
+    for key, value in new.items():
+        setattr(old_usr, key, value)
+    db.commit()
+    db.refresh(old_usr)
+    return old_usr</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.change_team"><code class="name flex">
+<span>def <span class="ident">change_team</span></span>(<span>db: sqlalchemy.orm.session.Session, team_id: int, name: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Updates name of one specific team</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def change_team(db: Session, team_id: int, name: str):
+    &#34;&#34;&#34;
+    Updates name of one specific team
+    &#34;&#34;&#34;
+    old_team = get_team(db, team_id)
+    new = {&#39;id&#39;: old_team.id, &#39;name&#39;: name}
+    for key, value in new.items():
+        setattr(old_team, key, value)
+    db.commit()
+    db.refresh(old_team)
+    return old_team</code></pre>
+</details>
+</dd>
 <dt id="sql_app.crud.create_body_device"><code class="name flex">
-<span>def <span class="ident">create_body_device</span></span>(<span>db: sqlalchemy.orm.session.Session, log: <a title="sql_app.schemas.BodyDeviceBase" href="schemas.html#sql_app.schemas.BodyDeviceBase">BodyDeviceBase</a>)</span>
+<span>def <span class="ident">create_body_device</span></span>(<span>db: sqlalchemy.orm.session.Session, log: <a title="sql_app.schemas.BodyDeviceTemp" href="schemas.html#sql_app.schemas.BodyDeviceTemp">BodyDeviceTemp</a>)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Creates new Body device</p></div>
@@ -401 +1051 @@
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def create_body_device(db: Session, log: schemas.BodyDeviceBase):
+<pre><code class="python">def create_body_device(db: Session, log: schemas.BodyDeviceTemp):
     &#34;&#34;&#34;
     Creates new Body device
     &#34;&#34;&#34;
-    db_body = models.BodyDevice(serial_number=log.serial_number)
+    db_body = models.BodyDevice(serial_number=log.serial_number, inventory_number=&#34;&#34;, comment=&#34;&#34;)
     db.add(db_body)
     db.commit()
     db.refresh(db_body)
@@ -413 +1063 @@
 </details>
 </dd>
 <dt id="sql_app.crud.create_device"><code class="name flex">
-<span>def <span class="ident">create_device</span></span>(<span>db: sqlalchemy.orm.session.Session, device: <a title="sql_app.schemas.DeviceBase" href="schemas.html#sql_app.schemas.DeviceBase">DeviceBase</a>)</span>
+<span>def <span class="ident">create_device</span></span>(<span>db: sqlalchemy.orm.session.Session, device: <a title="sql_app.schemas.DeviceTemp" href="schemas.html#sql_app.schemas.DeviceTemp">DeviceTemp</a>)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>creates new device with data from given DeviceBase object</p></div>
@@ -421 +1071 @@
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def create_device(db: Session, device: schemas.DeviceBase):
+<pre><code class="python">def create_device(db: Session, device: schemas.DeviceTemp):
     &#34;&#34;&#34;
     creates new device with data from given DeviceBase object
     &#34;&#34;&#34;
     db_device = models.Device(vendor_id=device.vendor_id, product_id=device.product_id,
-                              serial_number=device.serial_number, assigned=False)
+                              serial_number=device.serial_number, inventory_number=&#34;&#34;, comment=&#34;&#34;)
     db.add(db_device)
     db.commit()
     db.refresh(db_device)
@@ -475 +1125 @@
 </details>
 </dd>
 <dt id="sql_app.crud.create_head_device"><code class="name flex">
-<span>def <span class="ident">create_head_device</span></span>(<span>db: sqlalchemy.orm.session.Session, log: <a title="sql_app.schemas.HeadDeviceBase" href="schemas.html#sql_app.schemas.HeadDeviceBase">HeadDeviceBase</a>)</span>
+<span>def <span class="ident">create_head_device</span></span>(<span>db: sqlalchemy.orm.session.Session, log: <a title="sql_app.schemas.HeadDeviceTemp" href="schemas.html#sql_app.schemas.HeadDeviceTemp">HeadDeviceTemp</a>)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>Creates new head device</p></div>
@@ -483 +1133 @@
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def create_head_device(db: Session, log: schemas.HeadDeviceBase):
+<pre><code class="python">def create_head_device(db: Session, log: schemas.HeadDeviceTemp):
     &#34;&#34;&#34;
     Creates new head device
     &#34;&#34;&#34;
@@ -515 +1165 @@
 </details>
 </dd>
 <dt id="sql_app.crud.create_license"><code class="name flex">
-<span>def <span class="ident">create_license</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str, expdate: datetime.date)</span>
+<span>def <span class="ident">create_license</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str, lic_id: str, expdate: datetime.date)</span>
 </code></dt>
 <dd>
 <div class="desc"><p>creates new license with given name and expiration date</p></div>
@@ -523 +1173 @@
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def create_license(db: Session, name: str, expdate: date):
+<pre><code class="python">def create_license(db: Session, name: str, lic_id: str, expdate: date):
     &#34;&#34;&#34;
     creates new license with given name and expiration date
     &#34;&#34;&#34;
-    db_license = models.License(name=name, expiration_date=expdate)
+    db_license = models.License(name=name, license_id=lic_id, expiration_date=expdate)
     db.add(db_license)
     db.commit()
     db.refresh(db_license)
@@ -547 +1197 @@
     &#34;&#34;&#34;
     creates new pc with given username and hostname
     &#34;&#34;&#34;
-    db_pc = models.PC(username=user, hostname=host, assigned=False)
+    db_pc = models.PC(username=user, hostname=host)
     db.add(db_pc)
     db.commit()
     db.refresh(db_pc)
@@ -574 +1224 @@
     return db_team</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_body_device"><code class="name flex">
-<span>def <span class="ident">find_body_device</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: <a title="sql_app.schemas.BodyDeviceBase" href="schemas.html#sql_app.schemas.BodyDeviceBase">BodyDeviceBase</a>)</span>
+<dt id="sql_app.crud.create_user"><code class="name flex">
+<span>def <span class="ident">create_user</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str, passw: str, rol: str)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Finds one body device by its serial number</p></div>
+<div class="desc"><p>Creates new user</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_body_device(db: Session, serial: schemas.BodyDeviceBase):
+<pre><code class="python">def create_user(db: Session, name: str, passw: str, rol: str):
     &#34;&#34;&#34;
-    Finds one body device by its serial number
+    Creates new user
     &#34;&#34;&#34;
-    return db.query(models.BodyDevice).filter(models.BodyDevice.serial_number == serial.serial_number).first()</code></pre>
+    db_user = models.User(username=name, password=passw, role=rol)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_device"><code class="name flex">
-<span>def <span class="ident">find_device</span></span>(<span>db: sqlalchemy.orm.session.Session, device: <a title="sql_app.schemas.DeviceBase" href="schemas.html#sql_app.schemas.DeviceBase">DeviceBase</a>)</span>
+<dt id="sql_app.crud.delete_device_license"><code class="name flex">
+<span>def <span class="ident">delete_device_license</span></span>(<span>db: sqlalchemy.orm.session.Session, device: int, license: int)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>finds one device with product_id, vendor_id and serial_number same as in given DeviceBase object</p></div>
+<div class="desc"><p>deletes entry in devices_licenses table with device id, license id and time.</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_device(db: Session, device: schemas.DeviceBase):
+<pre><code class="python">def delete_device_license(db: Session, device: int, license: int):
     &#34;&#34;&#34;
-    finds one device with product_id, vendor_id and serial_number same as in given DeviceBase object
+    deletes entry in devices_licenses table with device id, license id and time.
     &#34;&#34;&#34;
-    return db.query(models.Device).filter(and_(models.Device.product_id == device.product_id,
-                                               models.Device.vendor_id == device.vendor_id,
-                                               models.Device.serial_number == device.serial_number)).first()</code></pre>
+    db_device_license = get_devicelicense_by_devicelicense(db, device, license)
+    db_lic = db.delete(db_device_license)
+    db.commit()
+    return db_lic</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_filtered_logs"><code class="name flex">
-<span>def <span class="ident">find_filtered_logs</span></span>(<span>db: sqlalchemy.orm.session.Session, logs: [])</span>
+<dt id="sql_app.crud.find_body_device"><code class="name flex">
+<span>def <span class="ident">find_body_device</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: <a title="sql_app.schemas.BodyDeviceTemp" href="schemas.html#sql_app.schemas.BodyDeviceTemp">BodyDeviceTemp</a>)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Returns all usb logs with ids in given id array.</p></div>
+<div class="desc"><p>Finds one body device by its serial number</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_filtered_logs(db: Session, logs: []):
+<pre><code class="python">def find_body_device(db: Session, serial: schemas.BodyDeviceTemp):
     &#34;&#34;&#34;
-    Returns all usb logs with ids in given id array.
+    Finds one body device by its serial number
     &#34;&#34;&#34;
-    return db.query(models.USBLog).filter(models.USBLog.id.in_(logs)).order_by(desc(models.USBLog.timestamp)).all()</code></pre>
+    return db.query(models.BodyDevice).filter(models.BodyDevice.serial_number == serial.serial_number).first()</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_head_device"><code class="name flex">
-<span>def <span class="ident">find_head_device</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: <a title="sql_app.schemas.HeadDeviceBase" href="schemas.html#sql_app.schemas.HeadDeviceBase">HeadDeviceBase</a>)</span>
+<dt id="sql_app.crud.find_bodydevice_by_serial"><code class="name flex">
+<span>def <span class="ident">find_bodydevice_by_serial</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: str)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Finds one head device by its serial number</p></div>
+<div class="desc"><p>Finds one specific body device by given serial number</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_head_device(db: Session, serial: schemas.HeadDeviceBase):
+<pre><code class="python">def find_bodydevice_by_serial(db: Session, serial: str):
     &#34;&#34;&#34;
-    Finds one head device by its serial number
+    Finds one specific body device by given serial number
     &#34;&#34;&#34;
-    return db.query(models.HeadDevice).filter(models.HeadDevice.serial_number == serial.serial_number).first()</code></pre>
+    return db.query(models.BodyDevice).filter(models.BodyDevice.serial_number == serial).first()</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_license"><code class="name flex">
-<span>def <span class="ident">find_license</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str)</span>
+<dt id="sql_app.crud.find_bodydevices_by_license"><code class="name flex">
+<span>def <span class="ident">find_bodydevices_by_license</span></span>(<span>db: sqlalchemy.orm.session.Session, lic_id: int)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>finds one license by given string name</p></div>
+<div class="desc"><p>Returns all body devices with specific license</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_license(db: Session, name: str):
+<pre><code class="python">def find_bodydevices_by_license(db: Session, lic_id: int):
     &#34;&#34;&#34;
-    finds one license by given string name
+    Returns all body devices with specific license
     &#34;&#34;&#34;
-    return db.query(models.License).filter(models.License.name == name).first()</code></pre>
+    return db.query(models.BodyDevice).filter(models.BodyDevice.license_id == lic_id).all()</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_pc"><code class="name flex">
-<span>def <span class="ident">find_pc</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str, hostname: str)</span>
+<dt id="sql_app.crud.find_bodydevices_by_team"><code class="name flex">
+<span>def <span class="ident">find_bodydevices_by_team</span></span>(<span>db: sqlalchemy.orm.session.Session, team_id: int)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Finds one pc with given username and hostname</p></div>
+<div class="desc"><p>Returns all body devices in specific team</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_pc(db: Session, username: str, hostname: str):
+<pre><code class="python">def find_bodydevices_by_team(db: Session, team_id: int):
     &#34;&#34;&#34;
-    Finds one pc with given username and hostname
+    Returns all body devices in specific team
     &#34;&#34;&#34;
-    return db.query(models.PC).filter(and_(models.PC.username == username,
-                                           models.PC.hostname == hostname)).first()</code></pre>
+    return db.query(models.BodyDevice).filter(models.BodyDevice.team_id == team_id).all()</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_pc_by_name"><code class="name flex">
-<span>def <span class="ident">find_pc_by_name</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str)</span>
+<dt id="sql_app.crud.find_device"><code class="name flex">
+<span>def <span class="ident">find_device</span></span>(<span>db: sqlalchemy.orm.session.Session, device: <a title="sql_app.schemas.DeviceTemp" href="schemas.html#sql_app.schemas.DeviceTemp">DeviceTemp</a>)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Finds one pc by its username</p></div>
+<div class="desc"><p>finds one device with
+serial_number same as in given DeviceBase object</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_pc_by_name(db: Session, username: str):
+<pre><code class="python">def find_device(db: Session, device: schemas.DeviceTemp):
     &#34;&#34;&#34;
-    Finds one pc by its username
+    finds one device with  serial_number same as in given DeviceBase object
     &#34;&#34;&#34;
-    return db.query(models.PC).filter(models.PC.username == username).first()</code></pre>
+    return db.query(models.Device).filter(and_(models.Device.serial_number == device.serial_number)).first()</code></pre>
 </details>
 </dd>
-<dt id="sql_app.crud.find_pc_by_name_all"><code class="name flex">
-<span>def <span class="ident">find_pc_by_name_all</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str)</span>
+<dt id="sql_app.crud.find_device_by_serial"><code class="name flex">
+<span>def <span class="ident">find_device_by_serial</span></span>(<span>db: sqlalchemy.orm.session.Session, ser: str)</span>
 </code></dt>
 <dd>
-<div class="desc"><p>Finds all pcs with same username</p></div>
+<div class="desc"><p>finds one device with serial_number same as in given DeviceBase object</p></div>
 <details class="source">
 <summary>
 <span>Expand source code</span>
 </summary>
-<pre><code class="python">def find_pc_by_name_all(db: Session, username: str):
+<pre><code class="python">def find_device_by_serial(db: Session, ser: str):
     &#34;&#34;&#34;
-    Finds all pcs with same username
+    finds one device with serial_number same as in given DeviceBase object
+    &#34;&#34;&#34;
+    return db.query(models.Device).filter(and_(models.Device.serial_number == ser)).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_devicelicenses_by_licid_array"><code class="name flex">
+<span>def <span class="ident">find_devicelicenses_by_licid_array</span></span>(<span>db: sqlalchemy.orm.session.Session, lcs: [])</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds all device_licenses with license_id in given id array</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_devicelicenses_by_licid_array(db: Session, lcs: []):
+    &#34;&#34;&#34;
+    Finds all device_licenses with license_id in given id array
+    &#34;&#34;&#34;
+    return db.query(models.DeviceLicense).filter(models.DeviceLicense.license_id.in_(lcs)).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_filtered_ldlogs"><code class="name flex">
+<span>def <span class="ident">find_filtered_ldlogs</span></span>(<span>db: sqlalchemy.orm.session.Session, logs: [])</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Returns all ld logs with ids in given id array.</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_filtered_ldlogs(db: Session, logs: []):
+    &#34;&#34;&#34;
+    Returns all ld logs with ids in given id array.
+    &#34;&#34;&#34;
+    return db.query(models.LDLog).filter(models.LDLog.id.in_(logs)).order_by(desc(models.LDLog.timestamp)).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_filtered_logs"><code class="name flex">
+<span>def <span class="ident">find_filtered_logs</span></span>(<span>db: sqlalchemy.orm.session.Session, logs: [])</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Returns all usb logs with ids in given id array.</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_filtered_logs(db: Session, logs: []):
+    &#34;&#34;&#34;
+    Returns all usb logs with ids in given id array.
+    &#34;&#34;&#34;
+    return db.query(models.USBLog).filter(models.USBLog.id.in_(logs)).order_by(desc(models.USBLog.timestamp)).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_head_device"><code class="name flex">
+<span>def <span class="ident">find_head_device</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: <a title="sql_app.schemas.HeadDeviceTemp" href="schemas.html#sql_app.schemas.HeadDeviceTemp">HeadDeviceTemp</a>)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one head device by its serial number</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_head_device(db: Session, serial: schemas.HeadDeviceTemp):
+    &#34;&#34;&#34;
+    Finds one head device by its serial number
+    &#34;&#34;&#34;
+    return db.query(models.HeadDevice).filter(models.HeadDevice.serial_number == serial.serial_number).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_headdevice_by_serial"><code class="name flex">
+<span>def <span class="ident">find_headdevice_by_serial</span></span>(<span>db: sqlalchemy.orm.session.Session, serial: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one specific head device by given serial number</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_headdevice_by_serial(db: Session, serial: str):
+    &#34;&#34;&#34;
+    Finds one specific head device by given serial number
+    &#34;&#34;&#34;
+    return db.query(models.HeadDevice).filter(models.HeadDevice.serial_number == serial).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_headdevices_by_license"><code class="name flex">
+<span>def <span class="ident">find_headdevices_by_license</span></span>(<span>db: sqlalchemy.orm.session.Session, lic_id: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Returns all head devices with specific license</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_headdevices_by_license(db: Session, lic_id: int):
+    &#34;&#34;&#34;
+    Returns all head devices with specific license
+    &#34;&#34;&#34;
+    return db.query(models.HeadDevice).filter(models.HeadDevice.license_id == lic_id).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_headdevices_by_team"><code class="name flex">
+<span>def <span class="ident">find_headdevices_by_team</span></span>(<span>db: sqlalchemy.orm.session.Session, team_id: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Returns all head devices in specific team</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_headdevices_by_team(db: Session, team_id: int):
+    &#34;&#34;&#34;
+    Returns all head devices in specific team
+    &#34;&#34;&#34;
+    return db.query(models.HeadDevice).filter(models.HeadDevice.team_id == team_id).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_license"><code class="name flex">
+<span>def <span class="ident">find_license</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>finds one license by given string name</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_license(db: Session, name: str):
+    &#34;&#34;&#34;
+    finds one license by given string name
+    &#34;&#34;&#34;
+    return db.query(models.License).filter(models.License.license_id == name).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_pc"><code class="name flex">
+<span>def <span class="ident">find_pc</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str, hostname: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one pc with given username and hostname</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_pc(db: Session, username: str, hostname: str):
+    &#34;&#34;&#34;
+    Finds one pc with given username and hostname
+    &#34;&#34;&#34;
+    return db.query(models.PC).filter(and_(models.PC.username == username,
+                                           models.PC.hostname == hostname)).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_pc_by_name"><code class="name flex">
+<span>def <span class="ident">find_pc_by_name</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one pc by its username</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_pc_by_name(db: Session, username: str):
+    &#34;&#34;&#34;
+    Finds one pc by its username
+    &#34;&#34;&#34;
+    return db.query(models.PC).filter(models.PC.username == username).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_pc_by_name_all"><code class="name flex">
+<span>def <span class="ident">find_pc_by_name_all</span></span>(<span>db: sqlalchemy.orm.session.Session, username: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds all pcs with same username</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_pc_by_name_all(db: Session, username: str):
+    &#34;&#34;&#34;
+    Finds all pcs with same username
     &#34;&#34;&#34;
     return db.query(models.PC).filter(models.PC.username == username).offset(0).limit(100).all()</code></pre>
 </details>
@@ -753 +1585 @@
     return db.query(models.Team).filter(models.Team.name == name).first()</code></pre>
 </details>
 </dd>
+<dt id="sql_app.crud.find_user"><code class="name flex">
+<span>def <span class="ident">find_user</span></span>(<span>db: sqlalchemy.orm.session.Session, name: str)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one user by given username</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_user(db: Session, name: str):
+    &#34;&#34;&#34;
+    Finds one user by given username
+    &#34;&#34;&#34;
+    return db.query(models.User).filter(models.User.username == name).first()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.find_user_byid"><code class="name flex">
+<span>def <span class="ident">find_user_byid</span></span>(<span>db: sqlalchemy.orm.session.Session, id: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>Finds one user by given id</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def find_user_byid(db: Session, id: int):
+    &#34;&#34;&#34;
+    Finds one user by given id
+    &#34;&#34;&#34;
+    return db.query(models.User).filter(models.User.id == id).first()</code></pre>
+</details>
+</dd>
 <dt id="sql_app.crud.get_body_device"><code class="name flex">
 <span>def <span class="ident">get_body_device</span></span>(<span>db: sqlalchemy.orm.session.Session, body_id: int)</span>
 </code></dt>
@@ -785 +1649 @@
     return db.query(models.BodyDevice).offset(skip).limit(limit).all()</code></pre>
 </details>
 </dd>
+<dt id="sql_app.crud.get_bodydevices_with_ids"><code class="name flex">
+<span>def <span class="ident">get_bodydevices_with_ids</span></span>(<span>db: sqlalchemy.orm.session.Session, ids: [])</span>
+</code></dt>
+<dd>
+<div class="desc"><p>returns all bodydevices with given ids</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def get_bodydevices_with_ids(db: Session, ids: []):
+    &#34;&#34;&#34;
+    returns all bodydevices with given ids
+    &#34;&#34;&#34;
+    return db.query(models.BodyDevice).filter(models.BodyDevice.id.in_(ids)).all()</code></pre>
+</details>
+</dd>
 <dt id="sql_app.crud.get_device"><code class="name flex">
 <span>def <span class="ident">get_device</span></span>(<span>db: sqlalchemy.orm.session.Session, device_id: int)</span>
 </code></dt>
@@ -801 +1681 @@
     return db.query(models.Device).filter(models.Device.id == device_id).first()</code></pre>
 </details>
 </dd>
+<dt id="sql_app.crud.get_device_licenses"><code class="name flex">
+<span>def <span class="ident">get_device_licenses</span></span>(<span>db: sqlalchemy.orm.session.Session, device_id: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>returns all entries in devices_licenses table with given device_id</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def get_device_licenses(db: Session, device_id: int):
+    &#34;&#34;&#34;
+    returns all entries in devices_licenses table with given device_id
+    &#34;&#34;&#34;
+    return db.query(models.DeviceLicense).filter(models.DeviceLicense.device_id == device_id).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.get_devicelicense_by_devicelicense"><code class="name flex">
+<span>def <span class="ident">get_devicelicense_by_devicelicense</span></span>(<span>db: sqlalchemy.orm.session.Session, device_id: int, license_id: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>returns entry in devices_licenses table with given device id and license id</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def get_devicelicense_by_devicelicense(db: Session, device_id: int, license_id: int):
+    &#34;&#34;&#34;
+    returns entry in devices_licenses table with given device id and license id
+    &#34;&#34;&#34;
+    return db.query(models.DeviceLicense).filter(and_(models.DeviceLicense.device_id == device_id,
+                                                      models.DeviceLicense.license_id == license_id)).first()</code></pre>
+</details>
+</dd>
 <dt id="sql_app.crud.get_devices"><code class="name flex">
 <span>def <span class="ident">get_devices</span></span>(<span>db: sqlalchemy.orm.session.Session, skip: int = 0, limit: int = 100)</span>
 </code></dt>
@@ -817 +1730 @@
     return db.query(models.Device).offset(skip).limit(limit).all()</code></pre>
 </details>
 </dd>
+<dt id="sql_app.crud.get_devices_by_team"><code class="name flex">
+<span>def <span class="ident">get_devices_by_team</span></span>(<span>db: sqlalchemy.orm.session.Session, team: int)</span>
+</code></dt>
+<dd>
+<div class="desc"><p>returns all devices with same team</p></div>
+<details class="source">
+<summary>
+<span>Expand source code</span>
+</summary>
+<pre><code class="python">def get_devices_by_team(db: Session, team: int):
+    &#34;&#34;&#34;
+    returns all devices with same team
+    &#34;&#34;&#34;
+    return db.query(models.Device).filter(models.Device.team_id == team).all()</code></pre>
+</details>
+</dd>
+<dt id="sql_app.crud.get_devices_with_ids"><code class="name flex">