2022-5-1-jjk网络验证系统开源 服务端代码
服务端相关代码
http协议
通讯
.版本 2
.程序集 通讯
.子程序 初始化服务端, 逻辑型
全_通信句柄 ＝ 全_Http服务端.创建 (假)
.如果真 (全_通信句柄 ＞ 0)
.如果真 (全_Http服务端.启动 (全_通信句柄, “0.0.0.0”, 到整数 (取服务器监听端口 ())))
主标题 ＝ “JJK企业版网络验证系统 服务端已启动 监听 IP 0.0.0.0 端口 ” ＋ 取服务器监听端口 () ＋ “ 交流群 832092853”
全_Http服务端.事件_客户进入 (&客户进入)
全_Http服务端.事件_客户离开 (&客户离开)
全_Http服务端.事件_请求头完成通知 (&请求体完成通知)
全_Http服务端.事件_请求体报文通知 (&请求头报文通知)
全_Http服务端.事件_解析完成通知 (&解析完成通知)
全_Http线程池.创建 ()
全_Http线程池.启动 (0, 0, #TRP_WAIT_FOR, 0)
返回 (真)
.如果真结束
.如果真结束
返回 (假)
.子程序 取服务器监听端口, 文本型
返回 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\服务器配置\服务器配置.ini”, “监听端口”, “端口”, ))
HTTP事件处理
.版本 2
.程序集 HTTP事件处理
.子程序 客户进入, 整数型
.参数 通信句柄, 整数型
.参数 连接ID, 整数型
.参数 客户端口, 整数型
.局部变量 IBufferPtr, IBufferPtr
IBufferPtr.创建新指针 ()
全_Http服务端.置附加数据 (全_通信句柄, 连接ID, IBufferPtr.取本类数据 ())
返回 (#HR_OK)
.子程序 请求体完成通知, 整数型
.参数 通信句柄, 整数型
.参数 连接ID, 整数型
返回 (#HR_OK)
.子程序 请求头报文通知, 整数型
.参数 通信句柄, 整数型
.参数 连接ID, 整数型
.参数 数据指针, 整数型
.参数 数据长度, 整数型
.局部变量 附加数据, 整数型
.局部变量 IBufferPtr, IBufferPtr
.如果真 (全_Http服务端.取附加数据 (全_通信句柄, 连接ID, 附加数据))
.如果真 (附加数据 ≠ 0)
IBufferPtr.附加指针 (附加数据)
IBufferPtr_添加数据 (附加数据, 到文本 (指针到字节集 (数据指针, 数据长度)), , )
.如果真结束
.如果真结束
返回 (#HR_OK)
.子程序 解析完成通知, 整数型
.参数 通信句柄, 整数型
.参数 连接ID, 整数型
全_Http线程池.提交Soscket任务 (&完成解析_处理, 通信句柄, 连接ID, , , , , , )
返回 (#HR_OK)
.子程序 完成解析_处理
.参数 参_TaskFunc, 整数型
.局部变量 局_TSocketTask, TSocketTask
.局部变量 局_通信句柄, 整数型
.局部变量 局_连接ID, 整数型
.局部变量 局_协议头, TNVPair, , "0"
.局部变量 局_计次, 整数型
.局部变量 局_附加数据, 整数型
.局部变量 局_请求路径, 文本型
.局部变量 局_请求协议头, 文本型
.局部变量 局_URL参数, 文本型
.局部变量 局_请求Cookie, 文本型
.局部变量 局_请求类型, 文本型
.局部变量 局_请求数据, 文本型
.局部变量 参_通信句柄, 整数型
.局部变量 参_连接ID, 整数型
.如果真 (全_Http线程池.指针转换Socket任务 (参_TaskFunc, 局_TSocketTask) ＝ 假)
返回 ()
.如果真结束
局_连接ID ＝ 局_TSocketTask.连接ID
局_通信句柄 ＝ 局_TSocketTask.通信句柄
.如果真 (全_Http服务端.取附加数据 (局_通信句柄, 局_连接ID, 局_附加数据))
.如果真 (局_附加数据 ≠ 0)
局_请求数据 ＝ IBufferPtr_取出数据 (局_附加数据)
IBufferPtr_释放 (局_附加数据)
.如果真结束
.如果真结束
全_Http服务端.取所有HTTP返回协议头 (局_通信句柄, 局_连接ID, 局_协议头)
.计次循环首 (取数组成员数 (局_协议头), 局_计次)
局_请求协议头 ＝ 局_请求协议头 ＋ #换行符 ＋ 局_协议头 [局_计次].名称 ＋ “: ” ＋ 局_协议头 [局_计次].值
.计次循环尾 ()
局_请求路径 ＝ 全_Http服务端.取URL域值 (局_通信句柄, 局_连接ID, #HUF_PATH)
局_URL参数 ＝ 全_Http服务端.取URL域值 (局_通信句柄, 局_连接ID, #HUF_PATH ＋ 1)
局_请求Cookie ＝ 全_Http服务端.取请求头_单值 (局_通信句柄, 局_连接ID, “Cookie”)
局_请求类型 ＝ 全_Http服务端.取请求方法 (局_通信句柄, 局_连接ID)
数据到达_路由 (局_通信句柄, 局_连接ID, 局_请求路径, 局_请求协议头, 局_URL参数, 局_请求Cookie, 局_请求数据, 局_请求类型)
' 全_Http服务端.释放指针 (全_通信句柄, 局_连接ID)
' 全_Http服务端.断开连接 (全_通信句柄, 局_连接ID, 真)
返回 ()
.子程序 回复请求
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 参_要回复的数据, 文本型
全_Http服务端.回复请求 (参_通信句柄, 参_连接ID, 200, , , 到字节集 (参_要回复的数据))
.子程序 客户离开, 整数型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 错误代码, 整数型
.参数 错误描述, 整数型
' hpHPSocket_客户离开 (到文本 (参_连接ID))
返回 (#HR_OK)
.子程序 IBufferPtr_添加数据
.参数 数据指针, 整数型
.参数 数据1, 文本型, , 一行内的数据
.参数 数据2, 文本型, 可空, 一行内的数据
.参数 数据3, 文本型, 可空, 一行内的数据
.局部变量 IBufferPtr, IBufferPtr
IBufferPtr.附加指针 (数据指针)
IBufferPtr.添加字节集数据 (到字节集 (数据1 ＋ 数据2 ＋ 数据3))
返回 ()
.子程序 IBufferPtr_取出数据, 文本型
.参数 数据指针, 整数型
.局部变量 IBufferPtr, IBufferPtr
.局部变量 结果, 文本型
IBufferPtr.附加指针 (数据指针)
结果 ＝ 到文本 (IBufferPtr.返回字节集 ())
返回 (结果)
.子程序 IBufferPtr_释放
.参数 数据指针, 整数型
.局部变量 IBufferPtr, IBufferPtr
IBufferPtr.附加指针 (数据指针)
IBufferPtr.释放数据 ()
返回 ()
请求处理
.版本 2
.支持库 spec
.程序集 请求处理
.子程序 数据到达_路由, , , 在此添加修改访问路径即可添加新功能
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 参_请求路径, 文本型
.参数 参_请求协议头, 文本型
.参数 参_URL参数, 文本型
.参数 参_请求Cookie, 文本型
.参数 参_请求数据, 文本型
.参数 参_请求类型, 文本型
.局部变量 请求数据, 文本型
.局部变量 解密数据, 文本型
编码_UTF8解码 (到字节集 (参_请求数据), 请求数据)
请求数据 ＝ JJK解密 (请求数据)
写监控日志 (“====================================================”)
解密数据 ＝ JJK解密 (取文本右边 (参_请求路径, 取文本长度 (参_请求路径) － 1))
.判断开始 (解密数据 ＝ “csh”)
.如果 (初始化验证处理 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 客户登录成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 客户登录失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “fwqwjxz”)
.如果 (文件下载处理 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 文件下载成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 文件下载失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “gonggaoa”)
.如果 (取公告A (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取公告A成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取公告A失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “bmdfh”)
.如果 (取白名单返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取白名单返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取白名单返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ftfh”)
.如果 (取封停返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取封停返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取封停返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “pjfh”)
.如果 (取破解返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取破解返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取破解返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “gonggaob”)
.如果 (取公告B (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取公告B成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取公告B失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “zxkmzs”)
.如果 (取在线卡密总数 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取在线卡密总数成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取在线卡密总数失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “xx”)
.如果 (踢掉在线卡密 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 踢掉在线卡密成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 踢掉在线卡密失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ks”)
.如果 (解绑扣时 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 解绑扣时成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 解绑扣时失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “qszsf”)
.如果 (取所在省份 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取所在省份成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取所在省份失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “dlfh”)
.如果 (取登录返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取登录返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取登录返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “yzcshfh”)
.如果 (取验证初始化返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取验证初始化返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取验证初始化返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “zcfh”)
.如果 (取注册返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取注册返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取注册返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “hmdfh”)
.如果 (取黑名单返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取黑名单返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取黑名单返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “xtfh”)
.如果 (取心跳返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取心跳返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取心跳返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “sjjsfh”)
.如果 (取数据接收返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取数据接收返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取数据接收返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “yjsfh”)
.如果 (取云计算结果返回数据 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云计算结果返回数据成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云计算结果返回数据失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “jb”)
.如果 (解绑 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 解绑成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 解绑失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “gljb”)
.如果 (管理解绑 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 管理解绑成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 管理解绑失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ycs”)
.如果 (取云参数 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云参数成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云参数失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ytp”)
.如果 (取云图片 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云图片成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云图片失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “yMD5”)
.如果 (取云MD5 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云MD5成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云MD5失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ywd”)
.如果 (取云文档 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云文档成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 取云文档失败”)
.如果结束
返回 ()
.判断 (解密数据 ＝ “ft”)
.如果 (客户封停 (参_通信句柄, 参_连接ID, 请求数据))
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 客户封停成功”)
.否则
写监控日志 (到文本 (参_通信句柄) ＋ “ ” ＋ 到文本 (参_连接ID) ＋ “ 客户封停成功”)
.如果结束
.默认
.判断结束
返回 ()
.子程序 客户封停, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 客户封停”)
回复内容 ＝ 读取云MD5 (组 [5])
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取云MD5, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取云MD5”)
回复内容 ＝ 读取云MD5 (组 [5])
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 读取云MD5, 文本型
.参数 文件名, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 MD5总数, 整数型
.局部变量 i, 整数型
MD5总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, “MD5总数”, ))
.计次循环首 (MD5总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
.如果真 (组 [1] ＝ 文件名)
返回 (组 [2])
.如果真结束
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
返回 (“”)
.子程序 取云文档, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
.局部变量 文件, 字节集
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取云文档”)
文件 ＝ 读入文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云文档\” ＋ 组 [5])
.判断开始 (取文件尺寸 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云文档\” ＋ 组 [5]) ÷ 1024 ＞ 300)
返回 (假)
.默认
回复内容 ＝ 字节集_字节集转文本ex (文件)
.判断结束
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, 回复内容)
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取云图片, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
.局部变量 文件, 字节集
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取云图片”)
文件 ＝ 读入文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云图片\” ＋ 组 [5])
.判断开始 (取文件尺寸 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云图片\” ＋ 组 [5]) ÷ 1024 ＞ 300)
返回 (假)
.默认
回复内容 ＝ 字节集_字节集转文本ex (文件)
.判断结束
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, 回复内容)
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取云参数, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取云参数”)
回复内容 ＝ 读取云参数 (组 [5])
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 读取云参数, 文本型
.参数 参数名, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 云参数总数, 整数型
.局部变量 i, 整数型
调试输出 (参数名)
云参数总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, “云参数总数”, ))
.计次循环首 (云参数总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
.如果真 (组 [1] ＝ 参数名)
返回 (组 [2])
.如果真结束
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
返回 (“”)
.子程序 解绑, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
.局部变量 内容, 文本型
.局部变量 卡类型, 文本型
.局部变量 生成时间, 文本型
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.局部变量 软件版本, 文本型
.局部变量 价格, 文本型
.局部变量 附属性, 文本型
.局部变量 绑机数量, 文本型
.局部变量 备注, 文本型
.局部变量 销售员, 文本型
.局部变量 时间1, 文本型
.局部变量 时间2, 文本型
.局部变量 机器码, 文本型
.局部变量 IP, 文本型
.局部变量 所在省份, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
卡类型 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 1)
生成时间 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 2)
软件名 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 3)
软件类型 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 4)
软件版本 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 5)
价格 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 6)
附属性 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 7)
绑机数量 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 8)
备注 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 9)
销售员 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 10)
时间1 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 11)
时间2 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 12)
机器码 ＝ “唯一机器码”
IP ＝ “IP地址”
所在省份 ＝ “所在省份”
内容 ＝ 卡类型 ＋ “&&” ＋ 生成时间 ＋ “&&” ＋ 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本 ＋ “&&” ＋ 价格 ＋ “&&” ＋ 附属性 ＋ “&&” ＋ 绑机数量 ＋ “&&” ＋ 备注 ＋ “&&” ＋ 销售员 ＋ “&&” ＋ 时间1 ＋ “&&” ＋ 时间2 ＋ “&&” ＋ 机器码 ＋ “&&” ＋ IP ＋ “&&” ＋ 所在省份
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 组 [2] ＋ “&&” ＋ 组 [3] ＋ “&&” ＋ 组 [4], 组 [1], 内容)
写监控日志 (组 [1] ＋ “ 解绑”)
回复内容 ＝ “解绑成功”
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 管理解绑, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
.局部变量 内容, 文本型
.局部变量 卡类型, 文本型
.局部变量 生成时间, 文本型
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.局部变量 软件版本, 文本型
.局部变量 价格, 文本型
.局部变量 附属性, 文本型
.局部变量 绑机数量, 文本型
.局部变量 备注, 文本型
.局部变量 销售员, 文本型
.局部变量 时间1, 文本型
.局部变量 时间2, 文本型
.局部变量 机器码, 文本型
.局部变量 IP, 文本型
.局部变量 所在省份, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
卡类型 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 1)
生成时间 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 2)
软件名 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 3)
软件类型 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 4)
软件版本 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 5)
价格 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 6)
附属性 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 7)
绑机数量 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 8)
备注 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 9)
销售员 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 10)
时间1 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 11)
时间2 ＝ 取已使用卡密属性 (组 [1], 组 [2], 组 [3], 组 [4], 12)
机器码 ＝ “唯一机器码”
IP ＝ “IP地址”
所在省份 ＝ “所在省份”
内容 ＝ 卡类型 ＋ “&&” ＋ 生成时间 ＋ “&&” ＋ 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本 ＋ “&&” ＋ 价格 ＋ “&&” ＋ 附属性 ＋ “&&” ＋ 绑机数量 ＋ “&&” ＋ 备注 ＋ “&&” ＋ 销售员 ＋ “&&” ＋ 时间1 ＋ “&&” ＋ 时间2 ＋ “&&” ＋ 机器码 ＋ “&&” ＋ IP ＋ “&&” ＋ 所在省份
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 组 [2] ＋ “&&” ＋ 组 [3] ＋ “&&” ＋ 组 [4], 组 [1], 内容)
写监控日志 (组 [1] ＋ “ 解绑”)
回复内容 ＝ “解绑成功”
.如果真结束
.如果 (销售员 ＝ 组 [5])
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.否则
返回 (假)
.如果结束
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 服务器解绑, 逻辑型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 卡密, 文本型
.局部变量 内容, 文本型
.局部变量 卡类型, 文本型
.局部变量 生成时间, 文本型
.局部变量 价格, 文本型
.局部变量 附属性, 文本型
.局部变量 绑机数量, 文本型
.局部变量 备注, 文本型
.局部变量 销售员, 文本型
.局部变量 时间1, 文本型
.局部变量 时间2, 文本型
.局部变量 机器码, 文本型
.局部变量 IP, 文本型
.局部变量 所在省份, 文本型
卡类型 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 1)
生成时间 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 2)
价格 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 6)
附属性 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 7)
绑机数量 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 8)
备注 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 9)
销售员 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10)
时间1 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 11)
时间2 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 12)
机器码 ＝ “唯一机器码”
IP ＝ “IP地址”
所在省份 ＝ “所在省份”
内容 ＝ 卡类型 ＋ “&&” ＋ 生成时间 ＋ “&&” ＋ 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本 ＋ “&&” ＋ 价格 ＋ “&&” ＋ 附属性 ＋ “&&” ＋ 绑机数量 ＋ “&&” ＋ 备注 ＋ “&&” ＋ 销售员 ＋ “&&” ＋ 时间1 ＋ “&&” ＋ 时间2 ＋ “&&” ＋ 机器码 ＋ “&&” ＋ IP ＋ “&&” ＋ 所在省份
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
写监控日志 (卡密 ＋ “ 解绑成功”)
返回 (真)
.子程序 取云计算结果返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取云计算结果返回数据”)
回复内容 ＝ 主窗口.编辑框12.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取数据接收返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取数据接收返回数据”)
回复内容 ＝ 主窗口.编辑框11.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取心跳返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取心跳返回数据”)
回复内容 ＝ 主窗口.编辑框10.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取破解返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取破解返回数据”)
回复内容 ＝ 主窗口.编辑框9.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取封停返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取封停返回数据”)
回复内容 ＝ 主窗口.编辑框8.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取白名单返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取白名单返回数据”)
回复内容 ＝ 主窗口.编辑框7.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取黑名单返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取黑名单返回数据”)
回复内容 ＝ 主窗口.编辑框6.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取注册返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取注册返回数据”)
回复内容 ＝ 主窗口.编辑框5.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取验证初始化返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取验证初始化返回数据”)
回复内容 ＝ 主窗口.编辑框3.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取登录返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取登录返回数据”)
回复内容 ＝ 主窗口.编辑框2.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取所在省份, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取所在省份”)
回复内容 ＝ IP查询地址 (组 [5])
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 解绑扣时, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 6)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 解绑扣时”)
扣时 (到整数 (组 [5]), 组 [6], 组 [1], 组 [2], 组 [3], 组 [4])
回复内容 ＝ “真”
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取返回数据, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取公告A”)
回复内容 ＝ 主窗口.编辑框13.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 踢掉在线卡密, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 踢掉在线卡密”)
删除已登录卡密 (组 [1], 组 [2], 组 [3], 组 [4])
回复内容 ＝ “真”
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取在线卡密总数, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取在线卡密总数”)
回复内容 ＝ 取已登录卡密总数 ()
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取公告A, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取公告A”)
回复内容 ＝ 主窗口.编辑框13.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 取公告B, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 4)
.如果真 (卡密验证 (组 [1], 组 [2], 组 [3], 组 [4]))
写监控日志 (组 [1] ＋ “ 取公告A”)
回复内容 ＝ 主窗口.编辑框14.内容
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容))
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
返回 (真)
.子程序 文件下载处理, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 回复内容, 文本型
.局部变量 文件, 字节集
.如果真 (主窗口.选择框2.选中)
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 5)
.如果真 (卡密验证 (组 [2], 组 [3], 组 [4], 组 [5]))
写监控日志 (组 [2] ＋ “ 文件下载 ” ＋ 组 [1])
.如果真 (文件是否存在 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\” ＋ 组 [1]))
文件 ＝ 读入文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\” ＋ 组 [1])
.判断开始 (取文件尺寸 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\” ＋ 组 [1]) ÷ 1024 ＞ 300)
返回 (假)
.默认
回复内容 ＝ 字节集_字节集转文本ex (文件)
.判断结束
.如果真结束
.如果真结束
回复请求 (参_通信句柄, 参_连接ID, 回复内容)
.如果真结束
.如果真 (回复内容 ＝ “”)
返回 (假)
.如果真结束
.如果真结束
返回 (真)
.子程序 初始化验证处理, 逻辑型
.参数 参_通信句柄, 整数型
.参数 参_连接ID, 整数型
.参数 请求数据, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 卡密存在, 逻辑型
.局部变量 客户端唯一机器码, 文本型
.局部变量 客户端外网IP地址, 文本型
.局部变量 客户端所在省份, 文本型
.局部变量 服务器IP验证, 逻辑型
.局部变量 服务器端口验证, 逻辑型
.局部变量 软件名验证, 逻辑型
.局部变量 软件类型验证, 逻辑型
.局部变量 软件版本验证, 逻辑型
.局部变量 卡密所属销售员验证, 逻辑型
.局部变量 回复内容, 文本型
.局部变量 客户端口, 整数型
组 ＝ 分割文本 (请求数据, “&&”, )
.如果真 (取数组成员数 (组) ≥ 7)
.如果 (卡密验证 (组 [1], 组 [5], 组 [6], 组 [7]))
写监控日志 (“卡密存在 ” ＋ 组 [1])
全_Http服务端.取远程地址信息 (参_通信句柄, 参_连接ID, 客户端外网IP地址, 客户端口)
客户端唯一机器码 ＝ 组 [2]
客户端所在省份 ＝ IP查询地址 (客户端外网IP地址)
服务器IP验证 ＝ 服务器IP验证 (组 [3])
验证结果 ＝ “”
.如果真 (取反 (服务器IP验证) 且 验证结果 ≠ “”)
验证结果 ＝ “服务器IP验证错误”
.如果真结束
服务器端口验证 ＝ 服务器端口验证 (组 [4])
.如果真 (取反 (服务器端口验证) 且 验证结果 ≠ “”)
验证结果 ＝ “服务器端口验证错误”
.如果真结束
软件名验证 ＝ 软件名验证 (组 [5])
.如果真 (取反 (软件名验证) 且 验证结果 ≠ “”)
验证结果 ＝ “软件名验证错误”
.如果真结束
软件类型验证 ＝ 软件类型验证 (组 [1], 组 [5], 组 [6], 组 [7])
.如果真 (取反 (软件类型验证) 且 验证结果 ≠ “”)
验证结果 ＝ “软件类型验证错误”
.如果真结束
软件版本验证 ＝ 软件版本验证 (组 [1], 组 [5], 组 [6], 组 [7])
.如果真 (取反 (软件版本验证) 且 验证结果 ≠ “”)
验证结果 ＝ “软件版本验证错误”
.如果真结束
卡密所属销售员验证 ＝ 所属销售员验证 (组 [1], 组 [5], 组 [6], 组 [7])
.如果真 (取反 (卡密所属销售员验证) 且 验证结果 ≠ “”)
验证结果 ＝ “卡密所属销售员验证错误”
.如果真结束
卡密存在 ＝ 卡密合法性验证 (组 [1], 客户端唯一机器码, 客户端外网IP地址, 客户端所在省份, 组 [5], 组 [6], 组 [7])
.如果真 (验证结果 ＝ “”)
验证结果 ＝ “真”
.如果真结束
回复内容 ＝ 到文本 (服务器IP验证) ＋ “-” ＋ 到文本 (服务器端口验证) ＋ “-” ＋ 到文本 (软件名验证) ＋ “-” ＋ 到文本 (软件类型验证) ＋ “-” ＋ 到文本 (软件版本验证) ＋ “-” ＋ 到文本 (卡密所属销售员验证) ＋ “-” ＋ 到文本 (卡密存在) ＋ “-” ＋ 验证结果
.否则
写监控日志 (组 [1] ＋ “ 不存在”)
.如果结束
调试输出 (回复内容)
回复请求 (参_通信句柄, 参_连接ID, JJK加密 (回复内容 ＋ “-” ＋ 客户端外网IP地址 ＋ “-” ＋ 全_剩余时间))
.如果真结束
刷新标签信息 ()
返回 (回复内容 ＝ “真-真-真-真-真-真-真-真”)
.子程序 卡密合法性验证, 逻辑型
.参数 卡密, 文本型
.参数 客户端唯一机器码, 文本型
.参数 客户端外网IP地址, 文本型
.参数 客户端所在省份, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 登录时间, 日期时间型
.局部变量 激活时间, 日期时间型
.局部变量 内容, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 剩余时间, 整数型
.局部变量 卡类型时间, 整数型
登录时间 ＝ 取现行时间 ()
.如果真 (取已到期卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5) ≠ “卡密不存在”) ' 是否已到期
写监控日志 (卡密 ＋ “ 已到期”)
.如果真 (验证结果 ≠ “”)
验证结果 ＝ “卡密已到期”
.如果真结束
返回 (假)
.如果真结束
.如果真 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5) ≠ “卡密不存在”) ' 是否已使用
激活时间 ＝ 到时间 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 11))
剩余时间 ＝ 取时间间隔 (登录时间, 激活时间, #秒)
卡类型时间 ＝ 小时到秒 (到整数 (读取卡类型属性 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 1), 软件名, 软件类型, 软件版本, 5)))
剩余时间 ＝ 卡类型时间 － 剩余时间
全_剩余时间 ＝ 辅助_秒到天 (剩余时间)
写监控日志 (“卡类型 ” ＋ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 1))
写监控日志 (“卡时间 ” ＋ 读取卡类型属性 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 1), 软件名, 软件类型, 软件版本, 5))
写监控日志 (“剩余时间 ” ＋ 辅助_秒到天 (剩余时间))
.如果真 (剩余时间 ≤ 0) ' 是否已到期
写监控日志 (卡密 ＋ “ 已到期”)
.如果真 (验证结果 ≠ “”)
验证结果 ＝ “卡密已到期”
.如果真结束
内容 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 0)
组 ＝ 分割文本 (内容, “&&”, )
组 [12] ＝ 到文本 (登录时间)
内容 ＝ “”
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
.判断开始 (i ＞ 1)
内容 ＝ 内容 ＋ “&&” ＋ 组 [i]
.默认
内容 ＝ 内容 ＋ 组 [i]
.判断结束
.计次循环尾 ()
.如果真 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, “统计卡密总数”, “已使用卡密总数”, )) ＞ 0)
删除已使用卡密 (卡密, 软件名, 软件类型, 软件版本)
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
保存已到期卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.如果真结束
返回 (假)
.如果真结束
.如果真 (剩余时间 ＞ 0)
写监控日志 (卡密 ＋ “ 已使用”)
内容 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 0)
组 ＝ 分割文本 (内容, “&&”, )
组 [12] ＝ 到文本 (登录时间)
内容 ＝ “”
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
.判断开始 (i ＞ 1)
内容 ＝ 内容 ＋ “&&” ＋ 组 [i]
.默认
内容 ＝ 内容 ＋ 组 [i]
.判断结束
.计次循环尾 ()
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
内容 ＝ 子文本替换 (内容, “唯一机器码”, 客户端唯一机器码, , , 真)
内容 ＝ 子文本替换 (内容, “IP地址”, 客户端外网IP地址, , , 真)
内容 ＝ 子文本替换 (内容, “所在省份”, 客户端所在省份, , , 真)
保存已登录卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.如果真 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, )) ＞ 0)
删除已使用卡密 (卡密, 软件名, 软件类型, 软件版本)
保存已使用卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.如果真结束
.如果 (客户端唯一机器码 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 13) 或 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 13) ＝ “唯一机器码”)
写监控日志 (“客户机器码 ” ＋ 客户端唯一机器码)
.如果 (客户端外网IP地址 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 14) 或 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 14) ＝ “IP地址”)
写监控日志 (“客户端外网IP地址 ” ＋ 客户端外网IP地址)
.如果 (客户端所在省份 ＝ 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 15) 或 取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 15) ＝ “所在省份”)
写监控日志 (“客户地址 ” ＋ 客户端所在省份)
保存已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 13, 客户端唯一机器码)
保存已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 14, 客户端外网IP地址)
保存已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 15, 客户端所在省份)
返回 (真)
.否则
.如果真 (验证结果 ≠ “”)
验证结果 ＝ “客户地址错误”
.如果真结束
.如果结束
.否则
.如果真 (验证结果 ≠ “”)
验证结果 ＝ “客户端外网IP地址错误”
.如果真结束
.如果结束
.否则
.如果真 (验证结果 ≠ “”)
验证结果 ＝ “客户机器码错误”
.如果真结束
.如果结束
返回 (假)
.如果真结束
.如果真结束
.如果真 (取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5) ≠ “卡密不存在”) ' 是否首次激活
激活时间 ＝ 取现行时间 ()
内容 ＝ 取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 0) ＋ “&&” ＋ 到文本 (激活时间) ＋ “&&” ＋ 到文本 (登录时间) ＋ “&&” ＋ 客户端唯一机器码 ＋ “&&” ＋ 客户端外网IP地址 ＋ “&&” ＋ 客户端所在省份
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
保存已登录卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.如果真 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, )) ＞ 0)
删除未使用卡密 (卡密, 软件名, 软件类型, 软件版本)
保存已使用卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.如果真结束
写监控日志 (卡密 ＋ “ 首次激活成功”)
写监控日志 (“激活时间 ” ＋ 到文本 (激活时间))
写监控日志 (“客户机器码 ” ＋ 客户端唯一机器码)
写监控日志 (“客户端外网IP地址 ” ＋ 客户端外网IP地址)
写监控日志 (“客户地址 ” ＋ 客户端所在省份)
返回 (真)
.如果真结束
返回 (假)
.子程序 删除已封停卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, 到文本 (总数 － 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, “统计卡密总数”, “已封停卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, “统计卡密总数”, “已封停卡密总数”, 到文本 (总数 － 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, ))
.如果真 (总数 ＜ 0)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, 到文本 (0))
.如果真结束
.子程序 删除已到期卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, 到文本 (总数 － 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, “统计卡密总数”, “已到期卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, “统计卡密总数”, “已到期卡密总数”, 到文本 (总数 － 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, ))
.如果真 (总数 ＜ 0)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, 到文本 (0))
.如果真结束
.子程序 删除已使用卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, 到文本 (总数 － 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, “统计卡密总数”, “已使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, “统计卡密总数”, “已使用卡密总数”, 到文本 (总数 － 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, ))
.如果真 (总数 ＜ 0)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, 到文本 (0))
.如果真结束
.子程序 删除未使用卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, 到文本 (总数 － 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, 到文本 (总数 － 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, ))
.如果真 (总数 ＜ 0)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, 到文本 (0))
.如果真结束
.子程序 删除已登录卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 总数, 整数型
.如果真 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, ) ≠ “”)
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, 到文本 (总数 － 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, “统计卡密总数”, “已登录卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, “统计卡密总数”, “已登录卡密总数”, 到文本 (总数 － 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真结束
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, ))
.如果真 (总数 ＜ 0)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, 到文本 (0))
.如果真结束
.子程序 保存已登录卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 内容, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已登录卡密总数”, 到文本 (总数 ＋ 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, “统计卡密总数”, “已登录卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, “统计卡密总数”, “已登录卡密总数”, 到文本 (总数 ＋ 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
.子程序 保存已使用卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 内容, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已使用卡密总数”, 到文本 (总数 ＋ 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, “统计卡密总数”, “已使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, “统计卡密总数”, “已使用卡密总数”, 到文本 (总数 ＋ 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
.子程序 保存已到期卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 内容, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已到期卡密总数”, 到文本 (总数 ＋ 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, “统计卡密总数”, “已到期卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, “统计卡密总数”, “已到期卡密总数”, 到文本 (总数 ＋ 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
.子程序 保存已封停卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 内容, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “已封停卡密总数”, 到文本 (总数 ＋ 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, “统计卡密总数”, “已封停卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, “统计卡密总数”, “已封停卡密总数”, 到文本 (总数 ＋ 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
.子程序 保存未使用卡密
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 内容, 文本型
.局部变量 总数, 整数型
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, 到文本 (总数 ＋ 1))
总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, ))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, “统计卡密总数”, “未使用卡密总数”, 到文本 (总数 ＋ 1))
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
.子程序 取已封停卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “” 且 属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (卡密属性 ≠ “” 且 属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
返回 (组 [属性索引])
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 取已到期卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “” 且 属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (卡密属性 ≠ “” 且 属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
返回 (组 [属性索引])
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 取已使用卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “”)
.如果真 (属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
返回 (组 [属性索引])
.如果真结束
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 保存已到期卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.参数 属性内容, 文本型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 内容, 文本型
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “”)
.如果真 (属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
内容 ＝ 子文本替换 (卡密属性, 组 [属性索引], 属性内容, , , 真)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
返回 (组 [属性索引])
.如果真结束
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 保存已封停卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.参数 属性内容, 文本型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 内容, 文本型
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “”)
.如果真 (属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
内容 ＝ 子文本替换 (卡密属性, 组 [属性索引], 属性内容, , , 真)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
返回 (组 [属性索引])
.如果真结束
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 保存已使用卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.参数 属性内容, 文本型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
.局部变量 内容, 文本型
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “”)
.如果真 (属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
内容 ＝ 子文本替换 (卡密属性, 组 [属性索引], 属性内容, , , 真)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, 内容)
返回 (组 [属性索引])
.如果真结束
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 所属销售员验证, 逻辑型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 销售员总数, 整数型
.局部变量 i, 整数型
销售员总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”, “销售员”, “销售员总数”, ))
.计次循环首 (销售员总数, )
i ＝ i ＋ 1
.如果真 (寻找文本 (取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), “jjk”, , 假) ≠ -1 或 寻找文本 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), “jjk”, , 假) ≠ -1 或 寻找文本 (取已到期卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), “jjk”, , 假) ≠ -1 或 寻找文本 (取已封停卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), “jjk”, , 假) ≠ -1)
返回 (真)
.如果真结束
.如果真 (寻找文本 (取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), 取数据库销售员参数A (到文本 (i), 1), , 假) ≠ -1 或 寻找文本 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), 取数据库销售员参数A (到文本 (i), 1), , 假) ≠ -1 或 寻找文本 (取已到期卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), 取数据库销售员参数A (到文本 (i), 1), , 假) ≠ -1 或 寻找文本 (取已封停卡密属性 (卡密, 软件名, 软件类型, 软件版本, 10), 取数据库销售员参数A (到文本 (i), 1), , 假) ≠ -1)
返回 (真)
.如果真结束
.计次循环尾 ()
返回 (假)
.子程序 软件版本验证, 逻辑型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
返回 (寻找文本 (取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5), 软件版本, , 假) ≠ -1 或 寻找文本 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5), 软件版本, , 假) ≠ -1 或 寻找文本 (取已到期卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5), 软件版本, , 假) ≠ -1 或 寻找文本 (取已封停卡密属性 (卡密, 软件名, 软件类型, 软件版本, 5), 软件版本, , 假) ≠ -1)
.子程序 软件类型验证, 逻辑型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
返回 (寻找文本 (取未使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 4), 软件类型, , 假) ≠ -1 或 寻找文本 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 4), 软件类型, , 假) ≠ -1 或 寻找文本 (取已到期卡密属性 (卡密, 软件名, 软件类型, 软件版本, 4), 软件类型, , 假) ≠ -1 或 寻找文本 (取已封停卡密属性 (卡密, 软件名, 软件类型, 软件版本, 4), 软件类型, , 假) ≠ -1)
.子程序 取未使用卡密属性, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.参数 属性索引, 整数型
.局部变量 卡密属性, 文本型
.局部变量 组, 文本型, , "0"
卡密属性 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 卡密, )
.如果真 (卡密属性 ≠ “” 且 属性索引 ＝ 0)
返回 (卡密属性)
.如果真结束
.如果真 (卡密属性 ≠ “” 且 属性索引 ≠ 0)
组 ＝ 分割文本 (卡密属性, “&&”, )
.如果真 (取数组成员数 (组) ≥ 属性索引)
返回 (组 [属性索引])
.如果真结束
.如果真结束
返回 (“卡密不存在”)
.子程序 卡密验证, 逻辑型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
返回 (卡密 ＝ 取数据库卡密 (卡密, 软件名, 软件类型, 软件版本))
.子程序 取数据库卡密, 文本型
.参数 客户端卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 卡密, 文本型
.判断开始 (取未使用卡密属性 (客户端卡密, 软件名, 软件类型, 软件版本, 4) ≠ “卡密不存在”)
卡密 ＝ 客户端卡密
.判断 (取已使用卡密属性 (客户端卡密, 软件名, 软件类型, 软件版本, 4) ≠ “卡密不存在”)
卡密 ＝ 客户端卡密
.判断 (取已到期卡密属性 (客户端卡密, 软件名, 软件类型, 软件版本, 4) ≠ “卡密不存在”)
卡密 ＝ 客户端卡密
.判断 (取已封停卡密属性 (客户端卡密, 软件名, 软件类型, 软件版本, 4) ≠ “卡密不存在”)
卡密 ＝ 客户端卡密
.默认
卡密 ＝ “卡密不存在”
.判断结束
返回 (卡密)
.子程序 服务器IP验证, 逻辑型
.参数 IP, 文本型
返回 (真)
.子程序 服务器端口验证, 逻辑型
.参数 端口, 文本型
返回 (端口 ＝ 取服务器监听端口 ())
.子程序 软件名验证, 逻辑型
.参数 软件名, 文本型
返回 (软件名 ＝ 取数据库软件参数A (软件名, 2))
窗口集
窗口程序集_主窗口
.版本 2
.支持库 iext
.支持库 iext2
.支持库 spec
.程序集 窗口程序集_主窗口
.程序集变量 集表项索引, 整数型
.程序集变量 集列索引, 整数型
.子程序 初始化卡密列表格式
主窗口.超级列表框2.全部删除 ()
.计次循环首 (主窗口.超级列表框2.取列数 (), )
主窗口.超级列表框2.删除列 (0)
.计次循环尾 ()
主窗口.超级列表框2.插入列 (0, “序”, 30, 1, , )
主窗口.超级列表框2.插入列 (1, “卡密”, 70, 1, , )
主窗口.超级列表框2.插入列 (2, “卡类型”, 60, 1, , )
主窗口.超级列表框2.插入列 (3, “时间”, 40, 1, , )
主窗口.超级列表框2.插入列 (4, “软件名”, 60, 1, , )
主窗口.超级列表框2.插入列 (5, “软件类型”, 80, 1, , )
主窗口.超级列表框2.插入列 (6, “软件版本”, 80, 1, , )
主窗口.超级列表框2.插入列 (7, “价格”, 40, 1, , )
主窗口.超级列表框2.插入列 (8, “附属性”, 70, 1, , )
主窗口.超级列表框2.插入列 (9, “绑机数量”, 60, 1, , )
主窗口.超级列表框2.插入列 (10, “备注”, 70, 1, , )
主窗口.超级列表框2.插入列 (11, “销售员”, 65, 1, , )
主窗口.超级列表框2.插入列 (12, “激活时间”, 60, 1, , )
主窗口.超级列表框2.插入列 (13, “登录时间”, 60, 1, , )
主窗口.超级列表框2.插入列 (14, “唯一机器码”, 80, 1, , )
主窗口.超级列表框2.插入列 (15, “IP”, 60, 1, , )
主窗口.超级列表框2.插入列 (16, “省份”, 60, 1, , )
主窗口.超级列表框2.插入列 (17, “状态”, 60, 1, , )
' 载入所有卡密到列表2 ()
.子程序 载入所有卡密到列表2
.参数 参数配置路径, 文本型, 可空
.局部变量 节名数组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 标记位, 整数型
.局部变量 j, 整数型
.局部变量 配置路径, 文本型
.局部变量 项名数组, 文本型, , "0"
.局部变量 k, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 n, 整数型
.局部变量 总数, 整数型
.局部变量 m, 整数型
.局部变量 索引, 整数型
.计次循环首 (1, )
j ＝ j ＋ 1
.判断开始断 (j ＝ 1)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”
.' 判断 (j ＝ 2)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”
.' 判断 (j ＝ 3)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”
.' 判断 (j ＝ 4)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”
.默认
.判断结束
.如果 (是否为空 (参数配置路径))
配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”
.否则
配置路径 ＝ 参数配置路径
.如果结束
文件_取配置节名数组 (配置路径, 节名数组)
i ＝ 0
.计次循环首 (取数组成员数 (节名数组), )
i ＝ i ＋ 1
.如果真 (节名数组 [i] ＝ “统计卡密总数”)
标记位 ＝ i
.如果真结束
.计次循环尾 ()
删除成员 (节名数组, 标记位, )
i ＝ 0
.计次循环首 (取数组成员数 (节名数组), )
i ＝ i ＋ 1
文件_取配置项名数组 (配置路径, 节名数组 [i], 项名数组)
n ＝ 0
.计次循环首 (取数组成员数 (项名数组), )
n ＝ n ＋ 1
.如果真 (寻找文本 (项名数组 [n], “总数”, , 假) ≠ -1)
标记位 ＝ n
.如果真结束
.计次循环尾 ()
删除成员 (项名数组, 标记位, )
k ＝ 0
.计次循环首 (取数组成员数 (项名数组), )
k ＝ k ＋ 1
组 ＝ 分割文本 (读配置项 (配置路径, 节名数组 [i], 项名数组 [k], ), “&&”, )
索引 ＝ 主窗口.超级列表框2.取表项数 ()
主窗口.超级列表框2.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框2.置标题 (索引, 1, 项名数组 [k])
n ＝ 0
.计次循环首 (取数组成员数 (组), )
n ＝ n ＋ 1
主窗口.超级列表框2.置标题 (索引, n ＋ 1, 组 [n])
.计次循环尾 ()
.如果真 (配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”)
主窗口.超级列表框2.置标题 (索引, 12, “激活时间”)
主窗口.超级列表框2.置标题 (索引, 13, “登录时间”)
主窗口.超级列表框2.置标题 (索引, 14, “唯一机器码”)
主窗口.超级列表框2.置标题 (索引, 15, “IP”)
主窗口.超级列表框2.置标题 (索引, 16, “省份”)
主窗口.超级列表框2.置标题 (索引, 17, “未使用”)
.如果真结束
.如果真 (配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”)
主窗口.超级列表框2.置标题 (索引, 17, “已使用”)
.如果真结束
.如果真 (配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”)
主窗口.超级列表框2.置标题 (索引, 17, “已到期”)
.如果真结束
.如果真 (配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”)
主窗口.超级列表框2.置标题 (索引, 17, “已封停”)
.如果真结束
.计次循环尾 ()
.计次循环尾 ()
.计次循环尾 ()
' 软件总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, ))
.' 计次循环首 (软件总数, )
' 组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, 到文本 (i ＋ 1), ), “&&”, )
' 主窗口.超级列表框1.插入表项 (i, 组 [1], , , , )
' 主窗口.超级列表框1.置标题 (i, 1, 组 [2])
' 主窗口.超级列表框1.置标题 (i, 2, 组 [3])
' 主窗口.超级列表框1.置标题 (i, 3, 组 [4])
' 主窗口.超级列表框1.置标题 (i, 4, 组 [5])
' 主窗口.超级列表框1.置标题 (i, 5, 组 [6])
' 主窗口.超级列表框1.置标题 (i, 6, 组 [7])
' 主窗口.超级列表框1.置标题 (i, 7, 组 [8])
' 主窗口.超级列表框1.置标题 (i, 8, 组 [9])
' 主窗口.超级列表框1.置标题 (i, 9, 组 [10])
' 主窗口.超级列表框1.置标题 (i, 10, 组 [11])
' 主窗口.超级列表框1.置标题 (i, 11, 组 [12])
' 主窗口.超级列表框1.置标题 (i, 12, 组 [13])
' 主窗口.超级列表框1.置标题 (i, 13, 组 [14])
' 主窗口.超级列表框1.置标题 (i, 14, 组 [15])
' 主窗口.超级列表框1.置标题 (i, 15, 组 [16])
' 主窗口.超级列表框1.置标题 (i, 16, 组 [17])
' i ＝ i ＋ 1
.' 计次循环尾 ()
.子程序 初始化组合框2
组合框2.清空 ()
主窗口.组合框2.加入项目 (“全部”, 0)
主窗口.组合框2.加入项目 (“未使用”, 1)
主窗口.组合框2.加入项目 (“已使用”, 2)
主窗口.组合框2.加入项目 (“已到期”, 3)
主窗口.组合框2.加入项目 (“已封停”, 4)
主窗口.组合框2.现行选中项 ＝ 0
.子程序 初始化组合框3
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 相同, 逻辑型
.局部变量 j, 整数型
组合框3.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框3.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框3.取项目数 (), )
.如果真 (组 [4] ＝ 主窗口.组合框3.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框3.加入项目 (组 [4], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框3.现行选中项 ＝ 0
.子程序 初始化组合框4
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框4.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框4.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框4.取项目数 (), )
.如果真 (组 [6] ＝ 主窗口.组合框4.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框4.加入项目 (组 [6], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框4.现行选中项 ＝ 0
.子程序 初始化组合框5
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框5.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框5.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框5.取项目数 (), )
.如果真 (组 [7] ＝ 主窗口.组合框5.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框5.加入项目 (组 [7], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框5.现行选中项 ＝ 0
.子程序 初始化组合框6
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框6.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框6.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框6.取项目数 (), )
.如果真 (组 [8] ＝ 主窗口.组合框6.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框6.加入项目 (组 [8], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框6.现行选中项 ＝ 0
.子程序 初始化组合框7
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框7.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框7.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框7.取项目数 (), )
.如果真 (组 [9] ＝ 主窗口.组合框7.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框7.加入项目 (组 [9], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框7.现行选中项 ＝ 0
.子程序 初始化组合框8
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框8.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框8.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框8.取项目数 (), )
.如果真 (组 [10] ＝ 主窗口.组合框8.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框8.加入项目 (组 [10], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框8.现行选中项 ＝ 0
.子程序 初始化组合框9
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框9.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框9.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框9.取项目数 (), )
.如果真 (组 [11] ＝ 主窗口.组合框9.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框9.加入项目 (组 [11], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框9.现行选中项 ＝ 0
.子程序 初始化组合框10
.局部变量 卡类型总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框10.清空 ()
卡类型总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, ))
主窗口.组合框10.加入项目 (“全部”, 0)
.计次循环首 (卡类型总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框10.取项目数 (), )
.如果真 (组 [12] ＝ 主窗口.组合框10.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框10.加入项目 (组 [12], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框10.现行选中项 ＝ 0
.子程序 初始化组合框11
.局部变量 销售员总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
组合框11.清空 ()
销售员总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”, “销售员”, “销售员总数”, ))
主窗口.组合框11.加入项目 (“全部”, 0)
.计次循环首 (销售员总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”, “销售员”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
j ＝ 0
.计次循环首 (主窗口.组合框11.取项目数 (), )
.如果真 (组 [2] ＝ 主窗口.组合框11.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框11.加入项目 (组 [2], i)
.如果真结束
相同 ＝ 假
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.组合框11.现行选中项 ＝ 0
.子程序 _按钮1_被单击
.判断开始 (选择夹1.现行子夹 ＝ 0)
选择夹1.现行子夹 ＝ 1
显示复制卡密菜单 ()
显示复制整行菜单 ()
显示解绑菜单 ()
.判断 (选择夹1.现行子夹 ＝ 1)
选择夹1.现行子夹 ＝ 2
.判断 (选择夹1.现行子夹 ＝ 2)
选择夹1.现行子夹 ＝ 3
.默认
.判断结束
.子程序 _按钮2_被单击
.判断开始 (选择夹1.现行子夹 ＝ 3)
选择夹1.现行子夹 ＝ 2
.判断 (选择夹1.现行子夹 ＝ 2)
选择夹1.现行子夹 ＝ 1
显示复制卡密菜单 ()
显示复制整行菜单 ()
显示解绑菜单 ()
.判断 (选择夹1.现行子夹 ＝ 1)
选择夹1.现行子夹 ＝ 0
刷新菜单状态 ()
.判断 (选择夹1.现行子夹 ＝ 4 且 主窗口.按钮19.标题 ＝ “锁定”)
选择夹1.现行子夹 ＝ 2
.默认
.判断结束
.子程序 刷新菜单状态
.判断开始 (列表操作类型 ＝ 0)
隐藏复制卡密菜单 ()
显示删除菜单 ()
隐藏加白菜单 ()
隐藏加黑菜单 ()
隐藏封停菜单 ()
隐藏踢掉菜单 ()
显示添加菜单 ()
隐藏新软件菜单 ()
隐藏白名单菜单 ()
隐藏销售员菜单 ()
隐藏黑名单菜单 ()
显示可添加卡类型 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 1)
隐藏复制卡密菜单 ()
显示删除菜单 ()
隐藏加白菜单 ()
隐藏加黑菜单 ()
隐藏封停菜单 ()
隐藏踢掉菜单 ()
显示添加菜单 ()
隐藏黑名单菜单 ()
隐藏白名单菜单 ()
隐藏新软件菜单 ()
显示销售员菜单 ()
隐藏可添加卡类型 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 2)
隐藏复制卡密菜单 ()
显示删除菜单 ()
隐藏加白菜单 ()
隐藏加黑菜单 ()
隐藏封停菜单 ()
隐藏踢掉菜单 ()
显示添加菜单 ()
显示新软件菜单 ()
隐藏黑名单菜单 ()
隐藏白名单菜单 ()
隐藏销售员菜单 ()
隐藏可添加卡类型 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 3)
隐藏复制卡密菜单 ()
显示删除菜单 ()
隐藏加白菜单 ()
隐藏加黑菜单 ()
隐藏封停菜单 ()
隐藏踢掉菜单 ()
显示添加菜单 ()
显示白名单菜单 ()
隐藏黑名单菜单 ()
隐藏销售员菜单 ()
隐藏新软件菜单 ()
隐藏可添加卡类型 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 4)
隐藏复制卡密菜单 ()
显示删除菜单 ()
隐藏加白菜单 ()
隐藏加黑菜单 ()
隐藏封停菜单 ()
隐藏踢掉菜单 ()
显示添加菜单 ()
隐藏白名单菜单 ()
显示黑名单菜单 ()
隐藏销售员菜单 ()
隐藏新软件菜单 ()
隐藏可添加卡类型 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 5)
显示复制卡密菜单 ()
显示复制整行菜单 ()
显示删除菜单 ()
显示加白菜单 ()
显示加黑菜单 ()
显示封停菜单 ()
显示踢掉菜单 ()
隐藏添加菜单 ()
显示解绑菜单 ()
.判断 (列表操作类型 ＝ 6)
显示复制卡密菜单 ()
显示复制整行菜单 ()
显示删除菜单 ()
显示加白菜单 ()
显示加黑菜单 ()
显示封停菜单 ()
显示踢掉菜单 ()
隐藏添加菜单 ()
隐藏解绑菜单 ()
.判断 (列表操作类型 ＝ 7)
隐藏删除菜单 ()
隐藏添加菜单 ()
隐藏踢掉菜单 ()
隐藏封停菜单 ()
隐藏加黑菜单 ()
隐藏加白菜单 ()
隐藏复制卡密菜单 ()
显示复制整行菜单 ()
隐藏解绑菜单 ()
.默认
.判断结束
.子程序 _主窗口_创建完毕
主窗口.高度 ＝ 600
主窗口.宽度 ＝ 1067
托盘提示.创建 (主窗口.取窗口句柄 (), #托盘图标, “JJK企业版网络验证系统”)
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “服务器已启动”, 1)
托盘提示.挂接事件 (&托盘事件)
初始化jjk ()
.子程序 初始化jjk
橙色 ()
初始化标签3 ()
初始化皮肤列表 ()
' 统计卡密数量 ()
刷新标签信息 ()
批量读取配置 ()
_按钮4_被单击 ()
初始化列表框2操作参数 ()
载入监控日志 ()
.子程序 初始化标签3
主窗口.标签3.标题 ＝ 主标题
主窗口.标签3.宽度 ＝ 主窗口.宽度
.子程序 初始化列表框2操作参数
初始化组合框2 ()
初始化组合框3 ()
初始化组合框4 ()
初始化组合框5 ()
初始化组合框6 ()
初始化组合框7 ()
初始化组合框8 ()
初始化组合框9 ()
初始化组合框10 ()
初始化组合框11 ()
初始化卡密列表格式 ()
.子程序 批量保存配置
批量_编辑框_保存配置 (主窗口, 取运行目录 () ＋ “\jjk企业版网络验证系统\服务器配置\服务器配置.ini”, “监控”)
批量_选择框_保存配置 (主窗口, 取运行目录 () ＋ “\jjk企业版网络验证系统\服务器配置\服务器配置.ini”)
.子程序 批量读取配置
批量_编辑框_读取配置 (主窗口, 取运行目录 () ＋ “\jjk企业版网络验证系统\服务器配置\服务器配置.ini”)
批量_选择框_读取配置 (主窗口, 取运行目录 () ＋ “\jjk企业版网络验证系统\服务器配置\服务器配置.ini”)
.子程序 载入监控日志
_选择框1_被单击 ()
.子程序 _全选_被选择
.局部变量 i, 整数型
.如果真 (主窗口.选择夹1.现行子夹 ＝ 0)
.如果 (列表操作类型 ＝ 7)
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
.判断开始 (主窗口.超级列表框1.取当前状态图片 (i) ＝ 1)
主窗口.超级列表框1.置状态图片 (i, 0)
.判断 (主窗口.超级列表框1.取当前状态图片 (i) ＝ 0)
主窗口.超级列表框1.置状态图片 (i, 1)
.默认
.判断结束
i ＝ i ＋ 1
.计次循环尾 ()
.否则
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
主窗口.超级列表框1.选择表项 (i)
i ＝ i ＋ 1
.计次循环尾 ()
.如果结束
.如果真结束
.如果真 (主窗口.选择夹1.现行子夹 ＝ 1)
.计次循环首 (主窗口.超级列表框2.取表项数 (), )
主窗口.超级列表框2.选择表项 (i)
i ＝ i ＋ 1
.计次循环尾 ()
.如果真结束
.子程序 _删除_被选择
.局部变量 i, 整数型
.局部变量 组, 整数型, , "0"
.局部变量 个数, 整数型
.局部变量 软件版本, 文本型
.局部变量 卡密, 文本型
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.判断开始 (选择夹1.现行子夹 ＝ 0)
.判断开始 (列表操作类型 ＝ 5)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 超级列表框1.取标题 (组 [i], 1)
软件名 ＝ 超级列表框1.取标题 (组 [i], 4)
软件类型 ＝ 超级列表框1.取标题 (组 [i], 5)
软件版本 ＝ 超级列表框1.取标题 (组 [i], 6)
.判断开始 (超级列表框1.取标题 (组 [i], 17) ＝ “已封停”)
删除已封停卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框1.取标题 (组 [i], 17) ＝ “已到期”)
删除已到期卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框1.取标题 (组 [i], 17) ＝ “已使用”)
删除已使用卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框1.取标题 (组 [i], 17) ＝ “未使用”)
删除未使用卡密 (卡密, 软件名, 软件类型, 软件版本)
.默认
.判断结束
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
.计次循环尾 ()
刷新标签信息 ()
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
个数 ＝ 取数组成员数 (组)
i ＝ 个数
.计次循环首 (i, )
主窗口.超级列表框1.删除表项 (组 [i])
i ＝ i － 1
.计次循环尾 ()
i ＝ 0
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
主窗口.超级列表框1.置标题 (i, 0, 到文本 (i ＋ 1))
i ＝ i ＋ 1
.计次循环尾 ()
.默认
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
个数 ＝ 取数组成员数 (组)
i ＝ 个数
.计次循环首 (i, )
主窗口.超级列表框1.删除表项 (组 [i])
i ＝ i － 1
.计次循环尾 ()
i ＝ 0
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
主窗口.超级列表框1.置标题 (i, 0, 到文本 (i ＋ 1))
i ＝ i ＋ 1
.计次循环尾 ()
.判断开始 (列表操作类型 ＝ 0)
保存卡类型配置 ()
.默认
.判断结束
.判断结束
.判断 (选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 超级列表框2.取标题 (组 [i], 1)
软件名 ＝ 超级列表框2.取标题 (组 [i], 4)
软件类型 ＝ 超级列表框2.取标题 (组 [i], 5)
软件版本 ＝ 超级列表框2.取标题 (组 [i], 6)
.判断开始 (超级列表框2.取标题 (组 [i], 17) ＝ “已封停”)
删除已封停卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框2.取标题 (组 [i], 17) ＝ “已到期”)
删除已到期卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框2.取标题 (组 [i], 17) ＝ “已使用”)
删除已使用卡密 (卡密, 软件名, 软件类型, 软件版本)
.判断 (超级列表框2.取标题 (组 [i], 17) ＝ “未使用”)
删除未使用卡密 (卡密, 软件名, 软件类型, 软件版本)
.默认
.判断结束
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
.计次循环尾 ()
刷新标签信息 ()
.默认
.判断结束
.子程序 显示加白菜单
加白.可视 ＝ 真
.子程序 隐藏加白菜单
加白.可视 ＝ 假
.子程序 显示加黑菜单
加黑.可视 ＝ 真
.子程序 隐藏加黑菜单
加黑.可视 ＝ 假
.子程序 显示封停菜单
封停.可视 ＝ 真
.子程序 隐藏封停菜单
封停.可视 ＝ 假
.子程序 显示踢掉菜单
踢掉.可视 ＝ 真
.子程序 隐藏踢掉菜单
踢掉.可视 ＝ 假
.子程序 显示可添加卡类型
卡类型.可视 ＝ 真
.子程序 隐藏可添加卡类型
卡类型.可视 ＝ 假
.子程序 隐藏添加菜单
添加.可视 ＝ 假
.子程序 显示添加菜单
添加.可视 ＝ 真
.子程序 隐藏销售员菜单
销售员.可视 ＝ 假
.子程序 显示销售员菜单
销售员.可视 ＝ 真
.子程序 隐藏新软件菜单
软件.可视 ＝ 假
.子程序 显示新软件菜单
软件.可视 ＝ 真
.子程序 隐藏黑名单菜单
黑名单.可视 ＝ 假
.子程序 显示黑名单菜单
黑名单.可视 ＝ 真
.子程序 隐藏白名单菜单
白名单.可视 ＝ 假
.子程序 显示白名单菜单
白名单.可视 ＝ 真
.子程序 隐藏删除菜单
删除.可视 ＝ 假
.子程序 显示删除菜单
删除.可视 ＝ 真
.子程序 隐藏复制卡密菜单
复制卡密.可视 ＝ 假
.子程序 显示复制卡密菜单
复制卡密.可视 ＝ 真
.子程序 隐藏复制整行菜单
复制整行.可视 ＝ 假
.子程序 显示复制整行菜单
复制整行.可视 ＝ 真
.子程序 隐藏解绑菜单
解绑.可视 ＝ 假
.子程序 显示解绑菜单
解绑.可视 ＝ 真
.子程序 _按钮3_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “卡类型列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化卡类型列表格式 ()
读取卡类型配置 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮4_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “销售员列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化销售员列表格式 ()
读取销售员配置 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮5_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “软件列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化软件列表格式 ()
读取软件配置 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮8_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “白名单列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化白名单列表格式 ()
读取白名单配置 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮9_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “黑名单列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化黑名单列表格式 ()
读取黑名单配置 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮10_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “在线列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化在线列表格式 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮7_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “试用列表”, 1)
主窗口.超级列表框1.是否有检查框 ＝ 假
初始化试用列表格式 ()
刷新菜单状态 ()
刷新标签信息 ()
.子程序 _按钮6_被单击
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
.局部变量 卡类型名称, 文本型
.局部变量 时间, 文本型
.局部变量 软件名, 文本型
.局部变量 软件版本, 文本型
.局部变量 价格, 文本型
.局部变量 附属性, 文本型
.局部变量 绑机数量, 文本型
.局部变量 备注, 文本型
.局部变量 生成信息, 文本型
.局部变量 生成卡密, 文本型
.局部变量 软件类型, 文本型
.局部变量 所属销售员, 文本型
.局部变量 选中, 整数型
.如果真 (列表操作类型 ≠ 7)
初始化生成列表格式 ()
读取卡类型配置A ()
.如果真结束
.如果真 (列表操作类型 ＝ 7)
主窗口.按钮6.禁止 ＝ 真
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
.如果真 (主窗口.超级列表框1.取当前状态图片 (i) ＝ 1)
所属销售员 ＝ 主窗口.超级列表框1.取标题 (i, 12)
.如果真 (所属销售员 ＝ “”)
信息框 (“请选择销售员！”, 0, “JJK企业版网络验证系统”, )
主窗口.按钮6.禁止 ＝ 假
返回 ()
.如果真结束
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
i ＝ 0
.计次循环首 (主窗口.超级列表框1.取表项数 (), )
.如果真 (主窗口.超级列表框1.取当前状态图片 (i) ＝ 1)
选中 ＝ 选中 ＋ 1
卡类型名称 ＝ 主窗口.超级列表框1.取标题 (i, 3)
时间 ＝ 到文本 (取现行时间 ())
软件名 ＝ 主窗口.超级列表框1.取标题 (i, 5)
软件类型 ＝ 主窗口.超级列表框1.取标题 (i, 6)
软件版本 ＝ 主窗口.超级列表框1.取标题 (i, 7)
价格 ＝ 主窗口.超级列表框1.取标题 (i, 8)
附属性 ＝ 主窗口.超级列表框1.取标题 (i, 9)
绑机数量 ＝ 主窗口.超级列表框1.取标题 (i, 10)
备注 ＝ 主窗口.超级列表框1.取标题 (i, 11)
所属销售员 ＝ 主窗口.超级列表框1.取标题 (i, 12)
生成卡密 ＝ “”
生成信息 ＝ 卡类型名称 ＋ #换行符 ＋ 时间 ＋ #换行符 ＋ 软件名 ＋ #换行符 ＋ 软件类型 ＋ #换行符 ＋ 软件版本 ＋ #换行符 ＋ 价格 ＋ #换行符 ＋ 附属性 ＋ #换行符 ＋ 绑机数量 ＋ #换行符 ＋ 备注 ＋ #换行符 ＋ 所属销售员 ＋ #换行符 ＋ “====================” ＋ #换行符
.计次循环首 (到整数 (主窗口.编辑框1.内容), )
生成卡密 ＝ 生成卡密 ＋ 生成随机卡密 (i) ＋ #换行符
.计次循环尾 ()
生成卡密 ＝ 生成信息 ＋ 生成卡密
加入成员 (组, 生成卡密)
写到文件 (取运行目录 () ＋ “\生成的卡密\” ＋ 到文本 (i ＋ 1) ＋ “-” ＋ 到文本 (取现行时间 ()) ＋ “.txt”, 到字节集 (生成卡密))
保存未使用卡密数量 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 到文本 (到整数 (主窗口.编辑框1.内容)))
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
.如果真 (取数组成员数 (组) ＞ 0)
保存已生成的卡密 (组)
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “卡密已生成完毕，请打开目录文件夹生成的卡密查看！”, 1)
刷新标签信息 ()
初始化生成列表格式 ()
读取卡类型配置A ()
初始化列表框2操作参数 ()
清除数组 (全_指定未使用卡密总数)
清除数组 (全_指定已使用卡密总数)
清除数组 (全_指定已到期卡密总数)
清除数组 (全_指定已封停卡密总数)
.如果真结束
.如果真结束
刷新菜单状态 ()
主窗口.按钮6.禁止 ＝ 假
返回 ()
.子程序 _编辑框15_失去焦点
主窗口.超级列表框1.置标题 (集表项索引, 集列索引, 主窗口.编辑框15.内容)
主窗口.编辑框15.可视 ＝ 假
.子程序 _超级列表框1_右键单击表项
主窗口.超级列表框1.获取焦点 ()
弹出菜单 (主窗口.可执行, , )
.子程序 _超级列表框1_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项索引, 整数型
.局部变量 列索引, 整数型
.局部变量 矩形, 匿名结构_2
调试输出 (横向位置, 纵向位置, 功能键状态)
取表项行列索引 (主窗口.超级列表框1, 横向位置, 纵向位置, 表项索引, 列索引)
.如果真 (表项索引 ≥ 0)
.如果真 (列表操作类型 ＝ 0 或 列表操作类型 ＝ 1 或 列表操作类型 ＝ 2 或 列表操作类型 ＝ 3 或 列表操作类型 ＝ 4 或 列表操作类型 ＝ 7)
.判断开始 (列表操作类型 ＝ 1 且 列索引 ＝ 12 或 列表操作类型 ＝ 1 且 列索引 ＝ 13 或 列表操作类型 ＝ 1 且 列索引 ＝ 14)
.判断开始 (列索引 ＝ 12)
初始化组合框12 (1)
.判断 (列索引 ＝ 13)
初始化组合框12 (4)
.判断 (列索引 ＝ 14)
初始化组合框12 (5)
.默认
.判断结束
主窗口.组合框12.可视 ＝ 真
主窗口.组合框12.内容 ＝ 主窗口.超级列表框1.取标题 (表项索引, 列索引)
主窗口.组合框12.获取焦点 ()
主窗口.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (主窗口.超级列表框1, 表项索引, 列索引)
组合框12.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
组合框12.高度 ＝ 16
组合框12.左边 ＝ 矩形.匿名成员_1 ＋ 10
组合框12.顶边 ＝ 矩形.匿名成员_2 ＋ 34
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.判断 (列表操作类型 ＝ 0 且 列索引 ＝ 5 或 列表操作类型 ＝ 0 且 列索引 ＝ 6 或 列表操作类型 ＝ 7 且 列索引 ＝ 12)
.判断开始 (列索引 ＝ 5)
初始化组合框12 (1)
.判断 (列索引 ＝ 6)
初始化组合框12 (5)
.判断 (列索引 ＝ 12)
初始化组合框12 (1, 表项索引)
.默认
.判断结束
主窗口.组合框12.可视 ＝ 真
主窗口.组合框12.内容 ＝ 主窗口.超级列表框1.取标题 (表项索引, 列索引)
主窗口.组合框12.获取焦点 ()
主窗口.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (主窗口.超级列表框1, 表项索引, 列索引)
组合框12.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
组合框12.高度 ＝ 16
组合框12.左边 ＝ 矩形.匿名成员_1 ＋ 10
组合框12.顶边 ＝ 矩形.匿名成员_2 ＋ 34
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.判断 (列表操作类型 ＝ 7)
返回 ()
.默认
主窗口.编辑框15.可视 ＝ 真
主窗口.编辑框15.内容 ＝ 主窗口.超级列表框1.取标题 (表项索引, 列索引)
主窗口.编辑框15.获取焦点 ()
主窗口.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (主窗口.超级列表框1, 表项索引, 列索引)
编辑框15.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
编辑框15.高度 ＝ 16
编辑框15.左边 ＝ 矩形.匿名成员_1 ＋ 8
编辑框15.顶边 ＝ 矩形.匿名成员_2 ＋ 34
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.判断结束
.如果真结束
.如果真结束
返回 ()
.子程序 _刷新_被选择
.局部变量 索引, 整数型
.判断开始 (选择夹1.现行子夹 ＝ 1)
_组合框2_列表项被选择 ()
.判断 (列表操作类型 ＝ 0)
_按钮3_被单击 ()
.判断 (列表操作类型 ＝ 1)
_按钮4_被单击 ()
.判断 (列表操作类型 ＝ 2)
_按钮5_被单击 ()
.判断 (列表操作类型 ＝ 3)
_按钮8_被单击 ()
.判断 (列表操作类型 ＝ 4)
_按钮9_被单击 ()
.判断 (列表操作类型 ＝ 5)
_按钮10_被单击 ()
.判断 (列表操作类型 ＝ 6)
_按钮7_被单击 ()
.判断 (列表操作类型 ＝ 7)
初始化生成列表格式 ()
读取卡类型配置A ()
.默认
.判断结束
.子程序 托盘事件
.参数 操作类型, 整数型
.如果真 (操作类型 ＝ #托盘事件_双击鼠标左键 且 窗口_是否最小化 (主窗口.取窗口句柄 ()))
窗口_还原 (主窗口.取窗口句柄 ())
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “窗口已恢复”, 1)
.如果真结束
.如果真 (操作类型 ＝ #托盘事件_按下鼠标右键)
弹出托盘菜单 (托盘)
.如果真结束
.如果真 (操作类型 ＝ #托盘事件_按下鼠标左键)
窗口_还原 (主窗口.取窗口句柄 ())
.如果真结束
.子程序 _按钮17_被单击
窗口_最小化 (主窗口.取窗口句柄 ())
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “窗口已最小化到托盘”, 1)
.子程序 _按钮18_被单击
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “JJK企业版网络验证系统已退出”, 1)
批量保存配置 ()
结束 ()
.子程序 _关闭JJK_被选择
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “JJK企业版网络验证系统已退出”, 1)
结束 ()
.子程序 初始化皮肤列表
主窗口.组合框1.加入项目 (“紫色”, 0)
主窗口.组合框1.加入项目 (“蓝色”, 1)
主窗口.组合框1.加入项目 (“橙色”, 2)
主窗口.组合框1.现行选中项 ＝ 0
.子程序 _组合框1_列表项被选择
.判断开始 (主窗口.组合框1.现行选中项 ＝ 0)
橙色 ()
.判断 (主窗口.组合框1.现行选中项 ＝ 1)
蓝色 ()
.判断 (主窗口.组合框1.现行选中项 ＝ 2)
紫色 ()
.默认
.判断结束
.子程序 保存已生成的卡密
.参数 组, 文本型, 数组
.局部变量 i, 整数型
.局部变量 卡密组, 文本型, , "0"
.局部变量 生成信息组, 文本型, , "0"
.局部变量 生成卡密组, 文本型, , "0"
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.局部变量 软件版本, 文本型
.局部变量 j, 整数型
.局部变量 卡密属性, 文本型
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密组 ＝ 分割文本 (组 [i], “====================”, )
生成信息组 ＝ 分割文本 (卡密组 [1], #换行符, )
软件名 ＝ 生成信息组 [3]
软件类型 ＝ 生成信息组 [4]
软件版本 ＝ 生成信息组 [5]
生成卡密组 ＝ 分割文本 (卡密组 [2], #换行符, )
卡密属性 ＝ 拼接数组文本 (生成信息组, “&&”)
删除成员 (生成卡密组, 1, )
.如果真 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, ) ＝ “”)
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, “未使用卡密总数”, “0”)
.如果真结束
j ＝ 0
.计次循环首 (取数组成员数 (生成卡密组), )
j ＝ j ＋ 1
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”, 软件名 ＋ “&&” ＋ 软件类型 ＋ “&&” ＋ 软件版本, 生成卡密组 [j], 卡密属性)
.计次循环尾 ()
.计次循环尾 ()
.子程序 拼接数组文本, 文本型
.参数 组, 文本型, 数组
.参数 拼接符, 文本型
.局部变量 i, 整数型
.局部变量 retstr, 文本型
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
.如果 (i ＞ 1)
retstr ＝ retstr ＋ 拼接符 ＋ 组 [i]
.否则
retstr ＝ retstr ＋ 组 [i]
.如果结束
.计次循环尾 ()
返回 (retstr)
.子程序 添加卡类型
.参数 卡类型, 文本型, , “天|周|半月|月|季|半年|年|VIP”
.参数 时间, 文本型, , “24|168|360|720|2880|4320|8640|100000”
.参数 价格, 文本型
.参数 序, 文本型, 可空
.局部变量 索引, 整数型
.局部变量 i, 整数型
.局部变量 添加项, 文本型
索引 ＝ 主窗口.超级列表框1.取表项数 ()
.如果真 (是否为空 (序))
序 ＝ “1”
.如果真结束
.如果真 (取数据库软件参数B (序, 1) ＝ “不存在此软件”)
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “请先添加新软件！”, 1)
返回 ()
.如果真结束
主窗口.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框1.置标题 (索引, 1, “JJK”)
主窗口.超级列表框1.置标题 (索引, 2, “JJK”)
主窗口.超级列表框1.置标题 (索引, 3, 卡类型 ＋ “卡”)
主窗口.超级列表框1.置标题 (索引, 4, 时间)
主窗口.超级列表框1.置标题 (索引, 5, 取数据库软件参数B (序, 1))
主窗口.超级列表框1.置标题 (索引, 6, 取数据库软件参数B (序, 5))
主窗口.超级列表框1.置标题 (索引, 7, 取数据库软件参数B (序, 4))
主窗口.超级列表框1.置标题 (索引, 8, 价格)
主窗口.超级列表框1.置标题 (索引, 9, “JJK企业版”)
主窗口.超级列表框1.置标题 (索引, 10, “1”)
主窗口.超级列表框1.置标题 (索引, 11, “欢迎使用JJK企业版网络验证”)
i ＝ 1
.计次循环首 (主窗口.超级列表框1.取列数 () － 1, )
添加项 ＝ 添加项 ＋ “&&” ＋ 主窗口.超级列表框1.取标题 (索引, i)
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.超级列表框1.删除表项 (索引)
是否添加已存在项 (添加项)
保存卡类型配置 ()
.子程序 初始化组合框12
.参数 索引, 整数型
.参数 表项索引, 整数型, 可空
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 相同, 逻辑型
.判断开始 (列表操作类型 ＝ 0)
组合框12.清空 ()
.计次循环首 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, )), )
i ＝ i ＋ 1
j ＝ 0
.计次循环首 (主窗口.组合框12.取项目数 (), )
.如果真 (取数据库软件参数B (到文本 (i), 索引) ＝ 主窗口.组合框12.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框12.加入项目 (取数据库软件参数B (到文本 (i), 索引), 0)
.如果真结束
相同 ＝ 假
.计次循环尾 ()
.判断 (列表操作类型 ＝ 7)
组合框12.清空 ()
.计次循环首 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”, “销售员”, “销售员总数”, )), )
i ＝ i ＋ 1
.如果真 (寻找文本 (取数据库销售员参数A (到文本 (i), 11), 主窗口.超级列表框1.取标题 (表项索引, 3), , 假) ≠ -1 且 取数据库销售员参数A (到文本 (i), 12) ＝ 主窗口.超级列表框1.取标题 (表项索引, 5) 且 取数据库销售员参数A (到文本 (i), 13) ＝ 主窗口.超级列表框1.取标题 (表项索引, 7) 且 取数据库销售员参数A (到文本 (i), 14) ＝ 主窗口.超级列表框1.取标题 (表项索引, 6))
j ＝ 0
.计次循环首 (主窗口.组合框12.取项目数 (), )
.如果真 (取数据库销售员参数A (到文本 (i), 索引) ＝ 主窗口.组合框12.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框12.加入项目 (取数据库销售员参数A (到文本 (i), 索引), 0)
.如果真结束
相同 ＝ 假
.如果真结束
.计次循环尾 ()
.判断 (列表操作类型 ＝ 1)
组合框12.清空 ()
.计次循环首 (到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, )), )
i ＝ i ＋ 1
j ＝ 0
.计次循环首 (主窗口.组合框12.取项目数 (), )
.如果真 (取数据库软件参数B (到文本 (i), 索引) ＝ 主窗口.组合框12.取项目文本 (j))
相同 ＝ 真
跳出循环 ()
.如果真结束
j ＝ j ＋ 1
.计次循环尾 ()
.如果真 (取反 (相同))
主窗口.组合框12.加入项目 (取数据库软件参数B (到文本 (i), 索引), 0)
.如果真结束
相同 ＝ 假
' 主窗口.组合框12.加入项目 (取数据库软件参数B (到文本 (i), 索引), 0)
.计次循环尾 ()
.默认
.判断结束
.子程序 _天卡_被选择
添加卡类型 (“天”, “24”, “10”)
.子程序 _周卡_被选择
添加卡类型 (“周”, “168”, “50”)
.子程序 _半月卡_被选择
添加卡类型 (“半月”, “360”, “70”)
.子程序 _月卡_被选择
添加卡类型 (“月”, “720”, “100”)
.子程序 _季卡_被选择
添加卡类型 (“季”, “2880”, “200”)
.子程序 _半年卡_被选择
添加卡类型 (“半年”, “4320”, “300”)
.子程序 _年卡_被选择
添加卡类型 (“年”, “8640”, “400”)
.子程序 _VIP卡_被选择
添加卡类型 (“VIP”, “100000”, “500”)
.子程序 添加销售员
.参数 销售员级别, 文本型, , “S级|A级|B级|C级|D级”
.参数 余额, 文本型, , “999999|50000|25000|10000|5000”
.参数 可造卡类型, 文本型, , “天卡|周卡|半月卡|月卡|季卡|半年卡|年卡|VIP卡”
.参数 序, 文本型, 可空
.局部变量 索引, 整数型
.局部变量 i, 整数型
.局部变量 添加项, 文本型
.如果真 (是否为空 (序))
序 ＝ “1”
.如果真结束
.如果真 (取数据库软件参数B (序, 1) ＝ “不存在此软件”)
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “不存在此软件，请先添加至少一个新软件！”, 1)
返回 ()
.如果真结束
索引 ＝ 主窗口.超级列表框1.取表项数 ()
主窗口.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框1.置标题 (索引, 1, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 2, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 3, “jjk”)
主窗口.超级列表框1.置标题 (索引, 4, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 5, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 6, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 7, “jjk”)
主窗口.超级列表框1.置标题 (索引, 8, 文本_取随机数字 (8, ))
主窗口.超级列表框1.置标题 (索引, 9, 销售员级别)
主窗口.超级列表框1.置标题 (索引, 10, 余额)
主窗口.超级列表框1.置标题 (索引, 11, 可造卡类型)
主窗口.超级列表框1.置标题 (索引, 12, 取数据库软件参数B (序, 1))
主窗口.超级列表框1.置标题 (索引, 13, 取数据库软件参数B (序, 4))
主窗口.超级列表框1.置标题 (索引, 14, 取数据库软件参数B (序, 5))
主窗口.超级列表框1.置标题 (索引, 15, 取指定已使用卡密总数 (取数据库软件参数B (序, 1), 取数据库软件参数B (序, 4), 取数据库软件参数B (序, 5), ))
主窗口.超级列表框1.置标题 (索引, 16, 取指定未使用卡密总数 (取数据库软件参数B (序, 1), 取数据库软件参数B (序, 4), 取数据库软件参数B (序, 5), ))
主窗口.超级列表框1.置标题 (索引, 17, 取指定已到期卡密总数 (取数据库软件参数B (序, 1), 取数据库软件参数B (序, 4), 取数据库软件参数B (序, 5), ))
主窗口.超级列表框1.置标题 (索引, 18, 取指定已封停卡密总数 (取数据库软件参数B (序, 1), 取数据库软件参数B (序, 4), 取数据库软件参数B (序, 5), ))
主窗口.超级列表框1.置标题 (索引, 19, “0”)
i ＝ 1
.计次循环首 (主窗口.超级列表框1.取列数 () － 1, )
添加项 ＝ 添加项 ＋ “&&” ＋ 主窗口.超级列表框1.取标题 (索引, i)
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.超级列表框1.删除表项 (索引)
是否添加已存在项 (添加项)
保存销售员配置 ()
.子程序 _S级_被选择
添加销售员 (“S级”, “999999”, “天卡|周卡|半月卡|月卡|季卡|半年卡|年卡|VIP卡”)
.子程序 _A级_被选择
添加销售员 (“A级”, “50000”, “天卡|周卡|半月卡|月卡|季卡”)
.子程序 _B级_被选择
添加销售员 (“B级”, “25000”, “天卡|周卡|半月卡|月卡”)
.子程序 _C级_被选择
添加销售员 (“C级”, “10000”, “天卡|周卡|半月卡”)
.子程序 _D级_被选择
添加销售员 (“D级”, “5000”, “天卡|周卡”)
.子程序 _按钮11_被单击
.如果真 (信息框 (“是否确认清空数据库！”, 1, “JJK企业版网络验证系统”, ) ＝ #确认钮)
清空数据库 ()
.如果真结束
_刷新_被选择 ()
.子程序 清空数据库
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\黑名单\黑名单配置.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\白名单\白名单配置.ini”)
' 删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”)
托盘提示.气泡提示 (“JJK企业版网络验证系统”, “数据库已清空！”, 1)
.子程序 _选择框1_被单击
.如果 (主窗口.选择框1.选中)
主窗口.监控.宽度 ＝ 332
主窗口.监控.高度 ＝ 600
主窗口.监控.左边 ＝ 1067
主窗口.监控.顶边 ＝ 0
主窗口.宽度 ＝ 1067 ＋ 332
全_监控 ＝ 真
.否则
主窗口.宽度 ＝ 1067
全_监控 ＝ 假
.如果结束
.子程序 _超级列表框1_失去焦点
.判断开始 (列表操作类型 ＝ 0)
保存卡类型配置 ()
.判断 (列表操作类型 ＝ 1)
保存销售员配置 ()
.判断 (列表操作类型 ＝ 2)
保存软件配置 ()
.判断 (列表操作类型 ＝ 3)
保存白名单配置 ()
.判断 (列表操作类型 ＝ 4)
保存黑名单配置 ()
.默认
.判断结束
.子程序 _超级列表框1_获得焦点
.子程序 _白名单_被选择
添加白名单 (, , , , , , )
保存白名单配置 ()
.子程序 添加白名单
.参数 限制类型, 文本型, 可空
.参数 限制原因, 文本型, 可空
.参数 卡密, 文本型, 可空
.参数 IP地址, 文本型, 可空
.参数 所在省份, 文本型, 可空
.参数 唯一机器码, 文本型, 可空
.参数 加白时长, 文本型, 可空
.局部变量 索引, 整数型
.局部变量 i, 整数型
.局部变量 添加项, 文本型
.如果真 (是否为空 (限制类型))
限制类型 ＝ “自定义添加”
.如果真结束
.如果真 (是否为空 (限制原因))
限制原因 ＝ “限制原因”
.如果真结束
.如果真 (是否为空 (卡密))
卡密 ＝ “卡密”
.如果真结束
.如果真 (是否为空 (IP地址))
IP地址 ＝ “IP地址”
.如果真结束
.如果真 (是否为空 (所在省份))
所在省份 ＝ “所在省份”
.如果真结束
.如果真 (是否为空 (唯一机器码))
唯一机器码 ＝ “唯一机器码”
.如果真结束
.如果真 (是否为空 (加白时长))
加白时长 ＝ “720小时”
.如果真结束
索引 ＝ 主窗口.超级列表框1.取表项数 ()
主窗口.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框1.置标题 (索引, 1, 限制类型)
主窗口.超级列表框1.置标题 (索引, 2, 限制原因)
主窗口.超级列表框1.置标题 (索引, 3, 卡密)
主窗口.超级列表框1.置标题 (索引, 4, IP地址)
主窗口.超级列表框1.置标题 (索引, 5, 所在省份)
主窗口.超级列表框1.置标题 (索引, 6, 唯一机器码)
主窗口.超级列表框1.置标题 (索引, 7, 到文本 (取现行时间 ()))
主窗口.超级列表框1.置标题 (索引, 8, 加白时长)
i ＝ 1
.计次循环首 (主窗口.超级列表框1.取列数 () － 1, )
添加项 ＝ 添加项 ＋ “&&” ＋ 主窗口.超级列表框1.取标题 (索引, i)
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.超级列表框1.删除表项 (索引)
是否添加已存在项 (添加项)
.子程序 _黑名单_被选择
添加黑名单 (, , , , , , )
保存黑名单配置 ()
.子程序 添加黑名单
.参数 限制类型, 文本型, 可空
.参数 限制原因, 文本型, 可空
.参数 卡密, 文本型, 可空
.参数 IP地址, 文本型, 可空
.参数 所在省份, 文本型, 可空
.参数 唯一机器码, 文本型, 可空
.参数 加黑时长, 文本型, 可空
.局部变量 索引, 整数型
.局部变量 i, 整数型
.局部变量 添加项, 文本型
.如果真 (是否为空 (限制类型))
限制类型 ＝ “自定义添加”
.如果真结束
.如果真 (是否为空 (限制原因))
限制原因 ＝ “限制原因”
.如果真结束
.如果真 (是否为空 (卡密))
卡密 ＝ “卡密”
.如果真结束
.如果真 (是否为空 (IP地址))
IP地址 ＝ “IP地址”
.如果真结束
.如果真 (是否为空 (所在省份))
所在省份 ＝ “所在省份”
.如果真结束
.如果真 (是否为空 (唯一机器码))
唯一机器码 ＝ “唯一机器码”
.如果真结束
.如果真 (是否为空 (加黑时长))
加黑时长 ＝ “720小时”
.如果真结束
索引 ＝ 主窗口.超级列表框1.取表项数 ()
主窗口.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框1.置标题 (索引, 1, 限制类型)
主窗口.超级列表框1.置标题 (索引, 2, 限制原因)
主窗口.超级列表框1.置标题 (索引, 3, 卡密)
主窗口.超级列表框1.置标题 (索引, 4, IP地址)
主窗口.超级列表框1.置标题 (索引, 5, 所在省份)
主窗口.超级列表框1.置标题 (索引, 6, 唯一机器码)
主窗口.超级列表框1.置标题 (索引, 7, 到文本 (取现行时间 ()))
主窗口.超级列表框1.置标题 (索引, 8, 加黑时长)
i ＝ 1
.计次循环首 (主窗口.超级列表框1.取列数 () － 1, )
添加项 ＝ 添加项 ＋ “&&” ＋ 主窗口.超级列表框1.取标题 (索引, i)
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.超级列表框1.删除表项 (索引)
是否添加已存在项 (添加项)
.子程序 刷新标签信息
.参数 版本, 文本型, 可空
.参数 在线数量, 文本型, 可空
.参数 所有卡密, 文本型, 可空
.参数 已使用, 文本型, 可空
.参数 未使用, 文本型, 可空
.参数 已到期, 文本型, 可空
.参数 黑名单, 文本型, 可空
.参数 白名单, 文本型, 可空
.参数 已封停, 文本型, 可空
.参数 到期时间, 文本型, 可空
.局部变量 刷新内容, 文本型
.局部变量 卡类型总数, 文本型
.局部变量 销售员总数, 文本型
.局部变量 软件总数, 文本型
统计卡密数量B ()
.如果真 (是否为空 (版本))
版本 ＝ “jjk验证 v20”
.如果真结束
.如果真 (是否为空 (在线数量))
在线数量 ＝ 取已登录卡密总数 ()
.如果真结束
.如果真 (是否为空 (已使用))
已使用 ＝ 取已使用卡密总数 ()
.如果真结束
.如果真 (是否为空 (未使用))
未使用 ＝ 取未使用卡密总数 ()
.如果真结束
.如果真 (是否为空 (已到期))
已到期 ＝ 取已到期卡密总数 ()
.如果真结束
.如果真 (是否为空 (黑名单))
黑名单 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\黑名单\黑名单配置.ini”, “黑名单”, “黑名单总数”, )
.如果真结束
.如果真 (是否为空 (白名单))
白名单 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\白名单\白名单配置.ini”, “白名单”, “白名单总数”, )
.如果真结束
.如果真 (是否为空 (已封停))
已封停 ＝ 取已封停卡密总数 ()
.如果真结束
.如果真 (是否为空 (到期时间))
到期时间 ＝ 到文本 (取现行时间 ())
.如果真结束
.如果真 (是否为空 (所有卡密))
所有卡密 ＝ 到文本 (到整数 (已使用) ＋ 到整数 (未使用) ＋ 到整数 (已到期) ＋ 到整数 (已封停))
.如果真结束
卡类型总数 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡类型\卡类型配置.ini”, “卡类型”, “卡类型总数”, )
软件总数 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, )
销售员总数 ＝ 读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\销售员\销售员配置.ini”, “销售员”, “销售员总数”, )
刷新内容 ＝ “ 版本 ” ＋ 版本 ＋ “ 卡类型 ” ＋ 卡类型总数 ＋ “ 软件 ” ＋ 软件总数 ＋ “ 销售员 ” ＋ 销售员总数 ＋ “ 在线 ” ＋ 在线数量 ＋ “ 所有卡 ” ＋ 所有卡密 ＋ “ 已使用 ” ＋ 已使用 ＋ “ 未使用 ” ＋ 未使用 ＋ “ 已到期 ” ＋ 已到期 ＋ “ 黑 ” ＋ 黑名单 ＋ “ 白 ” ＋ 白名单 ＋ “ 封停 ” ＋ 已封停 ＋ “ 到期 ” ＋ 到期时间
主窗口.标签1.标题 ＝ 刷新内容
.子程序 _超级列表框2_右键单击表项
主窗口.超级列表框2.获取焦点 ()
显示删除菜单 ()
显示加白菜单 ()
显示加黑菜单 ()
显示封停菜单 ()
显示踢掉菜单 ()
隐藏添加菜单 ()
刷新标签信息 ()
弹出菜单 (主窗口.可执行, , )
.子程序 _主窗口_将被销毁
批量保存配置 ()
托盘提示.销毁 ()
.子程序 _踢掉_被选择
.局部变量 索引, 整数型, , "0"
.局部变量 卡密, 文本型
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.局部变量 软件版本, 文本型
.局部变量 i, 整数型
.判断开始 (列表操作类型 ＝ 5)
索引 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (索引), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框1.取标题 (索引 [i], 1)
软件名 ＝ 主窗口.超级列表框1.取标题 (索引 [i], 4)
软件类型 ＝ 主窗口.超级列表框1.取标题 (索引 [i], 5)
软件版本 ＝ 主窗口.超级列表框1.取标题 (索引 [i], 6)
删除已登录卡密 (卡密, 软件名, 软件类型, 软件版本)
.计次循环尾 ()
刷新标签信息 (, , , , , , , , , )
_刷新_被选择 ()
.默认
.判断结束
.子程序 _按钮13_被单击
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”)
刷新标签信息 ()
.子程序 _按钮14_被单击
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已登录卡密.ini”)
删除文件 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”)
刷新标签信息 ()
.子程序 _按钮16_被单击
选择夹1.现行子夹 ＝ 4
.子程序 _按钮19_被单击
.局部变量 临时密码, 文本型, 静态
.如果真 (主窗口.编辑框16.内容 ≠ “” 且 主窗口.按钮19.标题 ＝ “锁定”)
临时密码 ＝ 主窗口.编辑框16.内容
主窗口.按钮19.标题 ＝ “解锁”
主窗口.编辑框16.内容 ＝ “”
.如果真结束
.如果真 (主窗口.编辑框16.内容 ≠ “” 且 主窗口.按钮19.标题 ＝ “解锁”)
.如果真 (临时密码 ＝ 主窗口.编辑框16.内容)
主窗口.按钮19.标题 ＝ “锁定”
主窗口.编辑框16.内容 ＝ “”
选择夹1.现行子夹 ＝ 2
.如果真结束
.如果真结束
.子程序 删除指定属性的列表项
.参数 属性, 文本型
.参数 列索引, 整数型
.局部变量 i, 整数型
.局部变量 表项数, 整数型
表项数 ＝ 主窗口.超级列表框2.取表项数 ()
.如果真 (表项数 ＝ 0 或 属性 ＝ “” 或 属性 ＝ “全部”)
返回 ()
.如果真结束
i ＝ 表项数
.计次循环首 (表项数, )
i ＝ i － 1
.如果真 (主窗口.超级列表框2.取标题 (i, 列索引) ≠ 属性 且 主窗口.超级列表框2.取标题 (i, 列索引) ≠ “”)
主窗口.超级列表框2.删除表项 (i)
.如果真结束
.计次循环尾 ()
.子程序 _组合框2_列表项被选择
.局部变量 i, 整数型
.如果真 (主窗口.组合框2.现行选中项 ＝ 0)
主窗口.超级列表框2.全部删除 ()
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”)
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”)
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”)
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”)
.如果真结束
.如果真 (主窗口.组合框2.现行选中项 ＝ 1)
主窗口.超级列表框2.全部删除 ()
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”)
.如果真结束
.如果真 (主窗口.组合框2.现行选中项 ＝ 2)
主窗口.超级列表框2.全部删除 ()
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”)
.如果真结束
.如果真 (主窗口.组合框2.现行选中项 ＝ 3)
主窗口.超级列表框2.全部删除 ()
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”)
.如果真结束
.如果真 (主窗口.组合框2.现行选中项 ＝ 4)
主窗口.超级列表框2.全部删除 ()
载入所有卡密到列表2 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”)
.如果真结束
.判断开始断 (j ＝ 1)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\未使用卡密.ini”
.' 判断 (j ＝ 2)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已使用卡密.ini”
.' 判断 (j ＝ 3)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已到期卡密.ini”
.' 判断 (j ＝ 4)
' 配置路径 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\卡号\已封停卡密.ini”
.默认
.判断结束
.如果真 (主窗口.组合框2.现行选中项 ≥ 0)
删除指定属性的列表项 (主窗口.组合框3.取项目文本 (主窗口.组合框3.现行选中项), 2)
删除指定属性的列表项 (主窗口.组合框4.取项目文本 (主窗口.组合框4.现行选中项), 4)
删除指定属性的列表项 (主窗口.组合框5.取项目文本 (主窗口.组合框5.现行选中项), 5)
删除指定属性的列表项 (主窗口.组合框6.取项目文本 (主窗口.组合框6.现行选中项), 6)
删除指定属性的列表项 (主窗口.组合框7.取项目文本 (主窗口.组合框7.现行选中项), 7)
删除指定属性的列表项 (主窗口.组合框8.取项目文本 (主窗口.组合框8.现行选中项), 8)
删除指定属性的列表项 (主窗口.组合框9.取项目文本 (主窗口.组合框9.现行选中项), 9)
删除指定属性的列表项 (主窗口.组合框10.取项目文本 (主窗口.组合框10.现行选中项), 10)
删除指定属性的列表项 (主窗口.组合框11.取项目文本 (主窗口.组合框11.现行选中项), 11)
i ＝ 0
.计次循环首 (主窗口.超级列表框2.取表项数 (), )
主窗口.超级列表框2.置标题 (i, 0, 到文本 (i ＋ 1))
i ＝ i ＋ 1
.计次循环尾 ()
.如果真结束
.子程序 _组合框3_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框4_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框5_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框6_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框7_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框8_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框9_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框10_列表项被选择
_组合框2_列表项被选择 ()
.子程序 _组合框11_列表项被选择
_组合框2_列表项被选择 ()
.子程序 扣时
.参数 时间, 整数型
.参数 单位, 文本型
.参数 卡密, 文本型
.参数 软件名, 文本型
.参数 软件类型, 文本型
.参数 软件版本, 文本型
.局部变量 激活时间, 日期时间型
.局部变量 时, 整数型
.局部变量 分, 整数型
.局部变量 年, 整数型
.局部变量 月, 整数型
.局部变量 日, 整数型
.局部变量 秒, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 内容, 文本型
.局部变量 i
激活时间 ＝ 到时间 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 11))
年 ＝ 取年份 (激活时间)
月 ＝ 取月份 (激活时间)
日 ＝ 取日 (激活时间)
时 ＝ 取小时 (激活时间)
.如果真 (单位 ＝ “时”)
时 ＝ 时 － 时间
.如果真 (时 ＜ 0)
日 ＝ 日 － 1
时 ＝ 24 ＋ 时
.如果真结束
.如果真结束
分 ＝ 取分钟 (激活时间)
.如果真 (单位 ＝ “分”)
分 ＝ 分 － 时间
.如果真 (分 ＜ 0)
时 ＝ 时 － 1
分 ＝ 60 ＋ 分
.如果真结束
.如果真结束
秒 ＝ 取秒 (激活时间)
激活时间 ＝ 到时间 (到文本 (年) ＋ “年” ＋ 到文本 (月) ＋ “月” ＋ 到文本 (日) ＋ “日” ＋ 到文本 (时) ＋ “时” ＋ 到文本 (分) ＋ “分” ＋ 到文本 (秒) ＋ “秒”)
组 ＝ 分割文本 (取已使用卡密属性 (卡密, 软件名, 软件类型, 软件版本, 0), “&&”, )
组 [11] ＝ 到文本 (激活时间)
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
.如果 (i ＝ 1)
内容 ＝ 内容 ＋ 组 [i]
.否则
内容 ＝ 内容 ＋ “&&” ＋ 组 [i]
.如果结束
.计次循环尾 ()
删除已使用卡密 (卡密, 软件名, 软件类型, 软件版本)
保存已使用卡密 (卡密, 软件名, 软件类型, 软件版本, 内容)
.子程序 _所有卡_被选择
.局部变量 i, 整数型
.局部变量 软件总数, 整数型
软件总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, ))
.计次循环首 (软件总数, )
i ＝ i ＋ 1
添加卡类型 (“天”, “24”, “10”, 到文本 (i))
添加卡类型 (“周”, “168”, “50”, 到文本 (i))
添加卡类型 (“半月”, “360”, “70”, 到文本 (i))
添加卡类型 (“月”, “720”, “100”, 到文本 (i))
添加卡类型 (“季”, “2880”, “200”, 到文本 (i))
添加卡类型 (“半年”, “4320”, “300”, 到文本 (i))
添加卡类型 (“年”, “8640”, “400”, 到文本 (i))
添加卡类型 (“VIP”, “100000”, “500”, 到文本 (i))
.计次循环尾 ()
.子程序 _按钮15_被单击
.子程序 _组合框12_列表项被选择
.如果真 (主窗口.组合框12.内容 ≠ “”)
主窗口.超级列表框1.置标题 (集表项索引, 集列索引, 主窗口.组合框12.内容)
.如果真结束
主窗口.组合框12.可视 ＝ 假
.子程序 _所有销售员_被选择
.局部变量 软件总数, 整数型
.局部变量 i, 整数型
软件总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\软件\软件配置.ini”, “软件”, “软件总数”, ))
.计次循环首 (软件总数, )
i ＝ i ＋ 1
添加销售员 (“S级”, “999999”, “天卡|周卡|半月卡|月卡|季卡|半年卡|年卡|VIP卡”, 到文本 (i))
添加销售员 (“A级”, “50000”, “天卡|周卡|半月卡|月卡|季卡”, 到文本 (i))
添加销售员 (“B级”, “25000”, “天卡|周卡|半月卡|月卡”, 到文本 (i))
添加销售员 (“C级”, “10000”, “天卡|周卡|半月卡”, 到文本 (i))
添加销售员 (“D级”, “5000”, “天卡|周卡”, 到文本 (i))
.计次循环尾 ()
.子程序 _新软件_被选择
.局部变量 time, 日期时间型
time ＝ 取现行时间 ()
添加新软件 (“JJK软件”, “超级玛丽”, 到文本 (取年份 (time)) ＋ “.” ＋ 到文本 (取月份 (time)) ＋ “.” ＋ 到文本 (取日 (time)) ＋ “.” ＋ 到文本 (取小时 (time)), “易语言”)
.子程序 _常用软件_被选择
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “易语言”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “C”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “C++”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “TC”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “按键精灵”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “go”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “Python”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “java”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “vb”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “c#”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “php”)
添加新软件 (“JJK软件”, “DNF”, “2022.1.1.1”, “lua”)
.子程序 添加新软件
.参数 软件名, 文本型
.参数 用途, 文本型
.参数 版本, 文本型
.参数 软件类型, 文本型
.局部变量 索引, 整数型
.局部变量 i, 整数型
.局部变量 添加项, 文本型
索引 ＝ 主窗口.超级列表框1.取表项数 ()
主窗口.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
主窗口.超级列表框1.置标题 (索引, 1, 软件名)
主窗口.超级列表框1.置标题 (索引, 2, 用途)
主窗口.超级列表框1.置标题 (索引, 3, 到文本 (取现行时间 ()))
主窗口.超级列表框1.置标题 (索引, 4, 版本)
主窗口.超级列表框1.置标题 (索引, 5, 软件类型)
主窗口.超级列表框1.置标题 (索引, 6, “0”)
主窗口.超级列表框1.置标题 (索引, 7, “6”)
主窗口.超级列表框1.置标题 (索引, 8, “0”)
主窗口.超级列表框1.置标题 (索引, 9, “0”)
主窗口.超级列表框1.置标题 (索引, 10, “0”)
主窗口.超级列表框1.置标题 (索引, 11, “0”)
主窗口.超级列表框1.置标题 (索引, 12, “0”)
主窗口.超级列表框1.置标题 (索引, 13, “0”)
主窗口.超级列表框1.置标题 (索引, 14, “0”)
主窗口.超级列表框1.置标题 (索引, 15, “0”)
主窗口.超级列表框1.置标题 (索引, 16, “JJK + 123456”)
i ＝ 1
.计次循环首 (主窗口.超级列表框1.取列数 () － 1, )
添加项 ＝ 添加项 ＋ “&&” ＋ 主窗口.超级列表框1.取标题 (索引, i)
i ＝ i ＋ 1
.计次循环尾 ()
主窗口.超级列表框1.删除表项 (索引)
是否添加已存在项 (添加项)
保存软件配置 ()
.子程序 _组合框12_失去焦点
主窗口.组合框12.可视 ＝ 假
.子程序 _加黑_被选择
.局部变量 组, 整数型, , "0"
.局部变量 卡密, 文本型
.局部变量 i, 整数型
.局部变量 唯一机器码, 文本型
.局部变量 IP, 文本型
.局部变量 省份, 文本型
.判断开始 (列表操作类型 ＝ 5)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框1.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框1.取标题 (组 [i], 14)
IP ＝ 主窗口.超级列表框1.取标题 (组 [i], 15)
省份 ＝ 主窗口.超级列表框1.取标题 (组 [i], 16)
添加黑名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
.判断 (主窗口.选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
初始化黑名单列表格式 ()
读取黑名单配置 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框2.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框2.取标题 (组 [i], 14)
IP ＝ 主窗口.超级列表框2.取标题 (组 [i], 15)
省份 ＝ 主窗口.超级列表框2.取标题 (组 [i], 16)
添加黑名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
保存黑名单配置 ()
.判断 (列表操作类型 ＝ 6)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框1.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框1.取标题 (组 [i], 10)
IP ＝ 主窗口.超级列表框1.取标题 (组 [i], 8)
省份 ＝ 主窗口.超级列表框1.取标题 (组 [i], 9)
添加黑名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
.默认
.判断结束
.子程序 _加白_被选择
.局部变量 组, 整数型, , "0"
.局部变量 卡密, 文本型
.局部变量 i, 整数型
.局部变量 唯一机器码, 文本型
.局部变量 IP, 文本型
.局部变量 省份, 文本型
.判断开始 (列表操作类型 ＝ 5)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框1.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框1.取标题 (组 [i], 14)
IP ＝ 主窗口.超级列表框1.取标题 (组 [i], 15)
省份 ＝ 主窗口.超级列表框1.取标题 (组 [i], 16)
添加白名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
.判断 (主窗口.选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
初始化白名单列表格式 ()
读取白名单配置 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框2.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框2.取标题 (组 [i], 14)
IP ＝ 主窗口.超级列表框2.取标题 (组 [i], 15)
省份 ＝ 主窗口.超级列表框2.取标题 (组 [i], 16)
添加白名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
保存白名单配置 ()
.判断 (列表操作类型 ＝ 6)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 主窗口.超级列表框1.取标题 (组 [i], 1)
唯一机器码 ＝ 主窗口.超级列表框1.取标题 (组 [i], 10)
IP ＝ 主窗口.超级列表框1.取标题 (组 [i], 8)
省份 ＝ 主窗口.超级列表框1.取标题 (组 [i], 9)
添加白名单 (“手动添加”, “限制原因”, 卡密, IP, 省份, 唯一机器码, “720小时”)
.计次循环尾 ()
.默认
.判断结束
.子程序 _封停_被选择
.判断开始 (列表操作类型 ＝ 5)
.默认
.判断结束
.子程序 _复制卡密_被选择
.局部变量 组, 整数型, , "0"
.局部变量 i, 整数型
.局部变量 内容, 文本型
.判断开始 (选择夹1.现行子夹 ＝ 0)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
内容 ＝ 内容 ＋ 主窗口.超级列表框1.取标题 (组 [i], 1) ＋ #换行符
.计次循环尾 ()
剪辑板_置文本 (内容)
.判断 (选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
内容 ＝ 内容 ＋ 主窗口.超级列表框2.取标题 (组 [i], 1) ＋ #换行符
.计次循环尾 ()
剪辑板_置文本 (内容)
.默认
.判断结束
.子程序 _复制整行_被选择
.局部变量 组, 整数型, , "0"
.局部变量 列数, 整数型
.局部变量 i, 整数型
.局部变量 j, 整数型
.局部变量 内容, 文本型
.判断开始 (选择夹1.现行子夹 ＝ 0)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
列数 ＝ 主窗口.超级列表框1.取列数 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
j ＝ 0
.计次循环首 (列数, )
内容 ＝ 内容 ＋ 主窗口.超级列表框1.取标题 (组 [i], j) ＋ “|”
j ＝ j ＋ 1
.计次循环尾 ()
内容 ＝ 内容 ＋ #换行符
.计次循环尾 ()
剪辑板_置文本 (内容)
.判断 (选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
列数 ＝ 主窗口.超级列表框2.取列数 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
j ＝ 0
.计次循环首 (列数, )
内容 ＝ 内容 ＋ 主窗口.超级列表框2.取标题 (组 [i], j) ＋ “|”
j ＝ j ＋ 1
.计次循环尾 ()
内容 ＝ 内容 ＋ #换行符
.计次循环尾 ()
剪辑板_置文本 (内容)
.默认
.判断结束
.子程序 _按钮12_被单击
.子程序 写监控日志
.参数 内容, 文本型
.局部变量 time, 日期时间型
.如果真 (全_监控 且 内容 ≠ “”)
.如果 (内容 ＝ “====================================================”)
主窗口.监控.加入文本 (内容 ＋ #换行符)
.否则
time ＝ 取现行时间 ()
主窗口.监控.加入文本 (到文本 (取月份 (time)) ＋ “-” ＋ 到文本 (取日 (time)) ＋ “-” ＋ 到文本 (取小时 (time)) ＋ “-” ＋ 到文本 (取分钟 (time)) ＋ “-” ＋ 到文本 (取秒 (time)) ＋ “ ” ＋ 内容 ＋ #换行符)
.如果结束
.如果真结束
.子程序 _按钮20_被单击
载入 (文件下载管理, , 假)
.子程序 _按钮21_被单击
载入 (监控日志管理, , 假)
.子程序 _按钮22_被单击
载入 (MD5管理, , 假)
.子程序 _按钮23_被单击
载入 (远程代码管理, , 假)
.子程序 _按钮24_被单击
载入 (VMP授权管理, , 假)
.子程序 _按钮25_被单击
载入 (云参数管理, , 假)
.子程序 _按钮26_被单击
载入 (云图片管理, , 假)
.子程序 _按钮27_被单击
载入 (云文档管理, , 假)
.子程序 _按钮28_被单击
载入 (智能封卡管理, , 假)
.子程序 _按钮29_被单击
载入 (智能拉黑管理, , 假)
.子程序 _按钮30_被单击
载入 (远程文件管理, , 假)
.子程序 _解绑_被选择
.局部变量 i
.局部变量 组, 整数型, , "0"
.局部变量 卡密, 文本型
.局部变量 软件名, 文本型
.局部变量 软件类型, 文本型
.局部变量 软件版本, 文本型
.判断开始 (选择夹1.现行子夹 ＝ 1)
组 ＝ 主窗口.超级列表框2.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 超级列表框2.取标题 (组 [i], 1)
软件名 ＝ 超级列表框2.取标题 (组 [i], 4)
软件类型 ＝ 超级列表框2.取标题 (组 [i], 5)
软件版本 ＝ 超级列表框2.取标题 (组 [i], 6)
服务器解绑 (软件名, 软件类型, 软件版本, 卡密)
.计次循环尾 ()
.判断 (列表操作类型 ＝ 5)
组 ＝ 主窗口.超级列表框1.取被选择表项 ()
.计次循环首 (取数组成员数 (组), )
i ＝ i ＋ 1
卡密 ＝ 超级列表框2.取标题 (组 [i], 1)
软件名 ＝ 超级列表框2.取标题 (组 [i], 4)
软件类型 ＝ 超级列表框2.取标题 (组 [i], 5)
软件版本 ＝ 超级列表框2.取标题 (组 [i], 6)
服务器解绑 (软件名, 软件类型, 软件版本, 卡密)
.计次循环尾 ()
.默认
.判断结束
窗口程序集_MD5管理
.版本 2
.支持库 iext
.程序集 窗口程序集_MD5管理
.程序集变量 集表项索引, 整数型
.程序集变量 集列索引, 整数型
.子程序 _复制_被选择
.局部变量 索引, 整数型
.局部变量 i, 整数型
索引 ＝ MD5管理.超级列表框1.取表项数 ()
.计次循环首 (索引, )
超级列表框1.取当前状态图片 (i)
.计次循环尾 ()
.子程序 _MD5管理_创建完毕
读取MD5配置 ()
.子程序 读取MD5配置
.局部变量 MD5总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
MD5总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, “MD5总数”, ))
.计次循环首 (MD5总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
MD5管理.超级列表框1.插入表项 (i, 到文本 (i ＋ 1), , , , )
MD5管理.超级列表框1.置标题 (i, 1, 组 [1])
MD5管理.超级列表框1.置标题 (i, 2, 组 [2])
MD5管理.超级列表框1.保证显示 (i)
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 _超级列表框1_右键单击表项
弹出菜单 (MD5, , )
.子程序 _添加_被选择
.局部变量 索引, 整数型
索引 ＝ MD5管理.超级列表框1.取表项数 ()
MD5管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
MD5管理.超级列表框1.置标题 (索引, 1, “文件名”)
MD5管理.超级列表框1.置标题 (索引, 2, “MD5”)
.子程序 _超级列表框1_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项索引, 整数型
.局部变量 列索引, 整数型
.局部变量 矩形, 匿名结构_2
取表项行列索引 (MD5管理.超级列表框1, 横向位置, 纵向位置, 表项索引, 列索引)
MD5管理.编辑框1.可视 ＝ 真
MD5管理.编辑框1.内容 ＝ MD5管理.超级列表框1.取标题 (表项索引, 列索引)
MD5管理.编辑框1.获取焦点 ()
MD5管理.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (MD5管理.超级列表框1, 表项索引, 列索引)
编辑框1.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
编辑框1.高度 ＝ 16
编辑框1.左边 ＝ 矩形.匿名成员_1
编辑框1.顶边 ＝ 矩形.匿名成员_2 ＋ 2
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.子程序 _编辑框1_失去焦点
MD5管理.超级列表框1.置标题 (集表项索引, 集列索引, MD5管理.编辑框1.内容)
MD5管理.编辑框1.可视 ＝ 假
.子程序 _按钮7_被单击
.局部变量 索引, 整数型
.局部变量 组, 文本型, , "0"
MD5管理.通用对话框1.初始目录 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5”
MD5管理.通用对话框1.打开 ()
.如果真 (MD5管理.通用对话框1.文件名 ＝ “”)
返回 ()
.如果真结束
索引 ＝ MD5管理.超级列表框1.取表项数 ()
MD5管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
组 ＝ 分割文本 (MD5管理.通用对话框1.文件名, “\”, )
MD5管理.超级列表框1.置标题 (索引, 1, 组 [取数组成员数 (组)])
MD5管理.超级列表框1.置标题 (索引, 2, 校验_取md5 (读入文件 (MD5管理.通用对话框1.文件名)))
.子程序 _MD5管理_将被销毁
保存MD5配置 ()
.子程序 保存MD5配置
.局部变量 索引, 整数型
.局部变量 序, 文本型
.局部变量 i, 整数型
.局部变量 文件名, 文本型
.局部变量 配置, 文本型
.局部变量 MD5文本, 文本型
索引 ＝ MD5管理.超级列表框1.取表项数 ()
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, , )
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, “MD5总数”, 到文本 (索引))
.计次循环首 (索引, )
序 ＝ 到文本 (i ＋ 1)
.如果真 (序 ＝ “”)
返回 ()
.如果真结束
文件名 ＝ MD5管理.超级列表框1.取标题 (i, 1)
MD5文本 ＝ MD5管理.超级列表框1.取标题 (i, 2)
配置 ＝ 文件名 ＋ “&&” ＋ MD5文本
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\MD5\自定义MD5配置.ini”, “MD5”, 序, 配置)
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 _删除_被选择
.局部变量 索引, 整数型
.局部变量 组, 整数型, , "0"
.局部变量 index, 整数型
索引 ＝ MD5管理.超级列表框1.取表项数 ()
组 ＝ MD5管理.超级列表框1.取被选择表项 ()
index ＝ 取数组成员数 (组)
.计次循环首 (取数组成员数 (组), )
MD5管理.超级列表框1.删除表项 (组 [index])
index ＝ index － 1
.计次循环尾 ()
保存MD5配置 ()
MD5管理.超级列表框1.全部删除 ()
读取MD5配置 ()
窗口程序集_文件下载管理
.版本 2
.支持库 iext
.程序集 窗口程序集_文件下载管理
.程序集变量 集表项索引, 整数型
.程序集变量 集列索引, 整数型
.子程序 _文件下载管理_创建完毕
读取文件下载配置 ()
.子程序 读取文件下载配置
.局部变量 文件总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
文件总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\下载文件库配置.ini”, “文件”, “文件总数”, ))
.计次循环首 (文件总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\下载文件库配置.ini”, “文件”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
文件下载管理.超级列表框1.插入表项 (i, 到文本 (i ＋ 1), , , , )
文件下载管理.超级列表框1.置标题 (i, 1, 组 [1])
文件下载管理.超级列表框1.置标题 (i, 2, 组 [2])
文件下载管理.超级列表框1.置标题 (i, 3, 组 [3])
文件下载管理.超级列表框1.保证显示 (i)
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 _文件下载管理_将被销毁
保存文件下载配置 ()
.子程序 保存文件下载配置
.局部变量 索引, 整数型
.局部变量 序, 文本型
.局部变量 i, 整数型
.局部变量 文件名, 文本型
.局部变量 大小, 文本型
.局部变量 备注, 文本型
.局部变量 配置, 文本型
索引 ＝ 文件下载管理.超级列表框1.取表项数 ()
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\下载文件库配置.ini”, “文件”, , )
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\下载文件库配置.ini”, “文件”, “文件总数”, 到文本 (索引))
.计次循环首 (索引, )
序 ＝ 到文本 (i ＋ 1)
.如果真 (序 ＝ “”)
返回 ()
.如果真结束
文件名 ＝ 文件下载管理.超级列表框1.取标题 (i, 1)
大小 ＝ 文件下载管理.超级列表框1.取标题 (i, 2)
备注 ＝ 文件下载管理.超级列表框1.取标题 (i, 3)
配置 ＝ 文件名 ＋ “&&” ＋ 大小 ＋ “&&” ＋ 备注
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库\下载文件库配置.ini”, “文件”, 序, 配置)
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 _超级列表框1_右键单击表项
弹出菜单 (文件下载, , )
.子程序 _超级列表框1_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项索引, 整数型
.局部变量 列索引, 整数型
.局部变量 矩形, 匿名结构_2
取表项行列索引 (文件下载管理.超级列表框1, 横向位置, 纵向位置, 表项索引, 列索引)
文件下载管理.编辑框1.可视 ＝ 真
文件下载管理.编辑框1.内容 ＝ 文件下载管理.超级列表框1.取标题 (表项索引, 列索引)
文件下载管理.编辑框1.获取焦点 ()
文件下载管理.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (文件下载管理.超级列表框1, 表项索引, 列索引)
编辑框1.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
编辑框1.高度 ＝ 16
编辑框1.左边 ＝ 矩形.匿名成员_1
编辑框1.顶边 ＝ 矩形.匿名成员_2 ＋ 2
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.子程序 _编辑框1_失去焦点
文件下载管理.超级列表框1.置标题 (集表项索引, 集列索引, 文件下载管理.编辑框1.内容)
文件下载管理.编辑框1.可视 ＝ 假
.子程序 _添加_被选择
.局部变量 索引, 整数型
索引 ＝ 文件下载管理.超级列表框1.取表项数 ()
文件下载管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
文件下载管理.超级列表框1.置标题 (索引, 1, “文件名”)
文件下载管理.超级列表框1.置标题 (索引, 2, “大小”)
文件下载管理.超级列表框1.置标题 (索引, 3, “备注”)
.子程序 _删除_被选择
.局部变量 索引, 整数型
.局部变量 组, 整数型, , "0"
.局部变量 index, 整数型
索引 ＝ 文件下载管理.超级列表框1.取表项数 ()
组 ＝ 文件下载管理.超级列表框1.取被选择表项 ()
index ＝ 取数组成员数 (组)
.计次循环首 (取数组成员数 (组), )
文件下载管理.超级列表框1.删除表项 (组 [index])
index ＝ index － 1
.计次循环尾 ()
保存文件下载配置 ()
文件下载管理.超级列表框1.全部删除 ()
读取文件下载配置 ()
.子程序 _按钮7_被单击
.局部变量 索引, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 大小, 双精度小数型
.局部变量 单位, 文本型
文件下载管理.通用对话框1.初始目录 ＝ 取运行目录 () ＋ “\jjk企业版网络验证系统\下载文件库”
文件下载管理.通用对话框1.打开 ()
.如果真 (文件下载管理.通用对话框1.文件名 ＝ “”)
返回 ()
.如果真结束
索引 ＝ 文件下载管理.超级列表框1.取表项数 ()
文件下载管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
组 ＝ 分割文本 (文件下载管理.通用对话框1.文件名, “\”, )
文件下载管理.超级列表框1.置标题 (索引, 1, 组 [取数组成员数 (组)])
大小 ＝ 取文件尺寸 (文件下载管理.通用对话框1.文件名) ÷ 1024
.如果真 (大小 ＜ 1)
大小 ＝ 1
.如果真结束
.如果 (大小 ＞ 1024)
单位 ＝ “MB”
大小 ＝ 取文件尺寸 (文件下载管理.通用对话框1.文件名) ÷ 1024 ÷ 1024
.否则
单位 ＝ “KB”
.如果结束
文件下载管理.超级列表框1.置标题 (索引, 2, 到文本 (取整 (大小)) ＋ 单位)
文件下载管理.超级列表框1.置标题 (索引, 3, “备注”)
窗口程序集_云参数管理
.版本 2
.支持库 iext
.程序集 窗口程序集_云参数管理
.程序集变量 集表项索引, 整数型
.程序集变量 集列索引, 整数型
.子程序 _超级列表框1_右键单击表项
弹出菜单 (云参数, , )
.子程序 _超级列表框1_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项索引, 整数型
.局部变量 列索引, 整数型
.局部变量 矩形, 匿名结构_2
取表项行列索引 (云参数管理.超级列表框1, 横向位置, 纵向位置, 表项索引, 列索引)
云参数管理.编辑框1.可视 ＝ 真
云参数管理.编辑框1.内容 ＝ 云参数管理.超级列表框1.取标题 (表项索引, 列索引)
云参数管理.编辑框1.获取焦点 ()
云参数管理.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (云参数管理.超级列表框1, 表项索引, 列索引)
编辑框1.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
编辑框1.高度 ＝ 16
编辑框1.左边 ＝ 矩形.匿名成员_1
编辑框1.顶边 ＝ 矩形.匿名成员_2 ＋ 2
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.子程序 _编辑框1_失去焦点
云参数管理.超级列表框1.置标题 (集表项索引, 集列索引, 云参数管理.编辑框1.内容)
云参数管理.编辑框1.可视 ＝ 假
.子程序 _添加_被选择
.局部变量 索引, 整数型
索引 ＝ 云参数管理.超级列表框1.取表项数 ()
云参数管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
云参数管理.超级列表框1.置标题 (索引, 1, “参数名”)
云参数管理.超级列表框1.置标题 (索引, 2, “值”)
云参数管理.超级列表框1.置标题 (索引, 3, “备注”)
.子程序 _删除_被选择
.局部变量 索引, 整数型
.局部变量 组, 整数型, , "0"
.局部变量 index, 整数型
索引 ＝ 云参数管理.超级列表框1.取表项数 ()
组 ＝ 云参数管理.超级列表框1.取被选择表项 ()
index ＝ 取数组成员数 (组)
.计次循环首 (取数组成员数 (组), )
云参数管理.超级列表框1.删除表项 (组 [index])
index ＝ index － 1
.计次循环尾 ()
保存云参数配置 ()
云参数管理.超级列表框1.全部删除 ()
读取云参数配置 ()
.子程序 _清空_被选择
云参数管理.超级列表框1.全部删除 ()
.子程序 保存云参数配置
.局部变量 索引, 整数型
.局部变量 序, 文本型
.局部变量 i, 整数型
.局部变量 参数名, 文本型
.局部变量 值, 文本型
.局部变量 备注, 文本型
.局部变量 配置, 文本型
索引 ＝ 云参数管理.超级列表框1.取表项数 ()
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, , )
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, “云参数总数”, 到文本 (索引))
.计次循环首 (索引, )
序 ＝ 到文本 (i ＋ 1)
.如果真 (序 ＝ “”)
返回 ()
.如果真结束
参数名 ＝ 云参数管理.超级列表框1.取标题 (i, 1)
值 ＝ 云参数管理.超级列表框1.取标题 (i, 2)
备注 ＝ 云参数管理.超级列表框1.取标题 (i, 3)
配置 ＝ 参数名 ＋ “&&” ＋ 值 ＋ “&&” ＋ 备注
写配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, 序, 配置)
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 读取云参数配置
.局部变量 云参数总数, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 i, 整数型
云参数总数 ＝ 到整数 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, “云参数总数”, ))
.计次循环首 (云参数总数, )
组 ＝ 分割文本 (读配置项 (取运行目录 () ＋ “\jjk企业版网络验证系统\数据库\云参数\自定义云参数配置.ini”, “云参数”, 到文本 (i ＋ 1), ), “&&”, )
.如果真 (取数组成员数 (组) ＞ 0)
云参数管理.超级列表框1.插入表项 (i, 到文本 (i ＋ 1), , , , )
云参数管理.超级列表框1.置标题 (i, 1, 组 [1])
云参数管理.超级列表框1.置标题 (i, 2, 组 [2])
云参数管理.超级列表框1.置标题 (i, 3, 组 [3])
云参数管理.超级列表框1.保证显示 (i)
.如果真结束
i ＝ i ＋ 1
.计次循环尾 ()
.子程序 _云参数管理_创建完毕
读取云参数配置 ()
.子程序 _云参数管理_将被销毁
保存云参数配置 ()
窗口程序集_云图片管理
.版本 2
.支持库 iext
.程序集 窗口程序集_云图片管理
.程序集变量 集表项索引, 整数型
.程序集变量 集列索引, 整数型
.子程序 _添加_被选择
.局部变量 索引, 整数型
索引 ＝ 云图片管理.超级列表框1.取表项数 ()
云图片管理.超级列表框1.插入表项 (索引, 到文本 (索引 ＋ 1), , , , )
云图片管理.超级列表框1.置标题 (索引, 1, “图片名”)
云图片管理.超级列表框1.置标题 (索引, 2, “大小”)
云图片管理.超级列表框1.置标题 (索引, 3, “备注”)
.子程序 _云图片管理_创建完毕
读取云图片配置 ()
.子程序 _删除_被选择
.局部变量 索引, 整数型
.局部变量 组, 整数型, , "0"
.局部变量 index, 整数型
索引 ＝ 云图片管理.超级列表框1.取表项数 ()
组 ＝ 云图片管理.超级列表框1.取被选择表项 ()
index ＝ 取数组成员数 (组)
.计次循环首 (取数组成员数 (组), )
云图片管理.超级列表框1.删除表项 (组 [index])
index ＝ index － 1
.计次循环尾 ()
保存云图片配置 ()
云图片管理.超级列表框1.全部删除 ()
读取云图片配置 ()
.子程序 _超级列表框1_右键单击表项
弹出菜单 (云图片, , )
.子程序 _超级列表框1_被双击, 逻辑型
.参数 横向位置, 整数型
.参数 纵向位置, 整数型
.参数 功能键状态, 整数型
.局部变量 表项索引, 整数型
.局部变量 列索引, 整数型
.局部变量 矩形, 匿名结构_2
取表项行列索引 (云图片管理.超级列表框1, 横向位置, 纵向位置, 表项索引, 列索引)
云图片管理.编辑框1.可视 ＝ 真
云图片管理.编辑框1.内容 ＝ 云图片管理.超级列表框1.取标题 (表项索引, 列索引)
云图片管理.编辑框1.获取焦点 ()
云图片管理.超级列表框1.取列宽 (列索引)
矩形 ＝ 取表项尺寸 (云图片管理.超级列表框1, 表项索引, 列索引)
编辑框1.宽度 ＝ 矩形.匿名成员_3 － 矩形.匿名成员_1
编辑框1.高度 ＝ 16
编辑框1.左边 ＝ 矩形.匿名成员_1
编辑框1.顶边 ＝ 矩形.匿名成员_2 ＋ 2
集表项索引 ＝ 表项索引
集列索引 ＝ 列索引
.子程序 _编辑框1_失去焦点
云图片管理.超级列表框1.置标题 (集表项索引, 集列索引, 云图片管理.编辑框1.内容)
云图片管理.编辑框1.可视 ＝ 假
.子程序 _按钮7_被单击
.局部变量 索引, 整数型
.局部变量 组, 文本型, , "0"
.局部变量 大小, 双精度小数型
.局部变量 单位, 文本型
窗口
需要的来
762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
