使用示例

本文档提供了KaMiXiTong软件授权管理系统的详细使用示例。

后台管理系统使用

1. 登录系统

首次访问系统时，使用默认管理员账号：

用户名: admin
密码: admin123

# 启动系统
python run.py

# 访问地址
http://localhost:5000

2. 创建产品

# 示例: 创建一个名为"记事本Pro"的产品
import requests

# 登录获取token (简化示例)
login_data = {
    "username": "admin",
    "password": "admin123"
}

# 创建产品
product_data = {
    "product_name": "记事本Pro",
    "description": "高级文本编辑器，支持多种格式和插件"
}

response = requests.post(
    "http://localhost:5000/api/v1/products",
    json=product_data,
    headers={"Authorization": "Bearer your_token"}
)

if response.status_code == 200:
    result = response.json()
    product_id = result["data"]["product_id"]
    print(f"产品创建成功，ID: {product_id}")

3. 批量生成卡密

# 生成100个为期1年的正式卡密
import requests

license_data = {
    "product_id": "PROD_ABC12345",  # 从上一步获得
    "count": 100,
    "type": 1,  # 1=正式, 0=试用
    "valid_days": 365,
    "prefix": "NOTEPAD_",  # 可选前缀
    "length": 32
}

response = requests.post(
    "http://localhost:5000/api/v1/licenses",
    json=license_data,
    headers={"Authorization": "Bearer your_token"}
)

if response.status_code == 200:
    result = response.json()
    licenses = result["data"]["licenses"]
    print(f"成功生成 {len(licenses)} 个卡密")

    # 保存到文件
    with open("licenses.txt", "w") as f:
        for license_info in licenses:
            f.write(f"{license_info['license_key']}\n")

4. 发布软件版本

# 发布新版本
version_data = {
    "product_id": "PROD_ABC12345",
    "version_num": "2.1.0",
    "update_log": "新增功能:\n1. 支持Markdown语法\n2. 改进性能\n3. 修复已知问题",
    "download_url": "https://example.com/downloads/notepad-pro-2.1.0.exe",
    "force_update": 0,  # 0=不强制, 1=强制更新
    "min_license_version": "1.0.0"  # 最低兼容版本
}

response = requests.post(
    "http://localhost:5000/api/v1/versions",
    json=version_data,
    headers={"Authorization": "Bearer your_token"}
)

if response.status_code == 200:
    result = response.json()
    print(f"版本创建成功: {result['data']['version_num']}")

    # 发布版本
    version_id = result["data"]["version_id"]
    response = requests.post(
        f"http://localhost:5000/api/v1/versions/{version_id}/publish",
        headers={"Authorization": "Bearer your_token"}
    )

Python验证器集成

1. 基础集成示例

# main.py - 您的主程序
from auth_validator import AuthValidator
import sys

def check_license():
    """检查授权"""
    validator = AuthValidator(
        software_id="PROD_ABC12345",  # 您的软件ID
        api_url="http://your-domain.com/api/v1",
        gui_mode=True  # 显示图形界面输入框
    )

    return validator.validate()

def main():
    """主程序"""
    print("正在验证授权...")

    if not check_license():
        print("授权验证失败，程序退出")
        sys.exit(1)

    print("授权验证通过，启动程序...")

    # 您的程序逻辑
    print("欢迎使用记事本Pro!")
    # ... 您的程序代码 ...

if __name__ == "__main__":
    main()

2. 高级集成示例

# advanced_app.py - 高级集成示例
from auth_validator import AuthValidator
import logging
import sys
import json

class AdvancedValidator:
    """高级验证器"""

    def __init__(self, config_file="config.json"):
        self.config = self.load_config(config_file)
        self.validator = AuthValidator(
            software_id=self.config["software_id"],
            api_url=self.config["api_url"],
            secret_key=self.config.get("secret_key"),
            cache_days=self.config.get("cache_days", 7),
            gui_mode=self.config.get("gui_mode", True)
        )

        self.setup_logging()

    def load_config(self, config_file):
        """加载配置文件"""
        try:
            with open(config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            # 创建默认配置
            default_config = {
                "software_id": "YOUR_SOFTWARE_ID",
                "api_url": "http://localhost:5000/api/v1",
                "gui_mode": True,
                "cache_days": 7
            }
            with open(config_file, 'w', encoding='utf-8') as f:
                json.dump(default_config, f, indent=2, ensure_ascii=False)
            return default_config

    def setup_logging(self):
        """设置日志"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('app.log', encoding='utf-8'),
                logging.StreamHandler()
            ]
        )

    def verify_license(self):
        """验证授权"""
        try:
            logging.info("开始授权验证")

            if not self.validator.validate():
                logging.error("授权验证失败")
                return False

            # 获取授权详情
            software_info = self.validator.get_software_info()
            if software_info:
                logging.info(f"软件信息: {software_info}")

            logging.info("授权验证成功")
            return True

        except Exception as e:
            logging.error(f"授权验证异常: {e}")
            return False

    def check_updates(self):
        """检查更新"""
        try:
            software_info = self.validator.get_software_info()
            if software_info and software_info.get('need_update'):
                new_version = software_info.get('new_version')
                download_url = software_info.get('download_url')

                print(f"\n发现新版本: {new_version}")
                print(f"下载地址: {download_url}")

                if software_info.get('force_update'):
                    print("此版本为强制更新，请升级后重新启动程序")
                    return False

                # 询问用户是否立即更新
                choice = input("是否立即下载更新? (y/n): ").lower()
                if choice == 'y':
                    import webbrowser
                    webbrowser.open(download_url)
                    return False

            return True

        except Exception as e:
            logging.warning(f"检查更新失败: {e}")
            return True

def main():
    """主程序"""
    # 初始化验证器
    verifier = AdvancedValidator()

    # 验证授权
    if not verifier.verify_license():
        input("按任意键退出...")
        sys.exit(1)

    # 检查更新
    if not verifier.check_updates():
        input("按任意键退出...")
        sys.exit(1)

    # 启动主程序
    print("=" * 50)
    print("           记事本Pro v2.1.0")
    print("=" * 50)
    print("1. 新建文件")
    print("2. 打开文件")
    print("3. 关于")
    print("4. 退出")

    while True:
        choice = input("\n请选择操作 (1-4): ")

        if choice == '1':
            print("新建文件功能...")
        elif choice == '2':
            print("打开文件功能...")
        elif choice == '3':
            print("记事本Pro - 高级文本编辑器")
            print(f"授权状态: 已激活")
            print(f"版本: 2.1.0")
        elif choice == '4':
            print("感谢使用，再见！")
            break
        else:
            print("无效选择，请重试")

if __name__ == "__main__":
    main()

API接口调用示例

1. 卡密验证

import requests
import time
import hashlib

def generate_signature(data, secret_key):
    """生成验证签名"""
    combined = f"{data['software_id']}{data['license_key']}{data['machine_code']}{data['timestamp']}"
    return hashlib.sha256(combined + secret_key).hexdigest()

def verify_license_api(license_key, machine_code, software_id):
    """通过API验证卡密"""
    secret_key = "your-secret-key"
    api_url = "http://localhost:5000/api/v1/auth/verify"

    # 准备请求数据
    data = {
        "software_id": software_id,
        "license_key": license_key,
        "machine_code": machine_code,
        "timestamp": int(time.time())
    }

    # 生成签名
    data["signature"] = generate_signature(data, secret_key)

    # 发送请求
    response = requests.post(api_url, json=data)

    if response.status_code == 200:
        result = response.json()
        if result["success"]:
            auth_info = result["data"]
            print(f"验证成功! 类型: {auth_info['type_name']}")
            print(f"有效期至: {auth_info['expire_time'] or '永久'}")
            return True

    print(f"验证失败: {result.get('message', '未知错误')}")
    return False

# 使用示例
license_key = "NOTEPAD_ABC1234567890DEF"
machine_code = "A1B2C3D4E5F678901234567890ABCDEF"
software_id = "PROD_ABC12345"

verify_license_api(license_key, machine_code, software_id)

2. 批量操作示例

# 批量查询卡密状态
def batch_check_licenses(license_keys, software_id):
    """批量查询卡密状态"""
    api_url = "http://localhost:5000/api/v1/licenses"

    results = []

    for license_key in license_keys:
        params = {
            "keyword": license_key,
            "product_id": software_id
        }

        response = requests.get(api_url, params=params)

        if response.status_code == 200:
            result = response.json()
            if result["success"] and result["data"]["licenses"]:
                license_info = result["data"]["licenses"][0]
                results.append({
                    "license_key": license_key,
                    "status": license_info["status_name"],
                    "activate_time": license_info["activate_time"],
                    "expire_time": license_info["expire_time"]
                })
            else:
                results.append({
                    "license_key": license_key,
                    "status": "不存在",
                    "activate_time": None,
                    "expire_time": None
                })

    return results

# 使用示例
license_keys = [
    "NOTEPAD_ABC1234567890DEF",
    "NOTEPAD_XYZ9876543210ABC",
    "NOTEPAD_DEF5678901234GHI"
]

results = batch_check_licenses(license_keys, "PROD_ABC12345")
for result in results:
    print(f"{result['license_key']}: {result['status']}")

常见场景解决方案

1. 试用授权场景

# trial_manager.py - 试用管理
from auth_validator import AuthValidator
import time

class TrialManager:
    """试用授权管理"""

    def __init__(self, software_id):
        self.software_id = software_id
        self.validator = AuthValidator(software_id=software_id)

    def request_trial(self):
        """申请试用授权"""
        print("正在申请试用授权...")

        # 这里可以调用API生成试用卡密
        # 或者让用户联系管理员

        trial_code = input("请输入试用卡密: ").strip()

        if self.validator._validate_license_format(trial_code):
            return trial_code
        return None

    def start_trial(self):
        """开始试用"""
        trial_code = self.request_trial()
        if not trial_code:
            return False

        # 尝试验证试用卡密
        success, message, auth_info = self.validator._online_verify(trial_code)

        if success and auth_info and auth_info.get('type') == 0:
            days_left = auth_info.get('remaining_days', 0)
            print(f"试用激活成功！剩余 {days_left} 天")
            return True
        else:
            print(f"试用激活失败: {message}")
            return False

2. 离线授权场景

# offline_manager.py - 离线授权管理
from auth_validator import AuthValidator, AuthCache
import json
import os

class OfflineManager:
    """离线授权管理"""

    def __init__(self, software_id):
        self.software_id = software_id
        self.cache = AuthCache()
        self.license_file = "offline_license.json"

    def generate_offline_license(self, license_key, machine_code, expire_days):
        """生成离线授权文件"""
        offline_data = {
            "software_id": self.software_id,
            "license_key": license_key,
            "machine_code": machine_code,
            "issue_time": time.time(),
            "expire_days": expire_days,
            "signature": "offline_signature"  # 实际应用中需要数字签名
        }

        with open(self.license_file, 'w') as f:
            json.dump(offline_data, f, indent=2)

        print(f"离线授权文件已生成: {self.license_file}")

    def verify_offline_license(self):
        """验证离线授权"""
        if not os.path.exists(self.license_file):
            return False, "未找到离线授权文件"

        try:
            with open(self.license_file, 'r') as f:
                offline_data = json.load(f)

            # 检查软件ID
            if offline_data["software_id"] != self.software_id:
                return False, "授权文件不匹配当前软件"

            # 检查机器码
            current_machine_code = MachineCodeGenerator.generate()
            if offline_data["machine_code"] != current_machine_code:
                return False, "授权文件不匹配当前设备"

            # 检查过期时间
            issue_time = offline_data["issue_time"]
            expire_days = offline_data["expire_days"]

            if time.time() - issue_time > expire_days * 24 * 3600:
                return False, "离线授权已过期"

            return True, "离线授权验证成功"

        except Exception as e:
            return False, f"授权文件损坏: {e}"

3. 多产品授权场景

# multi_product_manager.py - 多产品授权管理
from auth_validator import AuthValidator

class MultiProductManager:
    """多产品授权管理"""

    def __init__(self):
        self.products = {}
        self.validators = {}

    def add_product(self, product_id, product_name, api_url):
        """添加产品"""
        self.products[product_id] = product_name
        self.validators[product_id] = AuthValidator(
            software_id=product_id,
            api_url=api_url
        )

    def verify_all_products(self):
        """验证所有产品授权"""
        results = {}

        for product_id, validator in self.validators.items():
            success = validator.validate()
            results[product_id] = {
                "name": self.products[product_id],
                "success": success
            }

        return results

    def get_product_status(self, product_id):
        """获取产品授权状态"""
        if product_id not in self.validators:
            return None

        auth_info = self.validators[product_id].cache.get_auth_info(product_id)
        return auth_info

# 使用示例
manager = MultiProductManager()
manager.add_product("PROD_NOTEPAD", "记事本Pro", "http://api.example.com/v1")
manager.add_product("PROD_CALC", "计算器Pro", "http://api.example.com/v1")

# 验证所有产品
results = manager.verify_all_products()
for product_id, result in results.items():
    status = "✅ 已授权" if result["success"] else "❌ 未授权"
    print(f"{result['name']}: {status}")

这些示例涵盖了KaMiXiTong系统的各种使用场景，您可以根据实际需求进行调整和扩展。

16 KiB Raw Blame History Unescape Escape

使用示例

目录

后台管理系统使用

1. 登录系统

2. 创建产品

3. 批量生成卡密

4. 发布软件版本

Python验证器集成

1. 基础集成示例

2. 高级集成示例

API接口调用示例

1. 卡密验证

2. 批量操作示例

常见场景解决方案

1. 试用授权场景

2. 离线授权场景

3. 多产品授权场景

16 KiB

Raw Blame History