HYTOS

# coding: utf-8

"""

    This is license module

"""

import sys

import os

from PyQt5.QtCore import *

from PyQt5.QtGui import *

from PyQt5.QtWidgets import *

from PyQt5.QtSvg import *

from PyQt5.QtCore import QTranslator

from PyQt5.QtCore import QLocale

import base64

import License_UI

class QLicenseDialog(QDialog):

    """ This is License dialog class """

    KEY = 'Image Drawing to Intelligent Drawing'

    def __init__(self, parent):

        QDialog.__init__(self, parent)

        self.ui = License_UI.Ui_DialogLicense()

        self.ui.setupUi(self)

        self.setWindowFlags(self.windowFlags() & ~Qt.WindowCloseButtonHint & ~Qt.WindowContextHelpButtonHint)

        self.setFixedSize(self.size())

    @property

    def license(self):

        """ return license key setted by user """

        return self.ui.lineEditLicense.text()

    @staticmethod

    def process_running():

        """ check if program is running inside samsung engineering """

        import subprocess

        import socket

        import ipaddress

        n = 0  # number of instances of the program running

        CREATE_NO_WINDOW = 0x08000000

        prog = [line.split() for line in

                subprocess.check_output("tasklist", creationflags=CREATE_NO_WINDOW).splitlines()]

        [prog.pop(e) for e in [0, 1, 2]]  # useless

        for task in prog:

            if (task[0].upper() == 'EPTRAY.EXE') or (task[0].upper() == 'ICTRAY.EXE') or (

                    task[0].upper() == 'ICTRAY64.EXE'):

                n = n + 1

        if n >= 2:

            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

            s.connect(("8.8.8.8", 80))

            ip = s.getsockname()[0]

            if ipaddress.ip_address(ip) in ipaddress.ip_network('66.85.31.0/255'):

                return True

        return False

    @staticmethod

    def check_license_key():

        """ check license key with computer name """

        from AppDocData import AppDocData

        from datetime import datetime, timedelta

        try:

            if QLicenseDialog.process_running(): return True

            appDocData = AppDocData.instance()

            configs = appDocData.getAppConfigs('app', 'license')

            configs2 = appDocData.getAppConfigs('app', 'expiration')

            if configs and 1 == len(configs):

                if 'DOFTECH' in configs[0].value:

                    configs[0].value = configs[0].value.replace('DOFTECH', '')

                decoded = QLicenseDialog.decode(QLicenseDialog.KEY, configs[0].value)

                if decoded.upper() == os.environ['COMPUTERNAME'].upper():

                    if configs2 and 1 == len(configs2):

                        decoded2 = QLicenseDialog.decode(QLicenseDialog.KEY, configs2[0].value).split('-')

                        ex_date = datetime(int(decoded2[0]), int(decoded2[1]), int(decoded2[2]), int(decoded2[3]), int(decoded2[4]), int(decoded2[5]))

                        if ex_date > datetime.now():

                            return True

                        else:

                            QMessageBox.information(None, 'Information', 'Trial version has expired.')

                            return False

                    else:

                        return True

            '''

            configs = appDocData.getAppConfigs('app', 'license')

            if configs and 1 == len(configs):

                decoded = QLicenseDialog.decode(QLicenseDialog.KEY, configs[0].value)

                if decoded.upper() == os.environ['COMPUTERNAME'].upper(): return True

            '''

            dialog = QLicenseDialog(None)

            dialog.exec_()

            if dialog.isAccepted: return True

        except Exception as ex:

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                          sys.exc_info()[-1].tb_lineno)

            print(message)

        return False

    @staticmethod

    def encode(key, clear):

        enc = []

        for i in range(len(clear)):

            key_c = key[i % len(key)]

            enc_c = (ord(clear[i]) + ord(key_c)) % 256

            enc.append(enc_c)

        return base64.urlsafe_b64encode(bytes(enc))

    @staticmethod

    def decode(key, enc):

        dec = []

        try:

            enc = base64.urlsafe_b64decode(enc)

            for i in range(len(enc)):

                key_c = key[i % len(key)]

                dec_c = chr((256 + enc[i] - ord(key_c)) % 256)

                dec.append(dec_c)

        except Exception as ex:

            print('error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                      sys.exc_info()[-1].tb_lineno))

        return "".join(dec)

    def accept(self):

        from AppDocData import AppDocData

        from AppDocData import Config

        try:

            _translate = QCoreApplication.translate

            origin_text = self.license

            decoded = QLicenseDialog.decode(QLicenseDialog.KEY, self.license.replace('DOFTECH', ''))

            if decoded.upper() == os.environ['COMPUTERNAME'].upper():

                appDocData = AppDocData.instance()

                # save license key

                configs = []

                configs.append(Config('app', 'license', origin_text))

                appDocData.saveAppConfigs(configs)

                # up to here

                self.isAccepted = True

                QDialog.accept(self)

            else:

                msg = QMessageBox()

                msg.setIcon(QMessageBox.Critical)

                msg.setText(self.tr(

                    'Invalid license key.\n(Expected Computer Name({}) is not match to your computer name({}))').format(

                    'decoded', os.environ['COMPUTERNAME']))

                msg.setWindowTitle(_translate('License', "License"))

                msg.setStandardButtons(QMessageBox.Ok)

                msg.exec_()

        except Exception as ex:

            message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                          sys.exc_info()[-1].tb_lineno)

            print(message)

    def reject(self):

        self.isAccepted = False

        QDialog.reject(self)

if __name__ == '__main__':

    from License import QLicenseDialog

    var = input('Enter Computer Name: ')

    license = QLicenseDialog.encode(QLicenseDialog.KEY, var)

    print(license)