Active StarUml version 6 for Window | MacOS | Linux

Active StarUml version 6 for Window | MacOS | Linux.md

Active StarUML on Window/MacOS/Linux

• Step 1: Download and install StarUML Version 6 from main website https://staruml.io
• Step 2: Download app.asar file from https://drive.google.com/file/d/1_sKvHVL6SebnYF73iZxSWD9l48Pddzvj/view?usp=sharing
• Step 3: Copy app.asar file download in step 2 (Override app.asar file)
  • Window: C:\Program Files\StarUML\resources
  • MacOS: /Applications/StarUML.app/Contents/Resources/
  • Linux: /opt/StartUML/resources
• Step 4: Open StarUML app to use

Do not forget to give me⭐

Support version: v6.3.1

Update

• [2025-01-30]:
  • Update app.asar to v6.3.1
  • Block auto update new version
• [2024-12-11]: Supports Linux from comment
• [2024-11-19]: Supports MacOS from comment
• [2024-11-12]:
  • Block auto update (Beta)
  • Update app.asar file for V6.3.0

Have done!

Support:

Funciona en la versión 7, ahora el archivo que se modifica está alojado en: app.asar\src\engine\license-store.js

const { ipcRenderer } = require("electron");
const { EventEmitter } = require("events");
const LicenseActivationDialog = require("../dialogs/license-activation-dialog");

class LicenseStore extends EventEmitter {
constructor() {
super();
this.licenseStatus = {
activated: false,
name: null,
product: null,
edition: null,
productDisplayName: null,
deviceId: null,
licenseKey: null,
activationCode: null,
trial: false,
trialDaysLeft: 0,
};

// Configuración de validación local
this.localValidation = true; // Flag para activar validación local por defecto

// Inicializar con validación local si está habilitada
if (this.localValidation) {
  this.initializeLocalLicense();
}

}

// Inicializar con datos de licencia local
initializeLocalLicense() {
const localResult = this.validateLocal();
this.licenseStatus = {
...this.licenseStatus,
activated: true,
name: localResult.name,
product: localResult.product,
edition: "Professional",
productDisplayName: localResult.product,
deviceId: "local-device-id",
licenseKey: localResult.licenseKey,
trial: false,
trialDaysLeft: 0,
};
}

// Método de validación local (adaptado del código original que querías integrar)
validateLocal(PK = null, name = null, product = null, licenseKey = null) {
// Simulación de la validación con NodeRSA (puedes descomentar si tienes node-rsa instalado)
// const NodeRSA = require('node-rsa');

return {
  success: true,
  name: "FullActivated",
  product: "StarUML",
  licenseType: "vip",
  quantity: "unlimited",
  licenseKey: licenseKey || "no, thanks!",
  activated: true,
  trial: false,
  trialDaysLeft: 0
};

}

// Método para registrar el dominio (si necesitas compatibilidad con domain manager)
initDomainManager(domainManager) {
if (!domainManager) return;

if (!domainManager.hasDomain("LicenseManager")) {
  domainManager.registerDomain("LicenseManager", {major: 0, minor: 1});
}

domainManager.registerCommand(
  "LicenseManager", // domain name
  "validate",       // command name
  this.validateLocal.bind(this), // command handler function
  false,            // this command is synchronous in Node
  "Validate License",
  [
    {
      name: "PK",
      type: "string", 
      description: "PK"
    },
    {
      name: "name",
      type: "string",
      description: "name of license owner"
    },
    {
      name: "product", 
      type: "string",
      description: "product name"
    },
    {
      name: "licenseKey",
      type: "string",
      description: "license key"
    }
  ],
  [
    {
      name: "result",
      type: "object", 
      description: "result"
    }
  ]
);

}

async fetch() {
if (this.localValidation) {
// Usar validación local en lugar de IPC
const localResult = this.validateLocal();
this.licenseStatus = {
...this.licenseStatus,
activated: true,
name: localResult.name,
product: localResult.product,
licenseKey: localResult.licenseKey,
trial: false,
trialDaysLeft: 0
};
} else {
// Lógica original con IPC
const licenseStatus = await ipcRenderer.invoke(
"license.get-license-status",
);
this.licenseStatus = licenseStatus;
}
this.emit("statusChanged", this.licenseStatus);
}

async getDeviceId() {
if (this.localValidation) {
return "local-device-id-" + Date.now(); // ID único para validación local
}

try {
  const deviceId = await ipcRenderer.invoke("license.get-device-id");
  return deviceId;
} catch (err) {
  console.error(err);
  return null;
}

}

async activate(licenseKey) {
if (this.localValidation) {
// Activación local siempre exitosa
const result = this.validateLocal(null, null, null, licenseKey);
this.licenseStatus = {
...this.licenseStatus,
activated: true,
licenseKey: licenseKey,
name: result.name,
product: result.product,
trial: false,
trialDaysLeft: 0
};
this.emit("statusChanged", this.licenseStatus);
console.log("License activated locally with key:", licenseKey);
return { success: true, message: "License activated successfully" };
}

// Lógica original con IPC
try {
  const result = await ipcRenderer.invoke("license.activate", licenseKey);
  if (!result.success) {
    this.emit("error", result.message || "Activation failed");
  }
} catch (err) {
  console.error(err);
  this.emit("error", "Activation failed");
}
await this.fetch();

}

async deactivate() {
if (this.localValidation) {
// Para validación local, mantener siempre activado
console.log("Deactivation ignored in local validation mode");
this.licenseStatus.activated = true;
this.emit("statusChanged", this.licenseStatus);
return { success: true, message: "License remains active in local mode" };
}

// Lógica original con IPC
try {
  const result = await ipcRenderer.invoke("license.deactivate");
  if (!result.success) {
    this.emit("error", result.message || "Deactivation failed");
  }
} catch (err) {
  console.error(err);
  this.emit("error", "Deactivation failed");
}
await this.fetch();

}

async validate() {
if (this.localValidation) {
// Usar validación local
const result = this.validateLocal();
// Actualizar status con los datos de validación local
this.licenseStatus = {
...this.licenseStatus,
activated: result.activated,
name: result.name,
product: result.product,
licenseKey: result.licenseKey,
trial: result.trial,
trialDaysLeft: result.trialDaysLeft
};
this.emit("statusChanged", this.licenseStatus);
return result;
}

// Lógica original con IPC
const result = await ipcRenderer.invoke("license.validate");
const licenseStatus = await ipcRenderer.invoke(
  "license.get-license-status",
);
this.licenseStatus = licenseStatus;
this.emit("statusChanged", this.licenseStatus);
return result;

}

getLicenseStatus() {
return this.licenseStatus;
}

async checkTrialMode() {
if (this.localValidation) {
// En modo local, nunca mostrar diálogo de activación ya que siempre está activado
console.log("Trial mode check skipped - local validation active");
return;
}

// Lógica original
const licenseStatus = await ipcRenderer.invoke(
  "license.get-license-status",
);
if (licenseStatus.trial) {
  LicenseActivationDialog.showDialog();
}

}

async htmlReady() {
try {
const result = await this.validate();

  if (this.localValidation) {
    // En modo local, siempre activado con datos del validador local
    this.licenseStatus.activated = true;
    this.licenseStatus.name = result.name;
    this.licenseStatus.product = result.product;
    this.licenseStatus.licenseKey = result.licenseKey;
    this.licenseStatus.trial = false;
    this.licenseStatus.trialDaysLeft = 0;
    console.log("License initialized with local validation");
  } else {
    // Lógica original que siempre pone true
    this.licenseStatus.activated = true;
  }
  
  this.emit("statusChanged", this.licenseStatus);
  await this.checkTrialMode();
} catch (err) {
  console.error(err);
  console.log("License validation failed");
  
  // Mantener la lógica original que fuerza true incluso en error
  this.licenseStatus.activated = true;
  
  if (this.localValidation) {
    // En caso de error en modo local, usar valores por defecto
    const defaultResult = this.validateLocal();
    this.licenseStatus.name = defaultResult.name;
    this.licenseStatus.product = defaultResult.product;
    this.licenseStatus.licenseKey = defaultResult.licenseKey;
    console.log("Using default local license due to validation error");
  }
  
  this.emit("statusChanged", this.licenseStatus);
}

}

// Método adicional para equivaler exactamente al código viejo
async checkLicenseValidity() {
try {
const result = await this.validate();

  // Equivalente a setStatus(this, true) - siempre true como en código original
  this.licenseStatus.activated = true;
  
  if (this.localValidation && result) {
    this.licenseStatus.name = result.name;
    this.licenseStatus.product = result.product;
    this.licenseStatus.licenseKey = result.licenseKey;
    this.licenseStatus.trial = result.trial;
    this.licenseStatus.trialDaysLeft = result.trialDaysLeft;
  }
  
  this.emit("statusChanged", this.licenseStatus);
} catch (err) {
  console.error("License validation error:", err);
  
  // Equivalente al catch que fuerza setStatus(this, true)
  this.licenseStatus.activated = true;
  
  if (this.localValidation) {
    // En modo local, usar valores por defecto incluso en error
    const defaultResult = this.validateLocal();
    this.licenseStatus.name = defaultResult.name;
    this.licenseStatus.product = defaultResult.product;
    this.licenseStatus.licenseKey = defaultResult.licenseKey;
  }
  
  this.emit("statusChanged", this.licenseStatus);
}

}

// Método para cambiar entre validación local e IPC
setLocalValidation(enabled) {
const wasEnabled = this.localValidation;
this.localValidation = enabled;

if (enabled && !wasEnabled) {
  // Cambió de IPC a local - inicializar con datos locales
  this.initializeLocalLicense();
  this.emit("statusChanged", this.licenseStatus);
  console.log("Switched to local validation mode");
} else if (!enabled && wasEnabled) {
  // Cambió de local a IPC - limpiar datos y usar IPC
  console.log("Switched to IPC validation mode");
  this.fetch(); // Recargar desde IPC
}

}

// Método para obtener información sobre el modo actual
getValidationMode() {
return {
localValidation: this.localValidation,
mode: this.localValidation ? "local" : "ipc"
};
}

// Método para forzar recarga del estado de licencia
async refresh() {
await this.fetch();
}

// Método de utilidad para debug
debugInfo() {
console.log("LicenseStore Debug Info:");
console.log("- Validation Mode:", this.localValidation ? "Local" : "IPC");
console.log("- License Status:", this.licenseStatus);
console.log("- Activated:", this.licenseStatus.activated);
console.log("- Product:", this.licenseStatus.product);
console.log("- Name:", this.licenseStatus.name);
}
}

module.exports = LicenseStore;