#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "qaesencryption.h"

#include <QClipboard>
#include <QDateTime>
#include <QDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QProcess>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    setFixedSize(680, 600);
}

MainWindow::~MainWindow()
{
    delete ui;
}

QString MainWindow::toUpperAndLower(QString src)
{
    for(int i = 0; i < src.count(); i++) {
        QChar curC = src.at(i);
        if(curC.isUpper()) {
            curC = curC.toLower();
        } else if(curC.isLower()){
            curC = curC.toUpper();
        }
        src[i] = curC;
    }
    return src;
}

QString MainWindow::EncodebyBase64(const QString &src)//中文字符转byte64
{
    QByteArray text = src.toLocal8Bit();
    QByteArray by = text.toBase64();
    QString str = QString(by);
    str = toUpperAndLower(str);
    return str;
}

QString MainWindow::DecodebyBase64(const QString &src)
{
    QString str = toUpperAndLower(src); // 大小写解密
    QByteArray text = str.toLocal8Bit();
    QByteArray by = text.fromBase64(text);
    return QString::fromLocal8Bit(by);
}

QString MainWindow::EncryptData(const QString &src, QCryptographicHash::Algorithm algo)
{
    //1.创建加密对象
     QCryptographicHash hash(algo);
     //2.放入要加入的数据
     hash.addData(src.toUtf8());
     //3.获取加密的结果
     QByteArray  arr = hash.result();
     QString result = arr.toHex();
     return result;
}

QString MainWindow::AES_encryption(const QString &data, const QString &key)// AES加密
{
    //AES_128要求key长度16，AES_192要求key长度24，AES_256要求key长度32
    QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB, QAESEncryption::PKCS7);
    QByteArray enBA = encryption.encode(data.toUtf8(), key.toUtf8());
    return QString::fromLatin1(enBA.toBase64());
}

QString MainWindow::AES_decryption(const QString &data, const QString &key)// AES解密
{
    QAESEncryption encryption(QAESEncryption::AES_256, QAESEncryption::ECB, QAESEncryption::PKCS7);
    QByteArray  enBA = QByteArray::fromBase64(data.toUtf8());
    QByteArray deBA = encryption.decode(enBA, key.toUtf8());
    return QString::fromLatin1(QAESEncryption::RemovePadding(deBA, QAESEncryption::PKCS7));
}

QString MainWindow::getEncrypt(const QString &data, QString key)
{
    QString str_encode_text;
    QString b64code = EncodebyBase64(data);
    QString hashkey64 = EncryptData(key,QCryptographicHash::Sha256);
    QString hashkey32 = EncryptData(hashkey64,QCryptographicHash::Md5);
    QString AEScode = AES_encryption(b64code,hashkey32);
    str_encode_text = EncodebyBase64(AEScode);
    return str_encode_text;
}

QString MainWindow::getDecrypt(const QString &data, QString key)
{
    QString decodedText;
    QString b64result = DecodebyBase64(data);
    QString hashkey64 = EncryptData(key,QCryptographicHash::Sha256);
    QString hashkey32 = EncryptData(hashkey64,QCryptographicHash::Md5);
    QString AESresult = AES_decryption(b64result,hashkey32);
    decodedText = DecodebyBase64(AESresult);
    return decodedText;
}

void MainWindow::changeUIstate()
{
    if(localinfo.Username==""){
        ui->pushButton_accreditall->setEnabled(false);
        ui->pushButton_accreditcell->setEnabled(false);
        ui->pushButton_accreditaquifer->setEnabled(false);
        ui->pushButton_accreditpipe->setEnabled(false);
        ui->pushButton_accreditnetwork->setEnabled(false);
        ui->pushButton_deaccreditall->setEnabled(false);
        ui->pushButton_dateset->setEnabled(false);
        ui->pushButton_adddate->setEnabled(false);
        ui->pushButton_reducedate->setEnabled(false);
        ui->pushButton_setversion->setEnabled(false);
        ui->pushButton_setproid->setEnabled(false);
        ui->lineEdit_setversion->setEnabled(false);
        ui->lineEdit_setproid->setEnabled(false);

        ui->lineEdit_basenum->setText("");
        ui->lineEdit_baseuuid->setText("");
        ui->lineEdit_biosnum->setText("");
        ui->lineEdit_cpunum->setText("");
        ui->lineEdit_username->setText("");
        ui->lineEdit_date->setText("");
        ui->label_iscell->setText("");
        ui->label_isaquifer->setText("");
        ui->label_ispipe->setText("");
        ui->label_isnetwork->setText("");
        ui->lineEdit_version->setText("");
        ui->lineEdit_setversion->setText("");
        ui->lineEdit_proid->setText("");
        ui->lineEdit_setproid->setText("");
    }else{
        ui->pushButton_accreditall->setEnabled(true);
        ui->pushButton_accreditcell->setEnabled(true);
        ui->pushButton_accreditaquifer->setEnabled(true);
        ui->pushButton_accreditpipe->setEnabled(true);
        ui->pushButton_accreditnetwork->setEnabled(true);
        ui->pushButton_deaccreditall->setEnabled(true);
        ui->pushButton_dateset->setEnabled(true);
        ui->pushButton_adddate->setEnabled(true);
        ui->pushButton_reducedate->setEnabled(true);
        ui->pushButton_setversion->setEnabled(true);
        ui->pushButton_setproid->setEnabled(true);
        ui->lineEdit_setversion->setEnabled(true);
        ui->lineEdit_setproid->setEnabled(true);

        ui->lineEdit_basenum->setText(localinfo.Baseboard_Serialnumber);
        ui->lineEdit_baseuuid->setText(localinfo.Baseboard_Uuid);
        ui->lineEdit_biosnum->setText(localinfo.Bios_Serialnumber);
        ui->lineEdit_cpunum->setText(localinfo.CPU_Processorid);
        ui->lineEdit_username->setText(localinfo.Username);
        ui->lineEdit_date->setText(localinfo.LicensedDuration_end);
        ui->lineEdit_version->setText(localinfo.Versionid);
        ui->lineEdit_proid->setText(localinfo.Productid);
        ui->label_iscell->setText(localinfo.IsEnabled_cell==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_isaquifer->setText(localinfo.IsEnabled_aquifer==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_ispipe->setText(localinfo.IsEnabled_pipe==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_isnetwork->setText(localinfo.IsEnabled_network==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
    }
    if(licenseinfo.Username==""){
        ui->lineEdit_basenum_2->setText("");
        ui->lineEdit_baseuuid_2->setText("");
        ui->lineEdit_biosnum_2->setText("");
        ui->lineEdit_cpunum_2->setText("");
        ui->lineEdit_username_2->setText("");
        ui->lineEdit_date_2->setText("");
        ui->label_iscell_2->setText("");
        ui->label_isaquifer_2->setText("");
        ui->label_ispipe_2->setText("");
        ui->label_isnetwork_2->setText("");
        ui->lineEdit_version_2->setText("");
        ui->lineEdit_proid_2->setText("");
    }else{
        ui->lineEdit_basenum_2->setText(licenseinfo.Baseboard_Serialnumber);
        ui->lineEdit_baseuuid_2->setText(licenseinfo.Baseboard_Uuid);
        ui->lineEdit_biosnum_2->setText(licenseinfo.Bios_Serialnumber);
        ui->lineEdit_cpunum_2->setText(licenseinfo.CPU_Processorid);
        ui->lineEdit_username_2->setText(licenseinfo.Username);
        ui->lineEdit_date_2->setText(licenseinfo.LicensedDuration_end);
        ui->lineEdit_version_2->setText(licenseinfo.Versionid);
        ui->lineEdit_setversion->setText(licenseinfo.Versionid);
        ui->lineEdit_proid_2->setText(licenseinfo.Productid);
        ui->lineEdit_setproid->setText(licenseinfo.Productid);
        ui->label_iscell_2->setText(licenseinfo.IsEnabled_cell==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_isaquifer_2->setText(licenseinfo.IsEnabled_aquifer==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_ispipe_2->setText(licenseinfo.IsEnabled_pipe==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
        ui->label_isnetwork_2->setText(licenseinfo.IsEnabled_network==0?QStringLiteral("未激活"):QStringLiteral("已激活"));
    }
}

void MainWindow::on_pushButton_decrypt_clicked()
{
    QString encryptlocalid = ui->textEdit_localid->toPlainText();
    QString localid = getDecrypt(encryptlocalid,key);
    QByteArray localidbyte = localid.toLocal8Bit();
    QJsonParseError err_rpt;
    QJsonDocument localidjsondoc(QJsonDocument::fromJson(localidbyte, &err_rpt));//字符串格式化为JSON
    if(err_rpt.error != QJsonParseError::NoError)
    {
        localinfo = LicenseInfo();
        licenseinfo = LicenseInfo();
        workingjsondoc = QJsonDocument();
        ui->textEdit_licensekey->setPlainText("");
        changeUIstate();
        qDebug() << QStringLiteral("localid JSON格式错误");
        QMessageBox msgbox(QMessageBox::Information,QStringLiteral(""),QStringLiteral("解析失败，不是一个正确的设备ID序列"),QMessageBox::Ok);
        msgbox.setButtonText(QMessageBox::Ok,QStringLiteral("确定"));
        msgbox.exec();
    }
    else    //JSON格式正确
    {
        QMessageBox msgbox(QMessageBox::Information,QStringLiteral(""),QStringLiteral("解析成功"),QMessageBox::Ok);
        msgbox.setButtonText(QMessageBox::Ok,QStringLiteral("确定"));
        msgbox.exec();
        ui->textEdit_licensekey->setPlainText(ui->textEdit_localid->toPlainText());
        workingjsondoc = QJsonDocument(QJsonDocument::fromJson(localidbyte));

        QJsonObject localid_Obj = localidjsondoc.object();
        localinfo.Baseboard_Serialnumber = localid_Obj.value("Baseboard_Serialnumber").toString();
        localinfo.Baseboard_Uuid = localid_Obj.value("Baseboard_Uuid").toString();
        localinfo.Bios_Serialnumber = localid_Obj.value("Bios_Serialnumber").toString();
        localinfo.CPU_Processorid = localid_Obj.value("CPU_Processorid").toString();
        localinfo.Username = localid_Obj.value("Username").toString();
        localinfo.IsEnabled_cell = localid_Obj.value("IsEnabled_cell").toInt();
        localinfo.IsEnabled_aquifer = localid_Obj.value("IsEnabled_aquifer").toInt();
        localinfo.IsEnabled_pipe = localid_Obj.value("IsEnabled_pipe").toInt();
        localinfo.IsEnabled_network = localid_Obj.value("IsEnabled_network").toInt();
        localinfo.LicensedDuration_end = localid_Obj.value("LicensedDuration_end").toString();
        localinfo.LicensedDuration_start = localid_Obj.value("LicensedDuration_start").toString();
        localinfo.Productid = localid_Obj.value("Productid").toString();
        localinfo.Versionid = localid_Obj.value("Versionid").toString();

        licenseinfo = LicenseInfo(localinfo);
        changeUIstate();
    }
}

void MainWindow::on_pushButton_accreditall_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_cell"] = 1;
    licensekey_Obj["IsEnabled_aquifer"] = 1;
    licensekey_Obj["IsEnabled_pipe"] = 1;
    licensekey_Obj["IsEnabled_network"] = 1;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_accreditcell_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_cell"] = 1;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_accreditaquifer_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_aquifer"] = 1;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_accreditpipe_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_pipe"] = 1;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_accreditnetwork_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_network"] = 1;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_deaccreditall_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["IsEnabled_cell"] = 0;
    licensekey_Obj["IsEnabled_aquifer"] = 0;
    licensekey_Obj["IsEnabled_pipe"] = 0;
    licensekey_Obj["IsEnabled_network"] = 0;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_copykey_clicked()
{
    QClipboard* clip = QApplication::clipboard();
    clip->setText(ui->textEdit_licensekey->toPlainText());
    QMessageBox msgbox(QMessageBox::Information,tr(""),QStringLiteral("复制成功"),QMessageBox::Ok);
    msgbox.setButtonText(QMessageBox::Ok,QStringLiteral("确定"));
    msgbox.exec();
}

void MainWindow::on_pushButton_clicked()
{
    if(ui->dockWidget->isHidden()){
        ui->dockWidget->show();
        setFixedSize(680, 600);
    }else{
        ui->dockWidget->hide();
        setFixedSize(340, 600);
    }
}

void MainWindow::setLicenseinfo(const QJsonObject licensekey_Obj)
{
    licenseinfo.Baseboard_Serialnumber = licensekey_Obj.value("Baseboard_Serialnumber").toString();
    licenseinfo.Baseboard_Uuid = licensekey_Obj.value("Baseboard_Uuid").toString();
    licenseinfo.Bios_Serialnumber = licensekey_Obj.value("Bios_Serialnumber").toString();
    licenseinfo.CPU_Processorid = licensekey_Obj.value("CPU_Processorid").toString();
    licenseinfo.Username = licensekey_Obj.value("Username").toString();
    licenseinfo.IsEnabled_cell = licensekey_Obj.value("IsEnabled_cell").toInt();
    licenseinfo.IsEnabled_aquifer = licensekey_Obj.value("IsEnabled_aquifer").toInt();
    licenseinfo.IsEnabled_pipe = licensekey_Obj.value("IsEnabled_pipe").toInt();
    licenseinfo.IsEnabled_network = licensekey_Obj.value("IsEnabled_network").toInt();
    licenseinfo.LicensedDuration_end = licensekey_Obj.value("LicensedDuration_end").toString();
    licenseinfo.LicensedDuration_start = licensekey_Obj.value("LicensedDuration_start").toString();
    licenseinfo.Productid = licensekey_Obj.value("Productid").toString();
    licenseinfo.Versionid = licensekey_Obj.value("Versionid").toString();
    changeUIstate();
}

QString MainWindow::getLocalID()
{
    QString localid = "";
    LicenseInfo localinfo;
    //查询系统用户名
    localinfo.Username = qgetenv("USER"); // Linux系统
    if (localinfo.Username.isEmpty())
        localinfo.Username = qgetenv("USERNAME"); // Windows系统
    //查询CPU序列号
    localinfo.CPU_Processorid = getWindowsInfo("wmic cpu get processorid");
    //查询主板序列号
    localinfo.Baseboard_Serialnumber = getWindowsInfo("wmic baseboard get serialnumber");
    //查询BIOS序列号
    localinfo.Bios_Serialnumber = getWindowsInfo("wmic bios get serialnumber");
    //查询主板唯一标识
    localinfo.Baseboard_Uuid = getWindowsInfo("wmic csproduct get uuid");

    QJsonDocument json_doc;//创建json文件
    QJsonObject json_obj;//创建json对象
    json_obj.insert("Username",localinfo.Username);
    json_obj.insert("CPU_Processorid",localinfo.CPU_Processorid);
    json_obj.insert("Bios_Serialnumber",localinfo.Bios_Serialnumber);
    json_obj.insert("Baseboard_Serialnumber",localinfo.Baseboard_Serialnumber);
    json_obj.insert("Baseboard_Uuid",localinfo.Baseboard_Uuid);
    json_obj.insert("IsEnabled_cell",localinfo.IsEnabled_cell);
    json_obj.insert("IsEnabled_aquifer",localinfo.IsEnabled_aquifer);
    json_obj.insert("IsEnabled_pipe",localinfo.IsEnabled_pipe);
    json_obj.insert("IsEnabled_network",localinfo.IsEnabled_network);
    json_obj.insert("LicensedDuration_start",localinfo.LicensedDuration_start);
    json_obj.insert("LicensedDuration_end",localinfo.LicensedDuration_end);
    json_obj.insert("Productid",localinfo.Productid);
    json_obj.insert("Versionid",localinfo.Versionid);
    json_doc.setObject(json_obj);//将json对象转为json文件
    QByteArray jsonbytearray = json_doc.toJson();
    localid = QString(jsonbytearray);
    return localid;
}

QString MainWindow::getWindowsInfo(const QString &cmd)
{
    QProcess p;				//启动外部程序
    p.start(cmd);			//一体式启动，不分离，主程序退出则启动程序退出,使用close关闭
    //p.startDetached(cmd)	//分离式启动，主程序退出后，外部程序继续运行。
    p.waitForFinished(-1);	//超时等待，设置为-1，直到执行完成。
    QString result = QString::fromLocal8Bit(p.readAllStandardOutput());
    QStringList list = cmd.split(" ");
    result = result.remove(list.last(), Qt::CaseInsensitive);
    result = result.replace("\r", "");
    result = result.replace("\n", "");
    result = result.simplified();
    p.close();
    return result;
}


void MainWindow::on_pushButton_getId_clicked()
{
    QString localid = getLocalID();
    QString encryptid = getEncrypt(localid,key);
    ui->textEdit_localid->setText(encryptid);

    localinfo = LicenseInfo();
    licenseinfo = LicenseInfo();
    workingjsondoc = QJsonDocument();
    ui->textEdit_licensekey->setPlainText("");
    changeUIstate();
}

void MainWindow::on_pushButton_import_clicked()
{
    QString filename = QFileDialog::getOpenFileName(this,QStringLiteral("导入密钥"),"","TXT(*.txt)");
    if ( filename.isEmpty() )
        return;

    QFile file(filename);

    if(!file.exists()){
        QMessageBox msgBox(QMessageBox::Information, QStringLiteral("警告"), QStringLiteral("文件不存在！"));
        msgBox.setButtonText(QMessageBox::Yes,QStringLiteral("确定"));
        msgBox.exec();
        return;
    }

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)){
        QMessageBox msgBox(QMessageBox::Information, QStringLiteral("警告"), QStringLiteral("无法打开文件！"));
        msgBox.setButtonText(QMessageBox::Yes,QStringLiteral("确定"));
        msgBox.exec();
        return;
    }
    ui->textEdit_localid->setPlainText("");
    QTextStream stream(&file);
    while (!stream.atEnd()) {
        QString str = stream.readLine();
        ui->textEdit_localid->setPlainText(ui->textEdit_localid->toPlainText()+str);
    }
    file.close();
}

void MainWindow::on_pushButton_export_clicked()
{
    QString filepath = QFileDialog::getSaveFileName(this, QStringLiteral("导出文本"),
                                                    "/license", tr("TXT(*.txt)"));
    if(filepath.split(".").last()=="txt")
    {
        QTextEdit textEdit;
        textEdit.append(ui->textEdit_licensekey->toPlainText());

        QFile file(filepath);
        if(file.open(QFile::WriteOnly | QIODevice::Text))
        {
            QTextStream ts(&file);
            //ts.setCodec("UTF-8");
            ts<<textEdit.document()->toPlainText();
            file.close();
            QMessageBox msgbox(QMessageBox::Information,QStringLiteral("提示"),QStringLiteral("导出成功"));
            msgbox.setButtonText(QMessageBox::Yes,QStringLiteral("确定"));
            msgbox.exec();
        }
    }
}

void MainWindow::on_pushButton_dateset_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    QDateTime currentdate = QDateTime::currentDateTime();
    QString currentdatestr = currentdate.toString("yyyy-MM-dd hh:mm:ss");
    licensekey_Obj["LicensedDuration_end"] = currentdatestr;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_adddate_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    QDateTime licensedate = QDateTime::fromString(licensekey_Obj["LicensedDuration_end"].toString(),"yyyy-MM-dd hh:mm:ss");
    if(licensedate.isNull()){
        qDebug()<<"licenseTime is Null";
        licensedate = QDateTime::currentDateTime();
    }
    QDateTime newlicensedate = licensedate.addMonths(1);
    QString licensedatestr = newlicensedate.toString("yyyy-MM-dd hh:mm:ss");
    licensekey_Obj["LicensedDuration_end"] = licensedatestr;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_reducedate_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    QDateTime licensedate = QDateTime::fromString(licensekey_Obj["LicensedDuration_end"].toString(),"yyyy-MM-dd hh:mm:ss");
    if(licensedate.isNull()){
        qDebug()<<"licenseTime is Null";
        licensedate = QDateTime::currentDateTime();
    }
    QDateTime newlicensedate = licensedate.addMonths(-1);
    QString licensedatestr = newlicensedate.toString("yyyy-MM-dd hh:mm:ss");
    licensekey_Obj["LicensedDuration_end"] = licensedatestr;
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_setproid_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["Productid"] = ui->lineEdit_setproid->text();
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}

void MainWindow::on_pushButton_setversion_clicked()
{
    QJsonObject licensekey_Obj = workingjsondoc.object();
    licensekey_Obj["Versionid"] = ui->lineEdit_setversion->text();
    workingjsondoc.setObject(licensekey_Obj);
    QByteArray jsonbytearray = workingjsondoc.toJson();
    ui->textEdit_licensekey->setPlainText("");
    ui->textEdit_licensekey->setPlainText(getEncrypt(QString(jsonbytearray),key));
    setLicenseinfo(licensekey_Obj);
}