You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
740 lines
29 KiB
740 lines
29 KiB
|
|
using Sog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using ProtoCSStruct;
|
|
using System.Linq;
|
|
using StackExchange.Redis;
|
|
|
|
namespace DB
|
|
{
|
|
public partial class RedisDBOperator : DBOperator
|
|
{
|
|
public RedisDB m_redisDB;
|
|
|
|
public RedisDBOperator(string dbname, string ip, string user, string password)
|
|
{
|
|
m_redisDB = new RedisDB(dbname, ip, password);
|
|
}
|
|
|
|
public override void Dispose()
|
|
{
|
|
if (m_redisDB != null)
|
|
{
|
|
m_redisDB.Dispose();
|
|
m_redisDB = null;
|
|
}
|
|
}
|
|
|
|
public override void KeepAlive()
|
|
{
|
|
var latency = m_redisDB.Ping();
|
|
TraceLog.Trace("RedisDBOperator.KeepAlive exec at {0} latency {1}ms", DateTime.Now, latency.Milliseconds);
|
|
}
|
|
|
|
//================================================================================ tbaccount
|
|
|
|
private string GetAccount_StringKey(int accountType, string accountID)
|
|
{
|
|
return m_redisDB.CreateKey("string:tbaccount:account", accountType.ToString(), accountID);
|
|
}
|
|
|
|
public override tbAccount QueryAccount(int accountType, string accountID)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.QueryAccount type {0} accountid {1}", accountType, accountID);
|
|
return m_redisDB.StringGet<tbAccount>(GetAccount_StringKey(accountType, accountID));
|
|
}
|
|
|
|
public override bool UpdateAccountLastLoginRealm(int accountType, string accountID, tbAccount accountRecord, int lastLoginRealm)
|
|
{
|
|
accountRecord.LastLoginRealm = lastLoginRealm;
|
|
bool ret = m_redisDB.StringSet<tbAccount>(GetAccount_StringKey(accountType, accountID), accountRecord);
|
|
if (ret)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.UpdateAccountLastLoginRealm type {0} accountid {1} succ", accountType, accountID);
|
|
}
|
|
else
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccountLastLoginRealm type {0} accountid {1} fail", accountType, accountID);
|
|
}
|
|
return ret;
|
|
|
|
}
|
|
|
|
public override bool UpdateAccountGrade(int accountType, string accountID, tbAccount accountRecord, int Grade)
|
|
{
|
|
accountRecord.Grade = Grade;
|
|
bool ret = m_redisDB.StringSet<tbAccount>(GetAccount_StringKey(accountType, accountID), accountRecord);
|
|
if (ret)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.UpdateAccountComment type {0} accountid {1} succ", accountType, accountID);
|
|
}
|
|
else
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccountComment type {0} accountid {1} fail", accountType, accountID);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public override bool UpdateAccountExData(int accountType, string accountID, tbAccount accountRecord, ref DBAccountExData exdata)
|
|
{
|
|
accountRecord.exData = StructMessageParseUtils.ToByteArray<DBAccountExData>(ref exdata);
|
|
bool ret = m_redisDB.StringSet<tbAccount>(GetAccount_StringKey(accountType, accountID), accountRecord);
|
|
if (ret)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.UpdateAccountExData type {0} accountid {1} succ", accountType, accountID);
|
|
}
|
|
else
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccountExData type {0} accountid {1} fail", accountType, accountID);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public override bool InsertAccount(int accountType, string accountID, string accountToken, long createTime,
|
|
string deviceId, uint ipAddr, string nick, int gender, string icon, int grade, ref DBAccountExData exData)
|
|
{
|
|
var accountRecord = new tbAccount
|
|
{
|
|
AccountType = accountType,
|
|
AccountID = accountID,
|
|
AccountToken = accountToken,
|
|
CreateTime = createTime,
|
|
CreateDeviceID = deviceId,
|
|
CreateIpAddr = ipAddr,
|
|
Nick = nick,
|
|
Gender = gender,
|
|
Icon = icon,
|
|
Grade = grade,
|
|
exData = StructMessageParseUtils.ToByteArray<DBAccountExData>(ref exData),
|
|
};
|
|
bool result = m_redisDB.StringSet(GetAccount_StringKey(accountType, accountID), accountRecord);
|
|
if (result)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.InsertAccount type {0} accountid {1} succ", accountType, accountID);
|
|
}
|
|
else
|
|
{
|
|
TraceLog.Error("RedisDBOperator.InsertAccount type {0} accountid {1} fail", accountType, accountID);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
//================================================================================ tbuid
|
|
|
|
private string GetUid_StringKey(int accountTableIndex)
|
|
{
|
|
return m_redisDB.CreateKey("string:tbuid:account", accountTableIndex.ToString());
|
|
}
|
|
|
|
private bool GetLastGameId(int accountTableIndex, out long lastUid)
|
|
{
|
|
lastUid = 0;
|
|
string uidStr = m_redisDB.StringGet<string>(GetUid_StringKey(accountTableIndex));
|
|
if (string.IsNullOrEmpty(uidStr))
|
|
{
|
|
return false;
|
|
}
|
|
lastUid = long.Parse(uidStr);
|
|
return true;
|
|
}
|
|
|
|
private bool SetNewGameId(int accountTableIndex, long newUid)
|
|
{
|
|
if (!m_redisDB.StringSet(GetUid_StringKey(accountTableIndex), newUid.ToString()))
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SetnewUid insert to tbuid failed, subIndex {0}", accountTableIndex);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override long GenNewGameID(int accountTableIndex)
|
|
{
|
|
long newUid = 0;
|
|
string lastUidStr = m_redisDB.StringGet<string>(GetUid_StringKey(accountTableIndex));
|
|
if (string.IsNullOrEmpty(lastUidStr))
|
|
{
|
|
newUid = 100000 + accountTableIndex;
|
|
}
|
|
else
|
|
{
|
|
var lastUid = long.Parse(lastUidStr);
|
|
newUid = lastUid + TableIndexCalc.AccountTableCount;
|
|
}
|
|
|
|
if (!m_redisDB.StringSet(GetUid_StringKey(accountTableIndex), newUid.ToString()))
|
|
{
|
|
TraceLog.Error("RedisDBOperator.GenNewGameID insert to tbuid failed, subIndex {0}", accountTableIndex);
|
|
return 0;
|
|
}
|
|
|
|
TraceLog.Trace("RedisDBOperator.GenNewGameID update tbuid {0} succ", newUid);
|
|
return newUid;
|
|
}
|
|
|
|
|
|
//================================================================================ tbacc_realmuid_link
|
|
|
|
// ["tbacc_realmuid_link:UID{0}"] = tbacc_realmuid_link
|
|
private string GetUid2AccRealmuidLink_StringKey<T>(T uid)
|
|
{
|
|
return m_redisDB.CreateKey("string:tbacc_realmuid_link:uid", uid.ToString());
|
|
}
|
|
// ["tbacc_realmuid_link:{0}:{1}"] = [realmId] = uid // todo : u2一个区只有一个uid 可以这样，其他游戏多角色可以改数组
|
|
private string GetAccRealmuidLink_HashKey(int accountType, string accountID)
|
|
{
|
|
return m_redisDB.CreateKey("hash:tbacc_realmuid_link:account", accountType.ToString(), accountID);
|
|
}
|
|
|
|
public override List<tbacc_realmuid_link> QueryAccountUid(int accountType, string accountID, int realmId)
|
|
{
|
|
if (realmId == 0)
|
|
{
|
|
return QueryAccountUidAll(accountType, accountID);
|
|
}
|
|
else
|
|
{
|
|
return QueryAccountUidOneRealm(accountType, accountID, realmId);
|
|
}
|
|
}
|
|
|
|
private List<tbacc_realmuid_link> QueryAccountUidAll(int accountType, string accountID)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.QueryAccountUidAll accountType {0} accountId {1}", accountType, accountID);
|
|
|
|
List<tbacc_realmuid_link> accountUids = new List<tbacc_realmuid_link>();
|
|
var realmToUids = m_redisDB.HashGetAll(GetAccRealmuidLink_HashKey(accountType, accountID));
|
|
foreach (var item in realmToUids)
|
|
{
|
|
var tmp = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(item.Value));
|
|
if (tmp == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.QueryAccountUidAll accountType {0} accountID {1} realmId {2} uid {3} fail"
|
|
, accountType, accountID, item.Name, item.Value);
|
|
continue;
|
|
}
|
|
accountUids.Add(tmp);
|
|
}
|
|
return accountUids;
|
|
}
|
|
|
|
private List<tbacc_realmuid_link> QueryAccountUidOneRealm(int accountType, string accountID, int realmId)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.QueryAccountUidOneRealm accountType {0} accountId {1} realmId {2}", accountType, accountID, realmId);
|
|
|
|
var uidStr = (string)m_redisDB.HashGet<string>(GetAccRealmuidLink_HashKey(accountType, accountID), realmId.ToString());
|
|
if (uidStr == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.QueryAccountUid accountType {0} accountID {1} realmId {2} fail"
|
|
, accountType, accountID, realmId);
|
|
return null;
|
|
}
|
|
|
|
var tmp = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uidStr));
|
|
if (tmp == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.QueryAccountUidAll accountType {0} accountID {1} realmId {2} uid {3} fail"
|
|
, accountType, accountID, realmId, uidStr);
|
|
return null;
|
|
}
|
|
return new List<tbacc_realmuid_link> { tmp };
|
|
}
|
|
|
|
public override bool InsertAccRealmUidLink(int accountType, string accountId, int realmId, long uid)
|
|
{
|
|
long lNow = DBServerUtils.GetTimeSecond();
|
|
|
|
tbacc_realmuid_link accountData = new tbacc_realmuid_link
|
|
{
|
|
accountType = accountType,
|
|
accountId = accountId,
|
|
realmId = realmId,
|
|
uid = uid,
|
|
lastLoginTime = lNow
|
|
};
|
|
|
|
bool resStr = m_redisDB.StringSet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uid), accountData);
|
|
if (!resStr)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.InsertAccRealmUidLink type {0} accountid {1} realm {2} uid {3} fail"
|
|
, accountType, accountId, realmId, uid);
|
|
return false;
|
|
}
|
|
|
|
bool resHash = m_redisDB.HashSet(GetAccRealmuidLink_HashKey(accountType, accountId), realmId.ToString(), uid);
|
|
if (!resHash)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.InsertAccRealmUidLink type {0} accountid {1} realm {2} uid {3} fail"
|
|
, accountType, accountId, realmId, uid);
|
|
return false;
|
|
}
|
|
TraceLog.Trace("RedisDBOperator.InsertAccRealmUidLink type {0} accountid {1} realm {2} uid {3} succ"
|
|
, accountType, accountId, realmId, uid);
|
|
|
|
return true;
|
|
}
|
|
|
|
public override bool UpdateAccRealmUidLink(int accountType, string accountID, ref CSRoleBrief roleBrief)
|
|
{
|
|
long uid = roleBrief.Uid;
|
|
string Nick = roleBrief.Nick.GetString();
|
|
string Icon = roleBrief.Icon.GetString();
|
|
int Level = roleBrief.Level;
|
|
int IconFramId = roleBrief.IconFrameId;
|
|
long lastLoginTime = roleBrief.LastLoginTime;
|
|
|
|
var realmToUids = m_redisDB.HashGetAll(GetAccRealmuidLink_HashKey(accountType, accountID));
|
|
foreach (var item in realmToUids)
|
|
{
|
|
if (long.Parse(item.Value) == uid)
|
|
{
|
|
var record = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uid));
|
|
if (record == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} uid {2} no record",
|
|
accountType, accountID, uid);
|
|
return false;
|
|
}
|
|
|
|
record.nick = Nick;
|
|
record.icon = Icon;
|
|
record.level = Level;
|
|
record.iconFrameId = IconFramId;
|
|
record.lastLoginTime = lastLoginTime;
|
|
|
|
var res = m_redisDB.StringSet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uid), record);
|
|
if (! res)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} fail"
|
|
, accountType, accountID);
|
|
return false;
|
|
}
|
|
|
|
TraceLog.Trace("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} succ", accountType, accountID);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool UpdateAccRealmLinkUid(int accountType, string accountID, int realmId, long newUid)
|
|
{
|
|
var oldUid = m_redisDB.HashGet<long>(GetAccRealmuidLink_HashKey(accountType, accountID), realmId.ToString());
|
|
if (oldUid == 0)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} get realm_uid fail", accountType, accountID);
|
|
return false;
|
|
}
|
|
if (oldUid == newUid)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
var accountUidInfo = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(oldUid));
|
|
if (accountUidInfo == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} add newUid fail", accountType, accountID);
|
|
return false;
|
|
}
|
|
accountUidInfo.uid = newUid;
|
|
|
|
var resAdd = m_redisDB.StringSet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(newUid), accountUidInfo);
|
|
if (!resAdd)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} add newUid fail", accountType, accountID);
|
|
return false;
|
|
}
|
|
|
|
var resHashAdd = m_redisDB.HashSet<long>(GetAccRealmuidLink_HashKey(accountType, accountID), realmId.ToString(), newUid);
|
|
if (!resHashAdd)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} realmId {2} add newUid {3} hash fail",
|
|
accountType, accountID, realmId, newUid);
|
|
return false;
|
|
}
|
|
|
|
bool delOldStr = m_redisDB.KeyDelete(GetUid2AccRealmuidLink_StringKey(oldUid));
|
|
if (!delOldStr)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLink type {0} accountid {1} realm {2} uid {3} del olduid fail"
|
|
, accountType, accountID, realmId, newUid);
|
|
}
|
|
|
|
TraceLog.Trace("RedisDBOperator.UpdateAccRealmLinkUid type {0} accountid {1} new uid {2} succ"
|
|
, accountType, accountID, newUid);
|
|
return true;
|
|
}
|
|
|
|
public override void QueryRealmUidData(int realmId, ref SSQueryRealmUidDataRes res)
|
|
{
|
|
//todo 支持redis
|
|
res.Ret = 0;
|
|
res.RealmId = realmId;
|
|
}
|
|
|
|
public override int SaveRealmUidData(ref SSSaveRealmUidDataReq req)
|
|
{
|
|
//todo 支持redis
|
|
return 0;
|
|
}
|
|
|
|
public override void QueryRealmDBData(ref SSRealmDBQueryRes res)
|
|
{
|
|
TraceLog.Trace("RedisDBOperator.QueryRealmDBData All realm");
|
|
res.Ret = 0;
|
|
}
|
|
|
|
public override int UpdateRealmPlayerNum(int realmId, int regNum)
|
|
{
|
|
return 0;
|
|
}
|
|
public override int UpdateRealmDBData(ref SSRealmDBSaveReq req, ref SSRealmDBSaveRes res)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//public override bool UpdateAccRealmUidLinkLogoutTime(int accountType, string accountID,
|
|
// int realmId, long uid, int lastLogoutTime)
|
|
//{
|
|
// var record = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uid));
|
|
// if (record == null)
|
|
// {
|
|
// TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLinkLogoutTime uid {0} no record", uid);
|
|
// return false;
|
|
// }
|
|
|
|
// record.lastLogoutTime = lastLogoutTime;
|
|
// var res = m_redisDB.StringSet(GetUid2AccRealmuidLink_StringKey(uid), record);
|
|
// if (! res)
|
|
// {
|
|
// TraceLog.Error("RedisDBOperator.UpdateAccRealmUidLinkLogoutTime uid {0} fail", uid);
|
|
// return false;
|
|
// }
|
|
|
|
// TraceLog.Trace("RedisDBOperator.UpdateAccRealmUidLinkLogoutTime uid {0} lastLogoutTime {1} succ", uid, lastLogoutTime);
|
|
// return true;
|
|
//}
|
|
|
|
|
|
public override tbacc_realmuid_link QueryAccountUidbyUid(int uid, int realmId)
|
|
{
|
|
var accountUidInfo = m_redisDB.StringGet<tbacc_realmuid_link>(GetUid2AccRealmuidLink_StringKey(uid));
|
|
if (accountUidInfo == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.QueryAccountUidbyUid uid {0} fail", uid);
|
|
return null;
|
|
}
|
|
|
|
return accountUidInfo;
|
|
}
|
|
|
|
|
|
//================================================================================ tbpay
|
|
|
|
private string GetPay_OrderId_StringKey(string orderId)
|
|
{
|
|
return m_redisDB.CreateKey("string:tbpay:orderId", orderId);
|
|
}
|
|
private string GetPay_uidStatus2OrderId_ListKey(long uid, int status = 1)
|
|
{
|
|
return m_redisDB.CreateKey("list:tbpay:uidStatus2OrderId", uid.ToString(), status.ToString());
|
|
}
|
|
|
|
private void Delete_UidStatus2OrderId_List(long uid, int status, string orderId)
|
|
{
|
|
if (status != 1)
|
|
{
|
|
return;
|
|
}
|
|
var removeCount = m_redisDB.ListRemove(GetPay_uidStatus2OrderId_ListKey(uid, status), orderId);
|
|
TraceLog.Debug("RedisDBOperator.Delete_UidStatus2OrderId_List delete list uid {0} status {1} orderId {2} removeCount {3}",
|
|
uid, status, orderId, removeCount);
|
|
}
|
|
private void Insert_UidStatus2OrderId_List(long uid, int status, string orderId)
|
|
{
|
|
if (status != 1)
|
|
{
|
|
return;
|
|
}
|
|
m_redisDB.ListLeftPush(GetPay_uidStatus2OrderId_ListKey(uid, status), orderId);
|
|
TraceLog.Debug("RedisDBOperator.Insert_UidStatus2OrderId_List insert list uid {0} status {1} orderId {2}", uid, status, orderId);
|
|
}
|
|
private void UpdatePay_UidStatus2OrderId_List(tbpay record, int oldStatus)
|
|
{
|
|
if (oldStatus == record.Status)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Delete_UidStatus2OrderId_List(record.Uid, oldStatus, record.OrderID);
|
|
Insert_UidStatus2OrderId_List(record.Uid, record.Status, record.OrderID);
|
|
}
|
|
private bool InsertPay(tbpay record)
|
|
{
|
|
Insert_UidStatus2OrderId_List(record.Uid, record.Status, record.OrderID);
|
|
|
|
bool ret = m_redisDB.StringSet<tbpay>(GetPay_OrderId_StringKey(record.OrderID), record);
|
|
if (!ret)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool InsertPayReq(ref SSPayGoogleReq payReq)
|
|
{
|
|
tbpay record = new tbpay()
|
|
{
|
|
OrderID = payReq.OrderId.GetString(),
|
|
PayType = payReq.PayType,
|
|
ProductID = payReq.ItemID,
|
|
PayTime3rd = DBServerUtils.GetTimeSecond(),
|
|
Uid = payReq.Uid,
|
|
Money = payReq.Money
|
|
};
|
|
|
|
if (!InsertPay(record))
|
|
{
|
|
TraceLog.Error("RedisDBOperator.InsertPayReq uid {0} orderid {1} insert fail", payReq.Uid, payReq.OrderId);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override tbpay SelectPayRecord(long uid, string orderId)
|
|
{
|
|
tbpay tbRecord = m_redisDB.StringGet<tbpay>(GetPay_OrderId_StringKey(orderId));
|
|
if (tbRecord == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SelectPayRecord no record orderid {0}", orderId);
|
|
return null;
|
|
}
|
|
|
|
TraceLog.Trace("RedisDBOperator.SelectPayRecord query success uid {0} status {1} money {2} payType {3} orderId3rd {4} isTestPay {5}"
|
|
, tbRecord.Uid, tbRecord.Status, tbRecord.Money, tbRecord.PayType
|
|
, tbRecord.OrderId3rd, tbRecord.IsTestPay);
|
|
|
|
return tbRecord;
|
|
}
|
|
|
|
public override List<tbpay> SelectPaySuccRecord(long uid)
|
|
{
|
|
// 以防万一, 只返回前10条记录, 应该不会出现连充10笔订单没有到账还继续充的人吧
|
|
var payList = m_redisDB.ListRange(GetPay_uidStatus2OrderId_ListKey(uid, 1), 0, 10);
|
|
if (payList.Count() <= 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var resultList = new List<tbpay>();
|
|
foreach (var orderId in payList)
|
|
{
|
|
var record = m_redisDB.StringGet<tbpay>(GetPay_OrderId_StringKey(orderId));
|
|
if (record == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SelectPaySuccRecord get orderId {0} fail!", orderId);
|
|
continue;
|
|
}
|
|
resultList.Add(record);
|
|
}
|
|
return resultList;
|
|
}
|
|
|
|
public override tbpay SelectPayRecordByOrderId3rd(long uid, string orderId3rd)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
public override bool UpdatePayProductId(long uid, string orderId, int productId)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool UpdatePayStatus(long uid, string orderId, int newStatus, uint amountExchange, uint diamondExchange, int newItemId, uint money)
|
|
{
|
|
tbpay pay = m_redisDB.StringGet<tbpay>(GetPay_OrderId_StringKey(orderId));
|
|
if (pay == null)
|
|
{
|
|
return false;
|
|
}
|
|
int oldStatus = pay.Status;
|
|
|
|
pay.Status = newStatus;
|
|
pay.AmountExchange = amountExchange;
|
|
pay.DiamondExchange = diamondExchange;
|
|
pay.Money = money;
|
|
if (newItemId != 0)
|
|
{
|
|
pay.ProductID = newItemId;
|
|
}
|
|
|
|
UpdatePay_UidStatus2OrderId_List(pay, oldStatus);
|
|
bool ret = m_redisDB.StringSet<tbpay>(GetPay_OrderId_StringKey(orderId), pay);
|
|
if (!ret)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdatePayStatus uid {0} orderid {1} insert fail", uid, orderId);
|
|
return false;
|
|
}
|
|
TraceLog.Debug("RedisDBOperator.UpdatePayStatus orderid {0} status {1} to table success", orderId, newStatus);
|
|
return true;
|
|
}
|
|
|
|
public override bool UpdatePayStatus(long uid, string orderId, int newStatus, string orderId3rd, long lTime,
|
|
uint amount, bool isTestPay, string currency, int subPayType)
|
|
{
|
|
tbpay record = m_redisDB.StringGet<tbpay>(GetPay_OrderId_StringKey(orderId));
|
|
if (record == null)
|
|
{
|
|
return false;
|
|
}
|
|
int oldStatus = record.Status;
|
|
|
|
record.Status = newStatus;
|
|
record.PayTime3rd = lTime;
|
|
record.Amount = amount;
|
|
record.IsTestPay = (isTestPay ? 1 : 0);
|
|
record.OrderId3rd = orderId3rd;
|
|
record.Currency = currency;
|
|
record.SubPayType = subPayType;
|
|
|
|
UpdatePay_UidStatus2OrderId_List(record, oldStatus);
|
|
bool ret = m_redisDB.StringSet<tbpay>(GetPay_OrderId_StringKey(orderId), record);
|
|
if (!ret)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.UpdatePayStatus newStatus {0} orderid {1} insert fail", newStatus, orderId);
|
|
return false;
|
|
}
|
|
TraceLog.Debug("RedisDBOperator.UpdatePayStatus orderid {0} status {1} to table success", orderId, newStatus);
|
|
return true;
|
|
}
|
|
|
|
public override bool SetRefundTime(long uid, string orderId, string orderId3rd, long refundTime)
|
|
{
|
|
tbpay tbRecord = m_redisDB.StringGet<tbpay>(GetPay_OrderId_StringKey(orderId));
|
|
if (tbRecord == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SetRefundTime no record orderid {0}", orderId);
|
|
return false;
|
|
}
|
|
if (tbRecord.OrderId3rd != orderId3rd)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SetRefundTime record orderId3rd not equal orderId {0} orderId3rd {1}", orderId, orderId3rd);
|
|
return false;
|
|
}
|
|
tbRecord.RefundTime = refundTime;
|
|
|
|
bool ret = m_redisDB.StringSet<tbpay>(GetPay_OrderId_StringKey(orderId), tbRecord);
|
|
if (!ret)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SetRefundTime orderid {1} fail", orderId);
|
|
return false;
|
|
}
|
|
TraceLog.Trace("RedisDBOperator.SetRefundTime orderid {0} success", orderId);
|
|
|
|
return true;
|
|
}
|
|
|
|
public override Tuple<int, List<SSUserPayRecordOne>> SelectAllPayRecords(SSGmQueryUserPayRecordReq req)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
|
|
//================================================================================ tbpay_http
|
|
|
|
private string GetPayHttp_StringKey(string orderId)
|
|
{
|
|
return m_redisDB.CreateKey("string:tbpay_http:orderId", orderId);
|
|
}
|
|
private string GetPayHttp_ListKey()
|
|
{
|
|
return m_redisDB.CreateKey("list:tbpay_http");
|
|
}
|
|
|
|
public override bool ReplacePayHttpContent(ref SSPayHeroSaveHttpContentReq req)
|
|
{
|
|
string orderId = req.Http.OrderId.GetString();
|
|
tbpay_http patHttp = new tbpay_http
|
|
{
|
|
OrderId = orderId,
|
|
Uid = req.Http.Uid,
|
|
IsTestPay = req.Http.IsTestPay,
|
|
Method = req.Http.Method,
|
|
Url = req.Http.Url.GetString(),
|
|
Content = req.Http.Content.GetString(),
|
|
};
|
|
|
|
bool setResult = m_redisDB.StringSet<tbpay_http>(GetPayHttp_StringKey(orderId), patHttp);
|
|
if (!setResult)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.ReplacePayHttpContent orderId {0} ret {1}", orderId, setResult);
|
|
return false;
|
|
}
|
|
TraceLog.Trace("RedisDBOperator.ReplacePayHttpContent orderId {0} ret {1}", orderId, setResult);
|
|
|
|
// 尝试移除list中的订单查找表
|
|
try
|
|
{
|
|
m_redisDB.ListRemove(GetPayHttp_ListKey(), orderId, 1);
|
|
m_redisDB.ListLeftPush(GetPayHttp_ListKey(), orderId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TraceLog.Exception(ex);
|
|
TraceLog.Exception(ex.InnerException);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override void SelectPayHttpContent(ref SSPayHeroSelectHttpContentRes res)
|
|
{
|
|
var orders = m_redisDB.ListRange(GetPayHttp_ListKey(), 0, 10);
|
|
if (orders.Count() <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (var orderId in orders)
|
|
{
|
|
var payHttp = m_redisDB.StringGet<tbpay_http>(GetPayHttp_StringKey(orderId));
|
|
if (payHttp == null)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.SelectPayHttpContent get orderId {0} fail!", orderId);
|
|
continue;
|
|
}
|
|
|
|
var http = new SSHttpRequest();
|
|
http.Method = payHttp.Method;
|
|
http.IsTestPay = payHttp.IsTestPay;
|
|
http.Uid = payHttp.Uid;
|
|
http.OrderId.SetString(orderId);
|
|
http.Url.SetString(payHttp.Url);
|
|
http.Content.SetString(payHttp.Content);
|
|
res.Http.Add(ref http);
|
|
TraceLog.Trace("RedisDBOperator.SelectPayHttpContent orderId {0}", orderId);
|
|
}
|
|
}
|
|
|
|
public override void DeletePayHttpContent(ref SSPayHeroDeleteHttpContentNotify notify)
|
|
{
|
|
string orderId = notify.OrderId.GetString();
|
|
bool ret = m_redisDB.KeyDelete(GetPayHttp_StringKey(orderId));
|
|
var rm = m_redisDB.ListRemove(GetPayHttp_ListKey(), orderId);
|
|
if (!ret)
|
|
{
|
|
TraceLog.Error("RedisDBOperator.DeletePayHttpContent orderId {0} ret {1} rm list {2}", orderId, ret, rm);
|
|
}
|
|
else
|
|
{
|
|
TraceLog.Debug("RedisDBOperator.DeletePayHttpContent orderId {0} ret {1} rm list {2}", orderId, ret, rm);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|