Created
February 20, 2024 15:55
-
-
Save hcosta/cf7a6ff89b175e51c5093158ccfc65d1 to your computer and use it in GitHub Desktop.
programa.py
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Programari per extreure INFO remotament del equip | |
| # Data creació: 15/11/2023 | |
| # Data modificacio: 14/02/2024 | |
| # CarReel i chatgpt | |
| # Version 3.0 | |
| # Importar los módulos necesarios | |
| #PARTE 1 | |
| import os | |
| import socket | |
| import subprocess | |
| import sys | |
| import time | |
| from configparser import ConfigParser | |
| from datetime import datetime # Agrega esta línea | |
| import wmi | |
| from PySide2.QtGui import QIcon | |
| from PySide2.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QTextEdit, QWidget | |
| from PySide2.QtWidgets import QFrame, QLineEdit, QPushButton | |
| from PySide2.QtWidgets import QLabel | |
| from PySide2.QtWidgets import QMessageBox | |
| import sys | |
| class RemoteInfoExtractor(QMainWindow): | |
| def __init__(self, programas_instalados): | |
| super(RemoteInfoExtractor, self).__init__() | |
| self.setWindowTitle("Llistat de programes instal·lats") | |
| self.setMinimumSize(400, 600) | |
| central_widget = QWidget(self) | |
| self.setCentralWidget(central_widget) | |
| central_layout = QVBoxLayout(central_widget) | |
| # Configurar el área de desplazamiento y widget | |
| scroll_area = QFrame(self) | |
| scroll_area.setFrameShape(QFrame.StyledPanel) | |
| layout_scroll = QVBoxLayout(scroll_area) | |
| central_layout.addWidget(scroll_area) | |
| # Configurar el área de búsqueda | |
| search_layout = QVBoxLayout() | |
| search_label = QLabel("Buscar programa:") | |
| self.search_input = QLineEdit(self) | |
| self.search_input.textChanged.connect(self.filter_programs) | |
| search_layout.addWidget(search_label) | |
| search_layout.addWidget(self.search_input) | |
| # Configurar el área de texto para mostrar los programas instalados | |
| self.programs_text = QTextEdit(self) | |
| self.programs_text.setReadOnly(True) | |
| layout_scroll.addLayout(search_layout) | |
| layout_scroll.addWidget(self.programs_text) | |
| # Construir el texto HTML con colores | |
| self.programas_instalados = programas_instalados | |
| self.filter_programs() | |
| # Establecer el texto HTML en el QTextEdit | |
| self.setLayout(central_layout) | |
| def filter_programs(self): | |
| print("Filtrando programas por version") | |
| search_text = self.search_input.text().lower() | |
| html_text = "" | |
| version_a_comparar = "1.4.10.721" | |
| alarmas_ics_keyword = "alertaics - Versión: 4.9" | |
| skype_keyword = "skype - Versión: 16.0.4417.1000" | |
| for programa_info in self.programas_instalados: | |
| nombre, version = programa_info.split(" - Versión: ") | |
| # Comparar las versiones | |
| if version == version_a_comparar or ( | |
| alarmas_ics_keyword.lower() in nombre.lower() and version.startswith("4.9")) or ( | |
| skype_keyword.lower() in nombre.lower() and version == "16.0.4417.1000"): | |
| color = "red" | |
| else: | |
| color = "green" | |
| # Filtrar por el texto de búsqueda | |
| if search_text in nombre.lower(): | |
| # Marcar en rojo si el programa coincide con alguna de las condiciones anteriores | |
| html_text += f'<font color="{color}"><b>{nombre}</b> - Versión: {version}</font><br>' | |
| # Establecer el texto HTML en el QTextEdit | |
| self.programs_text.setHtml(html_text) | |
| class RemoteInfoApp(QMainWindow): | |
| def __init__(self): | |
| super().__init__() | |
| self.initUI() | |
| def obtener_programas_instalados(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtención de programas instalados...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| programas = {} | |
| for programa in c.Win32Reg_AddRemovePrograms(): | |
| nombre = programa.DisplayName | |
| version = programa.Version | |
| # Usar el nombre del programa como clave en un diccionario | |
| if nombre not in programas: | |
| programas[nombre] = version | |
| # Crear la lista de programas con formato | |
| lista_programas = [f"{nombre} - Versión: {version}" for nombre, version in programas.items()] | |
| lista_programas.sort() | |
| return lista_programas | |
| except Exception as e: | |
| print(f"Error al obtener la lista de programas instalados en el equipo remoto ({nombre_equipo}): {str(e)}") | |
| return [] | |
| def obtener_ubicacion(self, nombre_equipo): | |
| # Rutas del archivo de alarmas | |
| ruta_archivo_alarma1 = f"\\\\{nombre_equipo}\\c$\\Program Files\\AlertaICS\\AlertaICS.ini" | |
| ruta_archivo_alarma2 = f"\\\\{nombre_equipo}\\c$\\Program Files (x86)\\AlertaICS\\AlertaICS.ini" | |
| print("Procesando la obtención de la ubicacion del ordenador...") | |
| # Sección que deseas leer del archivo INI | |
| seccion = 'Datos_Globales' | |
| # Intentar obtener los valores desde la primera ruta | |
| valores = self.leer_campos_desde_ini(ruta_archivo_alarma1, seccion) | |
| # Si los valores no se obtienen desde la primera ruta, intentar desde la segunda ruta | |
| if valores is None: | |
| valores = self.leer_campos_desde_ini(ruta_archivo_alarma2, seccion) | |
| if valores is not None: | |
| # Obtener los valores específicos que te interesan | |
| lugar_trabajo = valores.get('lugar_trabajo', '') | |
| unidad_productiva = valores.get('unidad_productiva', '') | |
| # Inicializar la variable html_text | |
| html_text = '' | |
| # Marcar en rojo si el programa coincide con alguna de las condiciones anteriores | |
| html_text += f'<font color="red"><b>{lugar_trabajo}</b>- Versión: {unidad_productiva}</font><br>' | |
| return lugar_trabajo, unidad_productiva | |
| else: | |
| # Resaltar en rojo si la Alerta ICS no está instalada | |
| html_text = '<font color="red"><b>Alarma ICS no instalada</b></font><br>' | |
| print(f"No se pudo obtener la información de la sección '{seccion}' en ninguna de las rutas.") | |
| return html_text, None | |
| def leer_campos_desde_ini(self, ruta_archivo, seccion): | |
| def leer_configuracion(ruta_archivo, seccion): | |
| config = ConfigParser() | |
| config.read(ruta_archivo) | |
| # Verificar si la sección especificada existe en el archivo | |
| if seccion in config: | |
| return dict(config[seccion]) | |
| else: | |
| return None | |
| def procesar_archivo(ruta, seccion): | |
| if os.path.exists(ruta): | |
| return leer_configuracion(ruta, seccion) | |
| else: | |
| return None | |
| # Llamada a la función procesar_archivo con la ruta y sección específicas | |
| datos = procesar_archivo(ruta_archivo, seccion) | |
| if datos is not None: | |
| print(f"Datos encontrados en {ruta_archivo} (sección '{seccion}'): {datos}") | |
| else: | |
| print(f"No se encontraron datos en {ruta_archivo} (sección '{seccion}')") | |
| return datos | |
| #PARTE 2 | |
| def obtener_tamano_disco_duro_en_gb(self, nombre_equipo, unidad): | |
| try: | |
| print("Obteniendo el tamaño del disco duro...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| unidades_fisicas = c.Win32_DiskDrive() | |
| for unidad_fisica in unidades_fisicas: | |
| for particion in unidad_fisica.associators("Win32_DiskDriveToDiskPartition"): | |
| for disco_logico in particion.associators("Win32_LogicalDiskToPartition"): | |
| if disco_logico.DeviceID == unidad: | |
| espacio_total_bytes = int(disco_logico.Size) | |
| espacio_total_gb = espacio_total_bytes / (1024 ** 3) | |
| return espacio_total_gb | |
| except Exception as e: | |
| mensaje_error = f"Error al obtener el tamaño del disco duro en el equipo remoto ({nombre_equipo}): {str(e)}" | |
| return None | |
| def obtener_espacio_disponible_en_gb(self, nombre_equipo, unidad): | |
| try: | |
| print("Obteniendo el espacio de disco duro libre...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| unidades_fisicas = c.Win32_DiskDrive() | |
| for unidad_fisica in unidades_fisicas: | |
| for particion in unidad_fisica.associators("Win32_DiskDriveToDiskPartition"): | |
| for disco_logico in particion.associators("Win32_LogicalDiskToPartition"): | |
| if disco_logico.DeviceID == unidad: | |
| espacio_disponible_bytes = int(disco_logico.FreeSpace) | |
| espacio_disponible_gb = espacio_disponible_bytes / (1024 ** 3) | |
| return espacio_disponible_gb | |
| return f"No se encontró la unidad '{unidad}' en el disco duro remoto." | |
| except Exception as e: | |
| return f"Error al obtener el espacio disponible del disco duro remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_descripcion_equipo(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la etiqueta LT2B de la descripcion del equipo.") | |
| # Variable que contiene la clave de registro | |
| clave_registro = "SYSTEM\\ControlSet001\\Services\\LanmanServer\\Parameters" | |
| clave_lt2b = "srvcomment" | |
| # Declarar el comando con el equipo remoto | |
| comando = f"psexec \\\\{nombre_equipo} powershell -Command (Get-ItemProperty -Path 'HKLM:\\{clave_registro}').{clave_lt2b}" | |
| resultado = subprocess.run(comando, shell=True, check=True, capture_output=True, text=True) | |
| valor_actual = resultado.stdout.strip() | |
| # Puedes retornar el valor o realizar alguna acción con él | |
| return valor_actual | |
| except subprocess.CalledProcessError as e: | |
| print(f"Error al obtener la descripción del equipo: {e}") | |
| print(f"Salida de error: {e.stderr}") | |
| return None | |
| def initUI(self): | |
| self.setWindowTitle("INFORMACIÓ REMOTA D'UN PC") | |
| self.setGeometry(100, 100, 500, 460) | |
| icon_path = "logo.ico" | |
| icon = QIcon(icon_path) | |
| self.setWindowIcon(icon) | |
| main_widget = QWidget(self) | |
| self.setCentralWidget(main_widget) | |
| layout = QVBoxLayout(main_widget) | |
| self.hostname_input = QLineEdit(self) | |
| self.hostname_input.setPlaceholderText("Introdueix el nom de l'equip remot") | |
| layout.addWidget(self.hostname_input) | |
| get_info_button = QPushButton("PREM AQUÍ PER OBTENIR INFORMACIÓ DE L'PC REMOT", self) | |
| get_info_button.clicked.connect(self.get_remote_info) | |
| layout.addWidget(get_info_button) | |
| result_frame = QFrame(self) | |
| result_frame.setFrameShape(QFrame.StyledPanel) | |
| layout.addWidget(result_frame) | |
| result_layout = QVBoxLayout(result_frame) | |
| self.result_text = QTextEdit(self) | |
| result_layout.addWidget(self.result_text) | |
| new_frame = QFrame(self) | |
| new_frame.setFrameShape(QFrame.StyledPanel) | |
| layout.addWidget(new_frame) | |
| open_programs_button = QPushButton("PREM AQUI PER VEURE LLISTAT PROGRAMES INSTALATS", self) | |
| open_programs_button.clicked.connect(self.open_programs_window) | |
| layout.addWidget(open_programs_button) | |
| def open_programs_window(self): | |
| nombre_equipo = self.hostname_input.text() | |
| programas_instalados = self.obtener_programas_instalados(nombre_equipo) | |
| if programas_instalados: | |
| self.programs_window = RemoteInfoExtractor(programas_instalados) | |
| self.programs_window.show() | |
| #PARTE 3 | |
| def get_remote_info(self): | |
| nombre_equipo = self.hostname_input.text() | |
| # Obtener ubicación | |
| lugar_trabajo, unidad_productiva = self.obtener_ubicacion(nombre_equipo) | |
| info = "" | |
| unidad_disco = "GB" | |
| if lugar_trabajo is not None and unidad_productiva is not None: | |
| info += f'UNITAT PRODUCTIVA: <b>{unidad_productiva.upper()}</b><br>' | |
| info += f'LLOC DE TREBALL: <b>{lugar_trabajo}</b><br>' | |
| else: | |
| print("Alarma no instalada.") | |
| info += f'UNITAT PRODUCTIVA: Alarma ICS NO instalada.</b><br>' | |
| info += f'LLOC DE TREBALL: Alarma ICS NO instalada.</b><br>' | |
| # Acceder al valor de clave_lt2b desde el método obtener_descripcion_equipo | |
| descripcion_equipo = self.obtener_descripcion_equipo(nombre_equipo) | |
| if descripcion_equipo is not None: | |
| # Buscar la cadena que comienza con "LT2B" | |
| inicio_lt2b = descripcion_equipo.find('LT2B') | |
| def obtener_fecha_arranque_remoto(nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la fecha de arranque...") | |
| print("Fin de la obtencion de datos del equipo remoto...con exito.") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| os_info = c.Win32_OperatingSystem()[0] | |
| fecha_arranque = os_info.LastBootUpTime | |
| return fecha_arranque | |
| except Exception as e: | |
| return f"Error al obtener la fecha de arranque del equipo remoto ({nombre_equipo}): {str(e)}" | |
| """Aqui el codigo comienza a mostrar los campos del ordenador en la ventana grafica""" | |
| if inicio_lt2b != -1: | |
| texto_lt2b = descripcion_equipo[inicio_lt2b:].strip() | |
| info += 'ETIQUETA LT2BPC: <b style="color: red;">' + texto_lt2b + '</b><br>'; | |
| else: | |
| info += "No se encontró el texto 'LT2B' en la descripción del equipo.<br>" | |
| #Campo que muestra el nombre del equip a la pantalla de la interface | |
| info += f'NOM DEL EQUIP: <b>{nombre_equipo.upper()}</b><br>' | |
| # Campo que muestra la marca de la tarjeta de red al interface | |
| info += f'TARGETA XARXA ACTIVA: <b>{self.obtener_nombre_tarjeta_red(nombre_equipo)}</b><br>' | |
| #Variable que obtiene de la funcion el valor de la velocidad de la tarjeta de red | |
| velocidad_tarjeta_red = self.obtener_velocitat_xarxa(nombre_equipo) | |
| # Campo que muestra la velocidad de la tarjeta de red al interface | |
| info += f'VELOCITAT TARJETA DE XARXA ACTIVA: <b>{velocidad_tarjeta_red}</b><br>' | |
| info += f'IP: <b>{self.obtener_ip_por_nombre_equipo(nombre_equipo)}</b><br>' | |
| info += f'MÁSCARA: <b>{self.obtener_mascara_subred_equipo_remoto(nombre_equipo)}</b><br>' | |
| info += f'PORTA DE ENLLAÇ: <b>{self.obtener_puerta_enlace_remota(nombre_equipo)}</b><br>' | |
| info += f'MAC: <b>{self.obtener_mac_equipo_remoto(nombre_equipo)}</b><br>' | |
| # Variable que obtiene de la funcion el valor de las dns | |
| configuracion_dns = self.obtener_configuracion_dns(nombre_equipo) | |
| info += f'DNS1: <b>{configuracion_dns[0]}</b><br>' | |
| info += f'DNS2: <b>{configuracion_dns[1]}</b><br>' | |
| info += f'DOMINI: <b>{self.obtener_dominio(nombre_equipo).upper()}</b><br>' | |
| info += f'MODEL: <b>{self.obtener_modelo_equipo_remoto(nombre_equipo)}</b><br>' | |
| info += f'TIPUS DE PROCESSADOR: <b>{self.obtener_tipo_procesador(nombre_equipo)}</b><br>' | |
| info += f'MEMÒRIA RAM: <b>{self.obtener_memoria_ram(nombre_equipo):.2f} GB</b><br>' | |
| info += f'NÚMERO DE SÈRIE DE EQUIP: <b>{self.obtener_numero_serie_equipo_remoto(nombre_equipo)}</b><br>' | |
| info += f'SISTEMA OPERATIU: <b>{self.obtener_sistema_operativo_y_arquitectura(nombre_equipo)}</b><br>' | |
| unidad_disco = "C:" | |
| tamano_duro = self.obtener_tamano_disco_duro_en_gb(nombre_equipo, unidad_disco) | |
| info += f'MIDA TOTAL DEL DISC DUR A {unidad_disco} <b> {tamano_duro:.2f} GB</b><br>' | |
| espacio_disponible = self.obtener_espacio_disponible_en_gb(nombre_equipo, unidad_disco) | |
| if espacio_disponible is not None: | |
| espacio_disponible = float(espacio_disponible) | |
| color_estilo = "color: red;" if espacio_disponible < 20 else "" # Si es menor a 10 GB, se colorea en rojo | |
| info += f'ESPAI DISPONIBLE EN {unidad_disco} <b style="{color_estilo}">{espacio_disponible:.2f} GB</b><br>' | |
| else: | |
| info += f'No se pudo obtener el espacio disponible en {unidad_disco}<br>' | |
| fecha_arranque = obtener_fecha_arranque_remoto(nombre_equipo) | |
| if "Error al obtener la fecha de arranque" in str(fecha_arranque): | |
| info += f'Error al obtener la fecha de arranque del equipo remoto ({nombre_equipo}): {fecha_arranque}<br>' | |
| info += f'DATA INICI ENCES: <b>No disponible</b><br>' | |
| info += f'DÍAS SENSE APAGAR: <b>No disponible</b><br>' | |
| else: | |
| fecha_arranque = fecha_arranque.split('+')[0] | |
| fecha_arranque_datetime = datetime.strptime(fecha_arranque, '%Y%m%d%H%M%S.%f') | |
| fecha_formateada = fecha_arranque_datetime.strftime('%d/%m/%Y %H:%M:%S') | |
| fecha_actual = datetime.now() | |
| diferencia = fecha_actual - fecha_arranque_datetime | |
| dias_encendido = diferencia.days | |
| info += f'DATA INICI ENCES: <b>{fecha_formateada}</b><br>' | |
| # Determinar el estilo en función de la condición | |
| color_estilo = "color: red;" if dias_encendido > 7 else "" | |
| info += f'DÍAS SENSE APAGAR: <b style="{color_estilo}">{dias_encendido} días</b><br>' | |
| # Actualizar el área de texto con la información | |
| self.result_text.setHtml(info) | |
| def obtener_ip_por_nombre_equipo(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la ip del ordenador...") | |
| ip = socket.gethostbyname(nombre_equipo) | |
| return ip | |
| except socket.error as e: | |
| print(f"No se pudo obtener la IP del equipo {nombre_equipo}. Error: {str(e)}") | |
| return None | |
| def obtener_configuracion_dns(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de las dns del ordenador...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| network_configs = c.Win32_NetworkAdapterConfiguration(IPEnabled=True) | |
| if network_configs: | |
| for config in network_configs: | |
| dns_primario = config.DNSServerSearchOrder[0] if config.DNSServerSearchOrder else "" | |
| dns_secundario = config.DNSServerSearchOrder[1] if len(config.DNSServerSearchOrder) > 1 else "" | |
| return dns_primario, dns_secundario | |
| return None | |
| except Exception as e: | |
| return None | |
| def obtener_dominio(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion del dominio del ordenador...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| computer_system = c.Win32_ComputerSystem() | |
| if computer_system: | |
| return computer_system[0].Domain | |
| else: | |
| return "No se pudo obtener la información del dominio." | |
| except Exception as e: | |
| return f"Error al obtener la información del dominio del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_nombre_tarjeta_red(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion el adaptador de tarjeta de red del ordenador...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| interfaces_red = c.Win32_NetworkAdapter() | |
| for interfaz in interfaces_red: | |
| if interfaz.NetConnectionStatus == 2: # Verificar si la interfaz está conectada | |
| nombre_tarjeta = interfaz.Name | |
| return nombre_tarjeta | |
| return "No se encontró una tarjeta de red activa." | |
| except Exception as e: | |
| return f"Error al obtener el nombre de la tarjeta de red del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_velocitat_xarxa(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la velocidad del adaptador de tarjeta de red del ordenador...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| interfaces_red = c.Win32_NetworkAdapter() | |
| for interfaz in interfaces_red: | |
| if interfaz.NetConnectionStatus == 2: # Verificar si la interfaz está conectada | |
| velocidad_bps = int(interfaz.Speed) | |
| velocidad_mbps = velocidad_bps / 1_000_000 # Convertir a Mbps | |
| return f"{velocidad_mbps:.2f} Mbps" | |
| return "No se encontró una tarjeta de red activa." | |
| except Exception as e: | |
| return f"Error al obtener la velocidad de la tarjeta de red del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_mascara_subred_equipo_remoto(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la mascara de subred del ordenador...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| network_configs = c.Win32_NetworkAdapterConfiguration(IPEnabled=True) | |
| if network_configs: | |
| for config in network_configs: | |
| mascara_subred = config.IPSubnet | |
| if mascara_subred: | |
| return mascara_subred[0] | |
| return "No se pudo obtener la máscara de subred del equipo remoto." | |
| except Exception as e: | |
| return f"Error al obtener la máscara de subred del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_puerta_enlace_remota(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la puerta de enlace del ordenador...") | |
| wmi_connection = wmi.WMI(nombre_equipo) | |
| adapters = wmi_connection.Win32_NetworkAdapterConfiguration(IPEnabled=True) | |
| for adapter in adapters: | |
| if adapter.DefaultIPGateway: | |
| return adapter.DefaultIPGateway[0] | |
| return "" | |
| except Exception as e: | |
| print("Error al obtener la puerta de enlace remota:", str(e)) | |
| return "" | |
| def obtener_mac_equipo_remoto(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion de la MAC del equipo remoto...") | |
| comando_getmac = f'getmac /s \\\\{nombre_equipo}' | |
| resultado = subprocess.check_output(comando_getmac, shell=True, text=True) | |
| lineas = resultado.strip().split('\n') | |
| if len(lineas) > 2: | |
| direccion_mac = lineas[2].split()[0] | |
| direccion_mac = ":".join(direccion_mac.split('-')) | |
| return direccion_mac | |
| else: | |
| return "No se pudo obtener la dirección MAC del equipo remoto." | |
| except subprocess.CalledProcessError as e: | |
| return f"Error al obtener la dirección MAC del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_numero_serie_equipo_remoto(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion del numero de serie del ordenador remoto...") | |
| comando = f'wmic /node:"{nombre_equipo}" bios get serialnumber' | |
| resultado = subprocess.check_output(comando, shell=True).decode('utf-8') | |
| numero_serie = resultado.strip().split('\n')[1].strip() | |
| return numero_serie | |
| except Exception as e: | |
| return f"Error al obtener el número de serie del equipo remoto ({nombre_equipo}): {str(e)}" | |
| #PARTE 5 | |
| def obtener_modelo_equipo_remoto(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion del modelo del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| # Obtener información sobre el sistema informático | |
| system_info = c.Win32_ComputerSystem()[0] | |
| # Extraer el número de modelo del equipo desde la información obtenida | |
| modelo_equipo = system_info.Model | |
| # Diccionario que asocia números de modelos con textos descriptivos | |
| modelos_dict = { | |
| "ESPRIMO E410": "FUJITSU ESPRIMO E410", | |
| "ESPRIMO E420": "FUJITSU ESPRIMO E420", | |
| "ESPRIMO D556/2": "FUJITSU ESPRIMO D556/2-EQUIPO NO HOMOLOGADO", | |
| "20SM": "Lenovo ThinkBook 15-IIL (20SM) Portátil", | |
| "11DT003TSP": "Lenovo ThinkCentre M70q Desktop (11DT003TSP) Sobretaula", | |
| "11DTS0TU00": "Lenovo ThinkCentre M70q Desktop (11DTS0TU00) Sobretaula", | |
| "11MY0038SP": "Lenovo ThinkCentre M70q Gen 2 Desktop (11MY0038SP) Sobretaula", | |
| "11N0S2H400": "Lenovo ThinkCentre M70q Gen 2 Desktop (11N0S2H400) Sobretaula", | |
| "11JQS4EV00": "Lenovo ThinkCentre M75q Gen 2 Desktop (11JQS4EV00) Sobretaula", | |
| "12A0S02S00": "Lenovo ThinkCentre M80t Gen 3 Desktop (12A0S02S00) Sobretaula", | |
| "11MRS03X00": "Lenovo ThinkCentre M90q Gen2 Desktop (11MRS03X00) Sobretaula", | |
| "10GSS1V200": "Lenovo ThinkCentre M700 Desktop (10GSS1V200) Sobretaula", | |
| "10J0S1FH00": "Lenovo ThinkCentre M700 Tiny (10J0S1FH00) Sobretaula", | |
| "10J0S1G500": "Lenovo ThinkCentre M700 Tiny (10J0S1G500) Sobretaula", | |
| "10J0S3UA00": "Lenovo ThinkCentre M700 Tiny (10J0S3UA00) Sobretaula", | |
| "10UR0030SP": "Lenovo ThinkCentre M710e Desktop (10UR0030SP) Sobretaula", | |
| "10MQSABB00": "Lenovo ThinkCentre M710q Tiny (10MQSABB00) Sobretaula", | |
| "10M7005VSP": "Lenovo ThinkCentre M710s Desktop (10M7005VSP) Sobretaula", | |
| "10T700BTSP": "Lenovo ThinkCentre M720q Tiny (10T700BTSP) Sobretaula", | |
| "10T7S0AV00": "Lenovo ThinkCentre M720q Tiny (10T7S0AV00) Sobretaula", | |
| "10T7S0JJ00": "Lenovo ThinkCentre M720q Tiny (10T7S0JJ00) Sobretaula", | |
| "10T7S1H400": "Lenovo ThinkCentre M720q Tiny (10T7S1H400) Sobretaula", | |
| "10ST0043SP": "Lenovo ThinkCentre M720s Desktop (10ST0043SP) Sobretaula", | |
| "10MUS6JC00": "Lenovo ThinkCentre M910q Tiny (10MUS6JC00) Sobretaula", | |
| "10MVS0C100": "Lenovo ThinkCentre M910q Tiny (10MVS0C100) Sobretaula", | |
| "20RD001FSP": "Lenovo ThinkPad E15 (20RD001FSP) Portàtil", | |
| "20RD0032SP": "Lenovo ThinkPad E15 (20RD0032SP) Portàtil", | |
| "20RDS02M00": "Lenovo ThinkPad E15 (20RDS02M00) Portàtil", | |
| "20RES6DF04": "Lenovo ThinkPad E15 (20RES6DF04) Portàtil", | |
| "20TD001JSP": "Lenovo ThinkPad E15 Gen 2 (20TD001JSP) Portàtil", | |
| "20TD00HASP": "Lenovo ThinkPad E15 Gen 2 (20TD00HASP) Portàtil", | |
| "20YG00A3SP": "Lenovo ThinkPad E15 Gen 3 (20YG00A3SP) Portàtil", | |
| "21EES26U00": "Lenovo ThinkPad E15 Gen 4 (21EES26U00) Portàtil", | |
| "21JUS0Q600": "Lenovo ThinkPad E16 Gen 1 (21JUS0Q600) Portàtil", | |
| "20KS007RSP": "Lenovo ThinkPad E580 (20KS007RSP) Portàtil", | |
| "20NCS0BP00": "Lenovo ThinkPad E590 (20NCS0BP00) Portàtil", | |
| "20M5000USP": "Lenovo ThinkPad L380 (20M5000USP) Portàtil", | |
| "20LW000VSP": "Lenovo ThinkPad L580 (20LW000VSP) Portàtil", | |
| "20T1S13D00": "Lenovo ThinkPad T14s Gen 1 (20T1S13D00) Portàtil", | |
| "20UJS0VD00": "Lenovo ThinkPad T14s Gen 1 AMD (20UJS0VD00) Portàtil", | |
| "20UJS38P00": "Lenovo ThinkPad T14s Gen 1 AMD (20UJS38P00) Portàtil", | |
| "20UJS37000": "Lenovo ThinkPad T14s Gen 1 AMD (20UJS37000) Portàtil", | |
| "20UJS3EP00": "Lenovo ThinkPad T14s Gen 1 AMD (20UJS3EP00) Portàtil", | |
| "21CRS0GD00": "Lenovo ThinkPad T14s Gen 3 AMD (21CRS0GD00) Portàtil", | |
| "21CRS28100": "Lenovo ThinkPad T14s Gen 3 AMD (21CRS28100) Portàtil", | |
| "20SX001GSP": "Lenovo ThinkPad X13 Yoga Gen 1 (20SX001GSP) Portàtil", | |
| "20SYS0PB00": "Lenovo ThinkPad X13 Yoga Gen 1 (20SYS0PB00) Portàtil", | |
| "20W9S11100": "Lenovo ThinkPad X13 Yoga Gen 2 (20W9S11100) Portàtil", | |
| "21AXS2YC00": "Lenovo ThinkPad X13 Yoga Gen 3 (21AXS2YC00) Portàtil", | |
| "20F5S4K400": "Lenovo ThinkPad X260 (20F5S4K400) Portàtil", | |
| "20F5S5HV00": "Lenovo ThinkPad X260 (20F5S5HV00) Portàtil", | |
| "20HMS0XV00": "Lenovo ThinkPad X270 (20HMS0XV00) Portàtil", | |
| "20K5S1UU00": "Lenovo ThinkPad X270 (20K5S1UU00) Portàtil", | |
| "20Q0000SSP": "Lenovo ThinkPad X390 (20Q0000SSP) Portàtil", | |
| "20Q1S0Q800": "Lenovo ThinkPad X390 (20Q1S0Q800) Portàtil", | |
| "20Q1S1WW00": "Lenovo ThinkPad X390 (20Q1S1WW00) Portàtil", | |
| "20NN002ASP": "Lenovo ThinkPad X390 Yoga (20NN002ASP) Portàtil", | |
| "20NNS00R00": "Lenovo ThinkPad X390 Yoga (20NNS00R00) Portàtil", | |
| "20NNS01S00": "Lenovo ThinkPad X390 Yoga (20NNS01S00) Portàtil", | |
| "20NQS0QQ00": "Lenovo ThinkPad X390 Yoga (20NQS0QQ00) Portàtil", | |
| "20NQS2JX00": "Lenovo ThinkPad X390 Yoga (20NQS2JX00) Portàtil", | |
| "20NMS13700": "Lenovo ThinkPad X395 (20NMS13700) Portàtil", | |
| "20NMS2UJ00": "Lenovo ThinkPad X395 (20NMS2UJ00) Portàtil", | |
| "20FES24T00": "Lenovo ThinkPad Yoga 260 (20FES24T00) Portàtil", | |
| "20FES3MJ00": "Lenovo ThinkPad Yoga 260 (20FES3MJ00) Portàtil", | |
| "20FES4T700": "Lenovo ThinkPad Yoga 260 (20FES4T700) Portàtil", | |
| "21F9S0RQ00": "Lenovo ThinkPad T14s Gen 4 (21F9S0RQ00) Portàtil", | |
| "81V5": "Lenovo V155-15API (81V5) Portàtil", | |
| "30DJSDP100": "Lenovo ThinkStation P340 (30DJSDP100) WorkStation", | |
| "30FM0098SP": "Lenovo ThinkStation P360 Tower (30FM0098SP) WorkStation", | |
| "30FNSBFA00": "Lenovo ThinkStation P360 Tower (30FNSBFA00) WorkStation", | |
| "30A7S0F000": "Lenovo ThinkStation P500 (30A7S0F000) WorkStation", | |
| "30B50008SP": "Lenovo ThinkStation P510 (30B50008SP) WorkStation", | |
| "30B5S0DG00": "Lenovo ThinkStation P510 (30B5S0DG00) WorkStation", | |
| "30B5S17E00": "Lenovo ThinkStation P510 (30B5S17E00) WorkStation", | |
| "30B5S1AL00": "Lenovo ThinkStation P510 (30B5S1AL00) WorkStation", | |
| "30BES0V100": "Lenovo ThinkStation P520 (30BES0V100) WorkStation", | |
| "30BES0V200": "Lenovo ThinkStation P520 (30BES0V200) WorkStation", | |
| "30BES1XA00": "Lenovo ThinkStation P520 (30BES1XA00) WorkStation", | |
| "30BX000WSP": "Lenovo ThinkStation P520c (30BX000WSP) WorkStation", | |
| "30BX0076SP": "Lenovo ThinkStation P520c (30BX0076SP) WorkStation", | |
| "30BX00BJSP": "Lenovo ThinkStation P520c (30BX00BJSP) WorkStation", | |
| "30BX00E3SP": "Lenovo ThinkStation P520c (30BX00E3SP) WorkStation", | |
| "CLINIO 322C": "ReinMedical CLINIO 322C All-in-One", | |
| "CLINIO 422C": "ReinMedical CLINIO 422C All-in-One", | |
| "CLINIO 522C": "ReinMedical CLINIO 522C All-in-One", | |
| "CLINIO 522C Touch": "ReinMedical CLINIO 522C Touch All-in-One", | |
| "CLINIO 622C": "ReinMedical CLINIO 622C All-in-One", | |
| "CLINIO 622C Touch": "ReinMedical CLINIO 622C Touch All-in-One", | |
| "CLINIO 624C": "ReinMedical CLINIO 624C All-in-One" | |
| } | |
| # Obtener el texto descriptivo del modelo a partir del diccionario | |
| modelo_descriptivo = modelos_dict.get(modelo_equipo, f"Modelo no reconocido: {modelo_equipo}") | |
| # Resaltar en rojo si el modelo contiene "EXPRIMO" | |
| if "ESPRIMO" in modelo_equipo: | |
| modelo_descriptivo = f'<span style="color: red;">{modelo_descriptivo}</span>' | |
| return modelo_descriptivo | |
| except Exception as e: | |
| mensaje_error = f"Error al obtener el modelo del equipo remoto ({nombre_equipo}): {str(e)}" | |
| return mensaje_error | |
| # PARTE 6 | |
| def obtener_sistema_operativo_y_arquitectura(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtención del Sistema operativo y bits del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| os_info = c.Win32_OperatingSystem()[0] | |
| sistema_operativo = os_info.Caption | |
| arquitectura_bits = os_info.OSArchitecture | |
| # Determinar el estilo en función de la condición | |
| color_estilo = "color: red;" if sistema_operativo == "Microsoft Windows 7" else "" | |
| # Utilizar el estilo en la cadena formateada | |
| return f'<b style="{color_estilo}">{sistema_operativo} {arquitectura_bits}</b>' | |
| except Exception as e: | |
| return f"Error al obtener información del sistema operativo del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_espacio_disponible_en_gb(self, nombre_equipo, unidad): | |
| try: | |
| print("Procesando la obtencion del espacio del disco duro disponible del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| unidades_fisicas = c.Win32_DiskDrive() | |
| for unidad_fisica in unidades_fisicas: | |
| for particion in unidad_fisica.associators("Win32_DiskDriveToDiskPartition"): | |
| for disco_logico in particion.associators("Win32_LogicalDiskToPartition"): | |
| if disco_logico.DeviceID == unidad: | |
| espacio_disponible_bytes = int(disco_logico.FreeSpace) | |
| espacio_disponible_gb = espacio_disponible_bytes / (1024 ** 3) | |
| return espacio_disponible_gb | |
| return "No se pudo obtener el espacio disponible del disco duro remoto." | |
| except Exception as e: | |
| return f"Error al obtener el espacio disponible del disco duro remoto ({nombre_equipo}) {str(e)}" | |
| def obtener_tamano_disco_duro_en_gb(self, nombre_equipo, unidad): | |
| try: | |
| print("Procesando la obtencion del tamaño del disco duro del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| unidades_fisicas = c.Win32_DiskDrive() | |
| for unidad_fisica in unidades_fisicas: | |
| for particion in unidad_fisica.associators("Win32_DiskDriveToDiskPartition"): | |
| for disco_logico in particion.associators("Win32_LogicalDiskToPartition"): | |
| if disco_logico.DeviceID == unidad: | |
| tamano_bytes = int(disco_logico.Size) | |
| tamano_gb = tamano_bytes / (1024 ** 3) | |
| return tamano_gb | |
| return "No se pudo obtener el tamaño del disco duro remoto." | |
| except Exception as e: | |
| return f"Error al obtener el tamaño del disco duro remoto ({nombre_equipo}) {str(e)}" | |
| def obtener_tipo_procesador(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion del tipo de procesador del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| processor_info = c.Win32_Processor()[0] | |
| tipo_procesador = processor_info.Name | |
| return tipo_procesador | |
| except Exception as e: | |
| return f"Error al obtener el tipo de procesador del equipo remoto ({nombre_equipo}): {str(e)}" | |
| def obtener_memoria_ram(self, nombre_equipo): | |
| try: | |
| print("Procesando la obtencion del total de memoria ram del ordenador remoto...") | |
| c = wmi.WMI(computer=nombre_equipo) | |
| total_memoria = sum(int(mem.Capacity) for mem in c.Win32_PhysicalMemory()) | |
| # Convertir bytes a gigabytes y devolver un valor numérico | |
| total_memoria_gb = total_memoria / (1024 ** 3) | |
| return total_memoria_gb | |
| except Exception as LT2B027863e: | |
| return 0.0 # En | |
| def main(): | |
| app_1 = QApplication(sys.argv) | |
| ventana = RemoteInfoApp() | |
| ventana.show() | |
| sys.exit(app_1.exec_()) | |
| if __name__ == "__main__": | |
| app = QApplication(sys.argv) | |
| window = RemoteInfoApp() | |
| window.show() | |
| sys.exit(app.exec_()) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment