server/Gameserver/Amfphp/process/UserProc.php

<?php

namespace loyalsoft;

// 常量设定
define("USER_Backup_MaxRecords", 10);                                           //  玩家数据备份,最多10条,每天1条,最后一次登录时的数据.
define("USER_ActiveRecord_Days", 108);                                          // 玩家记录集维持的最大天数
define("USER_RANDOM_DAYS", 7);                                                  // 玩家记录集随机的最大天数
define("USER_ACTION_DAYS", 108);                                                // 玩家行为集维持的最大天数
define("INIT_TUTORIAL", 1);                                                     // 新手引导是否开启 0.否 1.是
define("INIT_GODPETMANUAL", '{"exp":0,"godpetDic":{"101001":[0],"101002":[0],"101003":[0]}}'); // 初始化设定
//

/**
 * Description of UserProc
 * 玩家数据处理流程
 *
 */
class UserProc {

    const role_Table = 'tab_rolename';

    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    public static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::cmd_user_getzonelist:                                 # 6000 分区列表
                return UserProc::GetZoneList($req);
            case CmdCode::cmd_user_loginuserinfo:                               # 6001 登录
                return UserProc::loginUserInfo($req);
            case CmdCode::cmd_user_gameconstinfo:                               # 6002 下载游戏配置
                return UserProc::downloadConstInfo($req);
            case CmdCode::cmd_user_acceptcontidaysgift:                         # 6003 领取连续登陆奖励
                return UserProc::acceptContiDaysGift($req);
            case CmdCode::cmd_user_registerNewUID:                              # 6004 注册新的用户 (送审/官方包接口)
                return UserProc::RegisterNewUID($req);
            case CmdCode::cmd_user_testUserLogin:                               # 6005 机器码登录（测试接口）
                return UserProc::TestUserLogin($req);
            case CmdCode::cmd_user_registerNewRole:                             # 6006 注册新角色
                return UserProc::RegisterNewRole($req);
            case CmdCode::cmd_user_completeNewbieGuide:                         # 6007 提交新手引导步骤
                return UserProc::completeNewbieGuide($req);
            case CmdCode::cmd_user_setNickname:                                 # 6008 设置/修改玩家昵称
                return self::SetUserNickname($req);
            case CmdCode::cmd_user_setNewbieGuideCards:                         # 6009 发放新手引导所需卡牌
                return self::SetNewbieGuideCards($req);
            case CmdCode::cmd_user_SetUserImageBorder:                          # 6010修改玩家头像框
                return self::SetUserImageBorder($req);
            case CmdCode::cmd_user_setNewbieGuideOver:
                return UserProc::setNewbieGuideOver($req);
            default:
                Err(ErrCode::cmd_err);
        }
    }

    /**
     * [6010]修改玩家头像框
     * @param Req $req
     */
    static function SetUserImageBorder($req) {
        list($imgborderId) = $req->paras;                                       # 参数, 新头像框ID
        $req->userInfo->game->imgBorderId = $imgborderId;
        UserProc::updateUserInfo($req);
        return Resp::ok(array('ret' => 'ok'));
    }

    /**
     * [6009] 新手引导 发送n张碎片到玩家身上
     * @param Req $req
     */
    static function SetNewbieGuideCards($req) {
        $private = $req->userInfo->game->privateState;
        if (!property_exists($private, 'newbieguideCards')) {                   # 逻辑检查, 是否已经发放过
            $private->newbieguideCards = true;
            $req->userInfo->game->privateState = $private;                      # 回写私有数据
            $sp = explode(';', glc()->User_SetNewbieGuideCards);                # 碎片
            foreach ($sp as $cardinfo) {
                $arr = explode(',', $cardinfo);
                $itemid = $arr[0];
                $num = $arr[1];
                StoreProc::addSegmentIntoStore($req->userInfo->game->store, $itemid, $num);
            }
            $exp = explode(';', glc()->User_SetNewbieGuideExps);                # 经验卡
            foreach ($exp as $expinfo) {
                $arr = explode(',', $expinfo);
                $itemid = $arr[0];
                $num = $arr[1];
                StoreProc::PutOverlyingItemInStore($itemid, $num, $req);
            }
            UserProc::updateUserInfo($req);                                     # 回存玩家数据
            return Resp::ok(array('store' => $req->userInfo->game->store));
        }
        return Resp::err(ErrCode::active_hasgetted);
    }

    /**
     * [6008] 设置/修改玩家昵称
     * @param Req $req
     */
    static function SetUserNickname($req) {
        list($newname, $image) = $req->paras;                                   # 参数: 新昵称, 头像
        $itemid = glc()->User_SetNickname_CostItemid;
        if ($itemid) {
            $err = StoreProc::removeItemFromStore($req->userInfo->game->store, $itemid, 1);
            if ($err) {
                Err($err);
            }
        }
        $req->userInfo->game->name = $newname;
        $req->userInfo->game->img = $image;
        daoInst()->update(self::role_Table)
                ->data(array('roleName' => $newname))
                ->where('userID')->eq($req->uid)
                ->andWhere('zoneid')->eq($req->zoneid)
                ->exec();
        UserProc::updateUserInfo($req);
        return Resp::ok(array('ret' => 'ok'));
    }

    /**
     * 增加 设置引导结束的标志位
     * @param type $req
     */
    public static function setNewbieGuideOver($req) {
        $user = new UserGameModel($req->userInfo->game);                        # user
        if (!CommUtil::isPropertyExists($user, "NewbieGuideOver")) {            # 防御: 变量未初始化
            $user->NewbieGuideOver = 1;
        }
        $user->NewbieGuideOver = 1;
        $req->userInfo->game = $user;
        UserProc::updateUserInfo($req);                                         # 回写数据
        return Resp::ok(array(#                                                 # 返回值
                    'result' => "succeed"
        ));
    }

    /**
     * 完成初始的强制的新手引导阶段
     * 第一阶段的引导
     * @param Req $req
     */
    public static function completeNewbieGuide($req) {
        list($guideType, $guideIndex, $guideState) = $req->paras;               # 参数: 新手引导类型, 执行步骤, 执行结果 
        $user = new UserGameModel($req->userInfo->game);                        # user
        if (!CommUtil::isPropertyExists($user, "NewbieGuide")) {                # 防御: 变量未初始化
            $user->NewbieGuide = ObjectInit();
        }
        $NewbieGuide = $user->NewbieGuide;
        if (!CommUtil::isPropertyExists($NewbieGuide, $guideType)) {            # 防御: 变量未初始化
            $NewbieGuide->$guideType = ObjectInit();
        }
        $temp = $NewbieGuide->$guideType;
        $temp->guideIndex = $guideIndex;
        $temp->guideState = $guideState;
        $NewbieGuide->$guideType = $temp;
        $user->NewbieGuide = $NewbieGuide;
        $req->userInfo->game = $user;
        UserProc::updateUserInfo($req);                                         # 回写数据
        return Resp::ok(array(#                                                 # 返回值
                    'result' => "succeed"
        ));
    }

    /**
     * 6006 注册新角色
     * @param Req $req
     */
    public static function RegisterNewRole($req) {
//        Err(ErrCode::err_method_obsoleted, "注册逻辑已经转移到龙游SDK中 --王刚");
        $userID = $req->uid;
        list($rolename, $gender, $profile_img) = $req->paras;                   # 参数: 昵称,性别,头像
        if (self::checkRoleNameNotExist($rolename)) {                           # 记录玩家
            $userinfo = self::createUser($req, $rolename, $gender, $profile_img);
            self::regRole($req->zoneid, $userID, $rolename, $gender, $profile_img, $userinfo->getPlatStr());
            $resp = Resp::ok($userinfo);
//            StatProc::UserGuidStep($userinfo->user->firstLogOn, $req->zoneid, -2, 1);
        } else {                                                                # 昵称已存在
            $resp = Resp::ok(array('ret' => '用户已存在.'));
        }
        return $resp;
    }

    /**
     * 6000 【移动端】 获取分区列表
     * @param Req $req
     */
    public static function GetZoneList($req) {
        $defaultZone = new ZoneInfoModel(1, 0, "");                             # 新用户默认分区
        $bGetRecommended = false;
        if (count($req->paras) > 0) {                                           # 是否只拉取推荐分区
            $bGetRecommended = $req->paras[0];
        }
        $zoneList = array();
        $ts = now();
        foreach (GameConfig::zonelist() as $zoneid => $zone) {
            isEditor() and $zone = new \sm_zonelist();
            if ($zone->publicTs > $ts) {
                continue;
            }
            $zone->zoneid = $zoneid;                                            # 把zoneid塞进zone数据结构中
            if ($bGetRecommended) {
                if ($zone->isRecommended > 0 && $zone->status == 1) {
                    $zoneList[] = $zone;
                } else {
                    
                }
            } else {
                $zoneList[] = $zone;
            }
            unset($zone->isRecommended);
        }
        UserProc::_AddTesterZonelist($req, $zoneList);                          # 添加测试分区
#
// <editor-fold defaultstate="collapsed" desc="    取玩家分区记录    ">
        $userZoneInfo = self::getUserZoneInfo($req);                            # 玩家分区记录
        $isNewUser = false;
        if ($userZoneInfo == null) {           // 这里使用推荐分区的数据，推荐分区信息，在后台编辑，编辑器可用
            $userZoneInfo = new UserZoneInfoModel();
            $userZoneInfo->lastZone = $defaultZone;                             # 新用户导向默认分区
            $isNewUser = true;

//            $err = self::RegisterNewUser($req);  # 新用户添加到总表中
//            if ($err != ErrCode::succeed) {
//                return ResponseVo::myErrResponse($req, $err);
//            }
# 统计模块添加记录
//            StatProc::UserGuidStep(CommUtil::tsCurrent(), $req->zoneid, -1, 1); // 第一次进入游戏
        } else { # 转换一下格式，去掉key，只保留value的集合
//            $userZoneInfo->playedZones = ArrayInit();
//            array_merge($userZoneInfo->playedZones, array_values((array) $userZoneInfo->playedZones));
        }

// </editor-fold>

        $ret = array(
            'isNewUser' => $isNewUser,
            'zonelist' => json_decode(json_encode($zoneList)),
            'userZoneInfo' => $userZoneInfo
        );

        return Resp::ok($ret);                                                  # 返回值
    }

    private static function _AddTesterZonelist($req, &$zoneList) {
        if (config::Inst()->isTester($req->uid)) {                              # 添加测试分区
            $zoneList[] = array('zoneid' => 999, 'name' => '内测专区', 'status' => 2, 'publicTs' => 0);
        }
    }

    /**
     * 6002 客户端下载常量配置信息
     * @param Req $req
     * @return type
     */
    public static function downloadConstInfo($req) {
        $clientver = $req->paras[0];                                            # 客户端数据版本号
        $serverVer = GameConfig::ver();                                         # 最新数据版本号
        if ($serverVer == null) {                                               # 找不到常量数据
            return Resp::err(ErrCode::err_const_no);
        }
        if ($clientver == $serverVer) {                                         # 如果版本一致，数据体抹掉，只传回版本号
//                $md5 = md5(json_encode($constInfo));                          # 计算MD5值，多余计算md5
            $ret = array(
                'version' => $clientver,
                'data' => null);
            return Resp::ok($ret);
        }
        $constInfo = GameConfig::client();                                      # 取出来的已经是base64过的压缩数据
        if ($constInfo == null) {
            return Resp::err(ErrCode::err_const_no);
        } else {
            return Resp::ok(array('data' => $constInfo));
        }
    }

    /**
     * 6001 客户端登录并返还玩家信息
     * @param Req $req
     * @return Resp
     */
    public static function loginUserInfo($req) {
//        return ResponseVo::ErrResponse($req, ErrCode::msg_methodnotimplement);
        $userInfo = UserProc::getUserInfo(gMem(), $req->zoneid, $req->uid);     # 取玩家信息
        if ($userInfo == null) {                                                # 新用户, -> 6006创建账号
            $ret = array(
                'isNewUser' => true
            );
            return Resp::ok($ret);
        } else {//2.如果玩家已存在，则处理普通登录流程
            $req->userInfo = $userInfo;                                         # 给Req挂载userInfo
            UserProc::checkContidays($req);                                     # 连续登录,状态检查
//            UserProc::_checkUpdateGift($req);                                 # 检查更新礼包
//            UserProc::fetchFromInteract($mem, $req);                          # 从交互体更新部分信息 
            PayProc::m_refreshChargeOrders($req);                               # 刷新订单, 多平台版本
            PayProc::checkDeltest($req);                                        # 检查内侧充值记录(函数内部会只检查一次)
            UserProc::updateUserInfo($req);                                     # 这一步回存操作只有在 userInfo正常存在的情况下才进行
            $resp = Resp::ok($userInfo);                                        # 设置返回值
//            if (isset($req->updateGift)) {                                    # 透传更新礼包给Response
//                $resp->updateGift = $req->updateGift;
//            }
            self::backupUserInfo($req);                                         # 数据回写
            self::updtateUserZoneInfo($req);                                    # 1. 更新玩家分区记录
        }

        return $resp;
    }

    /**
     * 6003 领取连续登录奖励
     * @param Req $req
     */
    public static function acceptContiDaysGift($req) {
        $resp = Resp::err(ErrCode::err_method_notimplement);

        return $resp;
    }

    /**
     * 初始化卡牌图鉴信息
     * @param UserGameModel $userInfo
     */
    private static function _intiHeroManual($userInfo) {
        if (INIT_TUTORIAL == 1) {                                               # 配合新手引导产生的图鉴数据
            $userInfo->heroManual = JsonUtil::decode(INIT_GODPETMANUAL);
        } else {
            $userInfo->heroManual = new HeroManualModel();
            $userInfo->heroManual->initInstance();
        }
    }

// <editor-fold defaultstate="collapsed" desc="送审/测试用方法">

    /**
     * 6004 测试: 注册新用户UID
     * @param Req $req
     * @return type
     */
    public static function RegisterNewUID($req) {
        if (count($req->paras) < 2) {                                           # 参数数量不足
            return Resp::err(ErrCode::parasnotenough_msg);
        }
        $userName = $req->paras[0];                                             # 取参数 昵称
        $pwd = $req->paras[1];                                                  # 密码
        $email = count($req->paras) > 2 ? $req->paras[2] : "";                  # 邮箱
        $phoneNumber = count($req->paras) > 3 ? $req->paras[3] : "";            # 电话号码
        $ret = RegNewUser::Write2MysqlUserInfo($userName, $pwd, $email, $phoneNumber); // 执行逻辑
        self::setNewbieGuideOver($req);
        return Resp::ok($ret);
    }

    /**
     * 6005 测试用的用户登录
     * @param Req $req
     */
    public static function TestUserLogin($req) {
        if (count($req->paras) < 2) {// 防御:参数数量不足
            return Resp::err(ErrCode::parasnotenough_msg);
        }
        $userName = $req->paras[0];                                             // 用户名
        $pwd = $req->paras[1];                                                  // 密码

        $ret = RegNewUser::VerifyUserPwd($userName, $pwd);                      // 校验

        return Resp::ok($ret);
    }

// </editor-fold>
//
// <editor-fold defaultstate="collapsed" desc="    辅助方法    ">

    /**
     * 检查昵称是否已经存在
     * @param string $roleName
     * @return boolean
     */
    static function checkRoleNameNotExist($roleName) {

        static $sqlFormat = "SELECT count(*) as rows FROM `tab_rolename` WHERE roleName='%s';";
        $sql = sprintf($sqlFormat, $roleName);
        $n = daoInst()->query($sql)->fetch();
        return $n->rows <= 0;
    }

    /**
     * 插入玩家新角色
     *
     * @param string $zoneid
     * @param string $userID
     * @param string $nickname
     * @param string $gender
     * @param string $profile_img
     * @param string $plat
     */
    static function regRole($zoneid, $userID, $nickname, $gender, $profile_img, $plat) {
        $paydb = CPayInit();
        $sqlFormat = "INSERT INTO `tab_rolename` ( zoneid,userID,roleName,gender, profile,plat) "
                . "VALUES ('%s','%s','%s','%s','%s','%s')";
        $sql = sprintf($sqlFormat, $zoneid, $userID, #
                $paydb->escape_string($nickname), $gender, $profile_img, $plat);
        $paydb->query($sql);
        $paydb->close();
    }

    /**
     * 检测连续登录状态，重置必要字段[时间戳自动记录]
     * @param Req $req
     */
    static function checkContidays($req, $isnew = 0) {
        $ret = TimeUtil::tsDay() - TimeUtil::tsDay($req->userInfo->game->lastLogin); // 对比登录日期
        if ($ret > 0) {                                                         # 当天第一次登录
            self::OnNewDay($req, $isnew);
        } else {
            # 更新下登录次数记录(任务计数器)
        }
        if ($ret == 1) {                                                        # 连续登录
        } else if ($ret >= 2) {                                                 # 隔天登录
        }
        $req->userInfo->game->lastLogin = now();                                # 更新下访问时间
        return $ret;
    }

    /**
     *  处理当天第一次登录
     * @param RequesstVo $req
     * @param bool $isnew Description
     */
    static function OnNewDay($req, $isnew) {
        self::updatePlatUserRecord($req, $isnew);                               # 添加到到当天活跃玩家记录集合
        ActiveProc::DailyReset($req);                                           # 抽奖、每日任务状态,计数器...
        FightProc::ClearByDay($req);                                            # 战斗相关状态每日清理
    }

// <editor-fold defaultstate="collapsed" desc="创建新用户">

    /**
     * 创建用户
     * @param Req $req
     * @return UserInfoMo
     */
    static function createUser($req, $rolename, $gender, $profile_img) {
        $userInfo = new UserInfoMo();
        $req->userInfo = $userInfo;                                             # 更新Req的userinfo,
        $userInfo->uid = $req->uid;
        $userInfo->zoneid = $req->zoneid;
        $userInfo->game = new UserGameModel();
        $userInfo->game->initialize();                                          # 初始化玩家数据
        $userInfo->game->name = $rolename;
        $userInfo->game->gender = $gender;
        $userInfo->game->profile_img = $profile_img;
        $userInfo->game->firstLogin = now();
//        $userInfo->game->pvp->socre = PVPProc::_getScore_by_uid($req, $req->uid); # 初始化pvp积分
//        $userInfo->game->NewbieGuideOver = 1;
        UserProc::_intiHeroManual($userInfo->game);                             # 初始化图鉴
        $userInfo->interact = new UserInteractModel();                          # 初始化交互体数据
        #Ps 6006是没有获得到Userinfo到Req中的
        UserProc::checkContidays($req, 1);                                      # 每日状态检查
//        UserProc::fetchFromInteract($mem, $req);  # 从interact拉取数据，Ps.初始化的过程应该还拉取不到什么有效数据
        UserProc::updateUserInfo($req);                                         # 回存用户数据
        FriendProc::Init($req);
//        StatProc::                                                            ...
        gMem()->increment(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid));   # 增加玩家数量计数
//        GoalsDailyProc::dealDailyLogin($mem, $req, $resp);                   # 每日登录任务

        return $userInfo;
    }

    /**
     * 整理平台玩家记录集
     * @param Req $req
     * @param int $isnew
     */
    private static function updatePlatUserRecord($req, $isnew = 0) {
        $zoneid = $req->zoneid;
        $uid = $req->uid;
        $user = $req->userInfo->game;
        $day = tsDay();
        $level = $user->level;
        $platUser = ObjectInit();
        $platUser->uid = $uid;                                                  #
        $platUser->name = $user->name;                                          #
        $platUser->level = $level;
        $platUser->img = $user->img;                                            # 头像字段
        $platUser->cash = $user->cash;
        $platUser->gold = $user->gold;
        $platUser->tili = $user->tili;
        $platUser->ts = now();
        $platUser->isnew = $isnew;
        gMem()->delete(MemKey_GameRun::DailyLoginUser_byUID_hash($zoneid, $day - 108));
        gMem()->hset(MemKey_GameRun::DailyLoginUser_byUID_hash($zoneid), $uid, $platUser);
        gMem()->delete(MemKey_GameRun::DailyLoginUser_byLevel_hash($zoneid, $level, $day - 108));
        gMem()->hset(MemKey_GameRun::DailyLoginUser_byLevel_hash($zoneid, $level), $uid, $platUser);
    }

// </editor-fold>
//
// <editor-fold defaultstate="collapsed" desc="读写玩家数据">

    /**
     * 玩家数据
     * @param CRedisUtil $mem
     * @param type $zoneid
     * @param type $uid
     */
    public static function getUserInfo($mem, $zoneid, $uid) {
        $a = $mem->get(MemKey_User::Info($zoneid, $uid));
        if ($a) {
            $usrInfo = new UserInfoMo();
            $usrInfo->zoneid = $zoneid;
            $usrInfo->uid = $uid;
            $g = new UserGameModel($a);
            $usrInfo->game = $g;
            return $usrInfo;
        }
        return null;
    }

    /**
     * 更新用户数据(设置标志位,最后统一更新-gwang 2017.07.18)
     * @param Req $req
     */
    public static function updateUserInfo($req) {
        if (req()->userInfo) {
            req()->userInfoChanged = TRUE;
        } else {
            CLog::Assert("UserProc", $req->userInfo, #
                    "[" . $req->cmd . '] >>>>>>>>>>用户数据正试图置空!!<<<<<<<<<<<' . $req->uid);
        }
    }

    /**
     * 回写玩家数据
     * @param  CRedisUtil $mem
     * @param UserInfoMo $userInfo
     */
    public static function setUserInfo($mem, UserInfoMo $userInfo) {
        if ($mem && $userInfo) {
            $zoneid = $userInfo->zoneid;
            $uid = $userInfo->uid;
            $userInfo->game->lastSaveTs = now();
            return $mem->set(MemKey_User::Info($zoneid, $uid), $userInfo->game);
        }
        return false;
    }

// </editor-fold>
//
// <editor-fold defaultstate="collapsed" desc="玩家分区记录">

    /**
     * 读取玩家的分区记录
     * @param Req $req
     * @return UserZoneInfoModel Description
     */
    public static function getUserZoneInfo($req) {
        $ret = $req->mem->get(MemKey_User::Union_PlayedZoneInfo_normal($req->uid));
        return $ret;
    }

    /**
     * 更新玩家分区记录
     * @param Req $req
     */
    public static function updtateUserZoneInfo($req) {
        $userZoneInfo = self::getUserZoneInfo($req);                            # 取玩家分区记录
        if (!$userZoneInfo) {
            $userZoneInfo = new UserZoneInfoModel;
        }
        $level = 0;
        $zoneid = $req->zoneid;
        $playerName = "";
        if (isset($req->userInfo)) {                                            # 防御确保玩家数据不为空
            $level = $req->userInfo->game->level;
            $playerName = $req->userInfo->game->name;
        } else {
            CLog::warn('玩家数据为空!' . __CLASS__ . '.' . __FUNCTION__);
        }
        if (is_null($level)) {
            $level = 0;
        }
        $userZoneInfo->lastZone = new ZoneInfoModel($zoneid, $level, $playerName); # 更新玩家分区记录
        $userZoneInfo->playedZones->$zoneid = $userZoneInfo->lastZone;          # 玩过的分区集合
        $req->mem->set(MemKey_User::Union_PlayedZoneInfo_normal($req->uid), $userZoneInfo); # 回写数据
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="    用户数据备份    ">

    /**
     * 备份玩家数据,(玩家数据落地),一天一份,当天记为最后一次登录时的状态而非最后一次操作的状态
     * @history
     *           version 3.0.13 mysql版备份玩家数据, (性能优化后表现还不错)
     *                      除非用脚本在redis中实现备份,否则直接写入mysql.
     *                      主要是mysql版本利用存储过程之后性能已经和redis版相差不多.
     *           version 2.0.0 Redis storage 从MySQL转到Redis中存储. 这个备份数据没有大规模导出硬盘的需求
     *                      因为mysql版本实在是负载太大了, 上百毫秒. 所以改在redis中了.
     *           version 1.0.0 Mysql storagef 1. 分表不做了, 2. 存储过程不用了 3. 先能用再说
     * @param Req $req
     */
    public static function backupUserInfo($req) {
        $tsday = TimeUtil::tsDay();                                             # 精确到天,保留10个最近记录.
        $value = base64_encode(gzdeflate(JsonUtil::encode($req->userInfo)));    # blob数据,序列化下
        $sql = sprintf("call insertUserInfo('%s',%d,%d,'%s');", #               # 所以直接将序列化后的结果存进去吧,
                $req->uid, $req->zoneid, $tsday, $value);                       # zoneid, uid, tsday
        daoInst()->query($sql);                                                 # 也可以用exec($sql)
    }

// </editor-fold>
//</editor-fold>
//
}

//
// <editor-fold defaultstate="collapsed" desc="测试/送审=>注册新用户的业务逻辑">

/**
 * 注册新用户
 * @author gwang
 */
class RegNewUser {

    /**
     * 查找已有用户
     */
    const SQL_SelectUser = "Select tid,pwd from `tab_register` where `userName`='%s' order by tid limit 1;";

    /**
     * 插入新用户, Ps 常量字符串只能这么写了
     */
    const SQL_InsertNewUser = <<<sql
        Insert Into `tab_register` ( `userName`, `pwd`, `mail`, `phoneNumber`) values ( '%s', '%s', '%s', '%s');
sql;

    /**
     *  写用户信息到数据库
     * @param string $userName
     * @param string $pwd
     * @param string $email
     * @param string $phoneNumber
     * @return array
     */
    public static function Write2MysqlUserInfo($userName, $pwd, $email = "", $phoneNumber = "") {
        $paydb = CPayInit();
        $sql_sel = sprintf(self::SQL_SelectUser, $userName);
        $data = $paydb->fetch_result($sql_sel);
        if (count($data) > 0) {                                                 # 已经有用户了,那么注册失败.
            return array('ret' => -1, 'msg' => "这个账号已经注册过了.");
        }                                                                       # 尚未注册, 继续执行
        $sql_insert = sprintf(self::SQL_InsertNewUser, $userName, $pwd, $email, $phoneNumber);
        if (false === $paydb->query($sql_insert)) {                             # 插入用户信息
            return array('ret' => -1, 'msg' => "数据插入失败,请重试.");
        }
        $ret = array('ret' => 0, 'msg' => "注册成功.");                          # 插入成功, 返回
        $paydb->close();
        return $ret;
    }

    /**
     * 验证用户名和密码
     * @param type $userName
     * @param type $pwd
     */
    public static function VerifyUserPwd($userName, $pwd) {
        $paydb = CPayInit();
        $sql_sel = sprintf(self::SQL_SelectUser, $userName);
        $data = $paydb->fetch_result($sql_sel);
        $paydb->close();
        if (count($data) > 0) {
            if ($data[0]["pwd"] == $pwd) {                                      # 验证成功
                return array('ret' => 0, 'msg' => "通过.");
            } else {
                return array('ret' => -1, 'msg' => "密码错误.");
            }
        }
        return array('ret' => -1, 'msg' => "账号不存在.");
    }

}

// </editor-fold>
//