Merge pull request #3 from booskit-codes/nightly

1.1 - Nightly merge into main

Author: b00skit

README.md

@@ -16,6 +16,10 @@ The program automatically collects and sends the following information from your
 - Storage Information (`_snipeit_storage_information_7`)
 - Processor / CPU (`_snipeit_processor_cpu_8`)
 - IP Address (`_snipeit_ip_address_9`)
+- BIOS Release Date (`_snipeit_bios_release_date_10`)
+- Windows Username (`_snipeit_windows_username_11`)
+- RAM Usage (`_snipeit_ram_used_12`)
+- Disk Space Used (`_snipeit_disk_space_used_13`)
 
 [Download the latest version here](https://github.com/booskit-codes/PyITAgent/releases/).
 

config-example.ini

@@ -1,3 +1,9 @@
 [DEFAULT]
 site = http://insert_url_here.com/api/v1
-api_key = insert_api_key_here
+api_key = insert_api_key_here
+
+[GENERAL]
+snipeit_status_id = 2
+snipeit_company_id = 1
+snipeit_category_id = 3
+snipeit_fieldset_id = 1

main.py

@@ -5,25 +5,65 @@
 import sys
 
 class ITInventoryClient:
-    def __init__(self, url, access_token):
-        self.access_token = access_token
+    def __init__(self, config):
+        self.config = config
+        self.access_token = config['DEFAULT']['api_key']
         self.headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {self.access_token}",
             "content-type": "application/json"
         }
-        self.url_prefix = url
+        self.url_prefix = config['DEFAULT']['site']
         self.manufacturer = self.run_command("(gwmi win32_computersystem).manufacturer")
         self.serial_number = self.determine_serial_number()
         self.hostname = self.run_command("(Get-WmiObject Win32_OperatingSystem).CSName")
         self.os = self.run_command("(Get-WmiObject Win32_OperatingSystem).Caption")
         self.ram_available = self.run_command("[Math]::Round((Get-WmiObject Win32_ComputerSystem).totalphysicalmemory / 1gb,1)")
-        self.os_install_date = self.run_command("Get-CimInstance Win32_OperatingSystem | Select-Object  InstallDate | ForEach{ $_.InstallDate }")
+        self.ram_used = self.run_command("[Math]::Round(((Get-WmiObject Win32_ComputerSystem).TotalPhysicalMemory - (Get-WmiObject Win32_OperatingSystem).FreePhysicalMemory * 1024) / 1GB, 2)")
+        self.os_install_date = self.run_command("[math]::Round((New-TimeSpan -Start (Get-Date '1970-01-01') -End (Get-CimInstance Win32_OperatingSystem).InstallDate).TotalSeconds)")
+        self.bios_release_date = self.run_command("[math]::Round((New-TimeSpan -Start (Get-Date '1970-01-01') -End (Get-CimInstance Win32_BIOS).ReleaseDate).TotalSeconds)")
         self.model_number, self.model = self.determine_model_info()
         self.ip_address = self.run_command("(Test-Connection (hostname) -count 1).IPv4Address.IPAddressToString")
-        self.disk_size, self.disk_info = self.determine_disk_info()
-        self.mac_addresses = self.run_command("(Get-WmiObject Win32_NetworkAdapterConfiguration | where {$_.ipenabled -EQ $true}).Macaddress")
+        self.disk_size, self.disk_info, self.disk_used = self.determine_disk_info()
+        self.mac_addresses = self.run_command("(Get-WmiObject Win32_NetworkAdapterConfiguration | Where-Object {$_.IPEnabled -eq $true} | Select-Object -First 1).MACAddress")
         self.processor = self.run_command("(gwmi Win32_processor).name")
+        self.current_user = self.run_command("[System.Security.Principal.WindowsIdentity]::GetCurrent().Name")
+
+    def resolve_payload(self, type, values):
+        match type:
+            case "hardware":
+                return {
+                    'serial': values['serial_number'],
+                    'name': self.hostname,
+                    'asset_tag': values['serial_number'],
+                    'status_id': values['status_id'],
+                    'model_id': values['model_id'],
+                    'company_id': values['company_id'],
+                    '_snipeit_mac_address_1': self.mac_addresses,
+                    '_snipeit_memory_ram_2': self.ram_available,
+                    '_snipeit_operating_system_3': self.os,
+                    '_snipeit_os_install_date_4': self.os_install_date,
+                    '_snipeit_ip_address_9': self.ip_address,
+                    '_snipeit_total_storage_6': self.disk_size,
+                    '_snipeit_storage_information_7': self.disk_info,
+                    '_snipeit_processor_cpu_8': self.processor,
+                    '_snipeit_bios_release_date_10': self.bios_release_date,
+                    '_snipeit_windows_username_11': self.current_user,
+                    '_snipeit_ram_used_12': self.ram_used,
+                    '_snipeit_disk_space_used_13': self.disk_used
+                }
+            case "model":
+                return {
+                    "name": self.model,
+                    "model_number": self.model_number,
+                    "category_id": values['category_id'],
+                    "manufacturer_id": values['manufacturer_id'],
+                    "fieldset_id": values['fieldset_id']
+                }
+            case "manufacturer":
+                return {
+                    values['manufacturer_name']
+                }
 
     def run_command(self, cmd):
         completed = subprocess.run(["powershell.exe", "-Command", cmd], capture_output=True)
@@ -55,7 +95,8 @@ def determine_disk_info(self):
             echo "$($_.MediaType) - $($_.Model) - $($_.SerialNumber) - $([Math]::Round($_.Size/1gb,2)) GB"
         }
         """)
-        return disk_size, disk_info
+        disk_used = self.run_command("[Math]::Round(((Get-WmiObject Win32_LogicalDisk -Filter \"DeviceID='C:'\").Size - (Get-WmiObject Win32_LogicalDisk -Filter \"DeviceID='C:'\").FreeSpace) / 1GB, 2)")
+        return disk_size, disk_info, disk_used
 
     def send_request(self, method, endpoint, payload=None):
         url = f"{self.url_prefix}/{endpoint}"
@@ -87,7 +128,10 @@ def get_manufacturer(self, manufacturer_name):
 
     def post_manufacturer(self, manufacturer_name):
         endpoint = 'manufacturers'
-        payload = {'name': manufacturer_name}
+        values = {
+            'manufacturer_name': manufacturer_name,
+        }
+        payload = self.resolve_payload("manufacturer", values)
         response = self.send_request('POST', endpoint, payload=payload)
         if response.get('status') == 'success':
             return True
@@ -104,15 +148,14 @@ def get_or_create_manufacturer(self, manufacturer_name):
                 manufacturer_id = self.get_manufacturer(manufacturer_name)
         return manufacturer_id
 
-    def post_model(self, model_name, model_number, manufacturer_id, category_id=3, fieldset_id=1):
+    def post_model(self, manufacturer_id, category_id = 3, fieldset_id = 1):
         endpoint = 'models'
-        payload = {
-            "name": model_name,
-            "model_number": model_number,
-            "category_id": category_id,
-            "manufacturer_id": manufacturer_id,
-            "fieldset_id": fieldset_id
+        values = {
+            'manufacturer_id': manufacturer_id,
+            'category_id': category_id,
+            'fieldset_id': fieldset_id
         }
+        payload = self.resolve_payload("model", values)
         response = self.send_request('POST', endpoint, payload=payload)
         if response.get('status') == 'success':
             return True
@@ -131,33 +174,24 @@ def get_model(self, model_name):
         print("No model found in database, perhaps create a new one?")
         return None
 
-    def get_or_create_model(self, model_name, model_number, manufacturer_id):
-        model_id = self.get_model(model_name)
+    def get_or_create_model(self, manufacturer_id):
+        model_id = self.get_model(self.model)
         if model_id is None:
             print("Creating new model")
-            success = self.post_model(model_name, model_number, manufacturer_id)
+            success = self.post_model(manufacturer_id, self.config['GENERAL']['snipeit_category_id'], self.config['GENERAL']['snipeit_fieldset_id'])
             if success:
-                model_id = self.get_model(model_name)
+                model_id = self.get_model(self.model)
         return model_id
 
-    def post_hardware(self, serial_number, pc_name, model_id, mac_address, ram_available, operating_system, os_install_date, ipv4, disk_size, disk_info, cpu, status_id=2, company_id=1):
+    def post_hardware(self, serial_number, model_id, status_id, company_id):
         endpoint = 'hardware'
-        payload = {
-            'serial': serial_number,
-            'name': pc_name,
-            'asset_tag': serial_number,  # Assuming this method exists
+        values = {
+            'serial_number': serial_number,
             'status_id': status_id,
             'model_id': model_id,
             'company_id': company_id,
-            '_snipeit_mac_address_1': mac_address,
-            '_snipeit_memory_ram_2': ram_available,
-            '_snipeit_operating_system_3': operating_system,
-            '_snipeit_os_install_date_4': os_install_date,
-            '_snipeit_ip_address_9': ipv4,
-            '_snipeit_total_storage_6': disk_size,
-            '_snipeit_storage_information_7': disk_info,
-            '_snipeit_processor_cpu_8': cpu
         }
+        payload = self.resolve_payload("hardware", values)
         response = self.send_request('POST', endpoint, payload=payload)
         if response.get('status') == 'success':
             return True
@@ -176,42 +210,33 @@ def get_hardware(self, serial_number):
         print("No hardware found in database, perhaps create a new one?")
         return None
 
-    def patch_hardware(self, hardware_id, serial_number, pc_name, model_id, mac_address, ram_available, operating_system, os_install_date, ipv4, disk_size, disk_info, cpu, status_id=2, company_id=1):
+    def patch_hardware(self, hardware_id, serial_number, model_id, status_id, company_id):
         endpoint = f'hardware/{hardware_id}?deleted=false'
-        payload = {
-            'serial': serial_number,
-            'name': pc_name,
-            'asset_tag': serial_number,  # Assuming this method exists
+        values = {
+            'serial_number': serial_number,
             'status_id': status_id,
             'model_id': model_id,
             'company_id': company_id,
-            '_snipeit_mac_address_1': mac_address,
-            '_snipeit_memory_ram_2': ram_available,
-            '_snipeit_operating_system_3': operating_system,
-            '_snipeit_os_install_date_4': os_install_date,
-            '_snipeit_ip_address_9': ipv4,
-            '_snipeit_total_storage_6': disk_size,
-            '_snipeit_storage_information_7': disk_info,
-            '_snipeit_processor_cpu_8': cpu
         }
+        payload = self.resolve_payload("hardware", values)
         response = self.send_request('PATCH', endpoint, payload=payload)
         if response.get('status') == 'success':
             return True
         else:
             print(f"Failed to update hardware: {response.get('messages')}")
             return False
 
-    def get_or_create_hardware(self, serial_number, pc_name, model_id, mac_address, ram_available, operating_system, os_install_date, ipv4, disk_size, disk_info, cpu, update_hardware):
-        hardware_id = self.get_hardware(serial_number)
+    def get_or_create_hardware(self, model_id, update_hardware, status_id = 2, company_id = 1):
+        hardware_id = self.get_hardware(self.serial_number)
         if hardware_id is None:
             print("Creating new hardware")
             update_hardware = False
-            success = self.post_hardware(serial_number, pc_name, model_id, mac_address, ram_available, operating_system, os_install_date, ipv4, disk_size, disk_info, cpu)
+            success = self.post_hardware(self.serial_number, model_id, status_id, company_id)
             if success:
-                hardware_id = self.get_hardware(serial_number)
+                hardware_id = self.get_hardware(self.serial_number)
         if update_hardware:
             print("Patching hardware")
-            self.patch_hardware(hardware_id, serial_number, pc_name, model_id, mac_address, ram_available, operating_system, os_install_date, ipv4, disk_size, disk_info, cpu)
+            self.patch_hardware(hardware_id, self.serial_number, model_id, status_id, company_id)
         return hardware_id
 
 # Resolve pyinstaller's stoopid windows executable path issue
@@ -251,11 +276,7 @@ def main():
 
     # VV Seriously just don't change any of this. VV
     config = get_config()
-
-    url = config['DEFAULT']['site']
-    api_key = config['DEFAULT']['api_key']
-
-    it_client = ITInventoryClient(url, api_key)
+    it_client = ITInventoryClient(config)
     # ΛΛ Seriously just don't change any of this. ΛΛ
 
     # This will serve as both debugging purposes & just general information, nothing bad with information.
@@ -268,12 +289,16 @@ def main():
           Hostname: {it_client.hostname}
           OS: {it_client.os}
           Ram Available: {it_client.ram_available}
+          Ram Used: {it_client.ram_used}
           OS Install Date: {it_client.os_install_date}
           Model Number: {it_client.model_number}
           IP Address: {it_client.ip_address}
           Disk Size: {it_client.disk_size}
+          Disk Used: {it_client.disk_used}
           MAC Address: {it_client.mac_addresses}
           Processor: {it_client.processor}
+          Current User: {it_client.current_user}
+          BIOS Release Date: {it_client.bios_release_date}
           """)
 
     # Get the manufacturer
@@ -283,14 +308,16 @@ def main():
     print("Manufacturer fetched: ", manufacturer_id)
 
     # Get the model
-    model_id = it_client.get_or_create_model(it_client.model, it_client.model_number, manufacturer_id)
+    model_id = it_client.get_or_create_model(manufacturer_id)
     if model_id is None:
         return print("Failed to fetch model")
     print("Model fetched: ", model_id)
 
     # Get the hardware, if it exists, update it properly.
+    snipeit_status_id = config['GENERAL']['snipeit_status_id']
+    snipeit_company_id = config['GENERAL']['snipeit_company_id']
     update_hardware = True
-    hardware_id = it_client.get_or_create_hardware(it_client.serial_number, it_client.hostname, model_id, it_client.mac_addresses, it_client.ram_available, it_client.os, it_client.os_install_date, it_client.ip_address, it_client.disk_size, it_client.disk_info, it_client.processor, update_hardware)
+    hardware_id = it_client.get_or_create_hardware(model_id, update_hardware, snipeit_status_id, snipeit_company_id)
     if hardware_id is None:
         return print("Failed to fetch hardware")
     print("Hardware fetched: ", hardware_id)

ps.py

@@ -0,0 +1,41 @@
+import logging
+import subprocess
+
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class PowerShellLogging:
+    def __init__(self):
+        self.manufacturer = self.run_command("(gwmi win32_computersystem).manufacturer")
+
+    def run_command(self, cmd):
+        try:
+            completed = subprocess.run(["powershell.exe", "-Command", cmd], capture_output=True, text=True)
+            
+            # Check if the command was executed successfully
+            if completed.returncode == 0:
+                logging.info(f"Command executed successfully: {cmd}")
+                return completed.stdout.strip()
+            else:
+                # Log an error if the command failed
+                logging.error(f"Command failed with return code {completed.returncode}: {cmd}")
+                logging.error(f"Error output: {completed.stderr.strip()}")
+                return None
+        except Exception as e:
+            # Log any exceptions that occur during execution
+            logging.exception(f"An exception occurred while executing the command: {cmd}")
+            return None
+    
+def test_powershell():
+
+    ps = PowerShellLogging()
+    
+    # This will serve as both debugging purposes & just general information, nothing bad with information.
+    print(f"""
+          Powershell Logging
+          -------------------------
+          
+          Manufacturer: {ps.manufacturer}
+          """)
+
+if __name__ == "__main__":
+    test_powershell()