Skip to content

Instantly share code, notes, and snippets.

@hcosta

hcosta/programa.py

Created February 20, 2024 15:55
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save hcosta/cf7a6ff89b175e51c5093158ccfc65d1 to your computer and use it in GitHub Desktop.
Save hcosta/cf7a6ff89b175e51c5093158ccfc65d1 to your computer and use it in GitHub Desktop.
Download ZIP
programa.py
Raw
programa.py
# 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