public UserRankValue InitRankValue(RankDataKey key)
{
DBManager dbMgr = DBManager.getInstance();
UserRankValue result;
if (null == dbMgr)
{
result = null;
}
else
{
UserRankValue DBRankValue = null;
if (RankType.Charge == key.rankType)
{
DBRoleInfo roleInfo = dbMgr.GetDBRoleInfo(ref this.roleID);
if (null != roleInfo)
{
DBRankValue = this.GetUserInputRankVaule(dbMgr, roleInfo.UserID, roleInfo.ZoneID, key.StartDate, key.EndDate);
}
}
else if (RankType.Consume == key.rankType)
{
DBRankValue = this.GetUserConsumeRankValue(dbMgr, key.StartDate, key.EndDate);
}
result = DBRankValue;
}
return(result);
}
public RankData GetRankData(RankDataKey key, List <int> minGateValueList, int maxPaiHang)
{
DBManager dbMgr = DBManager.getInstance();
RankData result;
if (null == dbMgr)
{
result = null;
}
else
{
double currSecond = Global.GetOffsetSecond(DateTime.Now);
RankData tmpRankData = this.GetRankDataFromCache(key);
if (null != tmpRankData)
{
double endTime = Global.GetOffsetSecond(DateTime.Parse(key.EndDate));
if (endTime >= currSecond)
{
return(tmpRankData);
}
if (tmpRankData.QueryFromDBTime > endTime)
{
return(tmpRankData);
}
}
lock (this.RankDataDictLock)
{
tmpRankData = this.InitRankData(key, minGateValueList, maxPaiHang);
this.RankDataDict[key.GetKey()] = tmpRankData;
result = tmpRankData;
}
}
return(result);
}
private UserRankValue GetRankValueStruct(RankDataKey key)
{
double currSecond = Global.GetOffsetSecond(DateTime.Now);
UserRankValue tmpRankData = this.GetRankValueFromCache(key);
if (null != tmpRankData)
{
if (tmpRankData.EndTime >= currSecond)
{
return(tmpRankData);
}
if (tmpRankData.QueryFromDBTime > tmpRankData.EndTime)
{
return(tmpRankData);
}
}
UserRankValue result;
lock (UserRankValueCache.UserRankValueDictLock)
{
tmpRankData = this.InitRankValue(key);
this.DictUserRankValue[key.GetKey()] = tmpRankData;
result = tmpRankData;
}
return(result);
}
public static RankDataKey GetKeyFromStr(string key)
{
string[] fields = key.Split(new char[]
{
RankDataKey.SplitChar
});
RankDataKey result;
if (fields == null || fields.Length < 3)
{
result = null;
}
else
{
RankDataKey rankDataKey = new RankDataKey();
rankDataKey.rankType = (RankType)Global.SafeConvertToInt32(fields[0], 10);
rankDataKey.StartDate = fields[1];
rankDataKey.EndDate = fields[2];
for (int i = 3; i < fields.Length; i++)
{
if (null == rankDataKey.minGateValueList)
{
rankDataKey.minGateValueList = new List <int>();
}
rankDataKey.minGateValueList.Add(int.Parse(fields[i]));
}
result = rankDataKey;
}
return(result);
}
public void OnUserDoSomething(int roleID, RankType rankType, int value)
{
DBManager dbMgr = DBManager.getInstance();
if (null != dbMgr)
{
DBRoleInfo roleInfo = dbMgr.GetDBRoleInfo(ref roleID);
if (null != roleInfo)
{
double currSecond = Global.GetOffsetSecond(DateTime.Now);
roleInfo.RankValue.AddUserRankValue(rankType, value);
lock (this.RankDataDictLock)
{
foreach (KeyValuePair <string, RankData> item in this.RankDataDict)
{
RankDataKey rankDataKey = RankDataKey.GetKeyFromStr(item.Key);
if (null != rankDataKey)
{
if (rankType == rankDataKey.rankType)
{
double startTime = Global.GetOffsetSecond(DateTime.Parse(rankDataKey.StartDate));
double endTime = Global.GetOffsetSecond(DateTime.Parse(rankDataKey.EndDate));
if (currSecond >= startTime && currSecond <= endTime)
{
bool bExist = false;
foreach (InputKingPaiHangData rankData in item.Value.RankDataList)
{
if ((RankType.Charge == rankType && rankData.UserID == roleInfo.UserID) || (RankType.Consume == rankType && rankData.UserID == roleInfo.RoleID.ToString()))
{
rankData.PaiHangTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
rankData.PaiHangValue += value;
bExist = true;
break;
}
}
if (!bExist)
{
int userRankValue = roleInfo.RankValue.GetRankValue(rankDataKey);
InputKingPaiHangData phData = new InputKingPaiHangData
{
UserID = ((RankType.Charge == rankType) ? roleInfo.UserID : roleInfo.RoleID.ToString()),
PaiHang = 0,
PaiHangTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
PaiHangValue = userRankValue
};
item.Value.RankDataList.Add(phData);
}
this.BuildRank(item.Value);
}
}
}
}
}
}
}
}
public RankData GetRankDataFromCache(RankDataKey key)
{
RankData tmpRankData = null;
lock (this.RankDataDictLock)
{
if (this.RankDataDict.ContainsKey(key.GetKey()))
{
tmpRankData = this.RankDataDict[key.GetKey()];
}
}
return(tmpRankData);
}
public UserRankValue GetRankValueFromCache(RankDataKey key)
{
UserRankValue tmpRankData = null;
lock (UserRankValueCache.UserRankValueDictLock)
{
if (this.DictUserRankValue.ContainsKey(key.GetKey()))
{
tmpRankData = this.DictUserRankValue[key.GetKey()];
}
}
return(tmpRankData);
}
public int AddUserRankValue(RankType ActType, int addValue)
{
double currSecond = Global.GetOffsetSecond(DateTime.Now);
lock (UserRankValueCache.UserRankValueDictLock)
{
foreach (KeyValuePair <string, UserRankValue> item in this.DictUserRankValue)
{
RankDataKey key = RankDataKey.GetKeyFromStr(item.Key.ToString());
if (null != key)
{
double startTime = Global.GetOffsetSecond(DateTime.Parse(key.StartDate));
double endTime = Global.GetOffsetSecond(DateTime.Parse(key.EndDate));
if (ActType == key.rankType && currSecond >= startTime && currSecond <= endTime)
{
item.Value.RankValue += addValue;
}
}
}
}
lock (this.UserChargeMoneyCountDicLock)
{
foreach (KeyValuePair <string, Dictionary <int, int> > item2 in this.ChargeMoneyCountDic)
{
RankDataKey key = RankDataKey.GetKeyFromStr(item2.Key.ToString());
if (null != key)
{
double startTime = Global.GetOffsetSecond(DateTime.Parse(key.StartDate));
double endTime = Global.GetOffsetSecond(DateTime.Parse(key.EndDate));
if (ActType == key.rankType && currSecond >= startTime && currSecond <= endTime)
{
if (item2.Value.ContainsKey(addValue))
{
Dictionary <int, int> value;
(value = item2.Value)[addValue] = value[addValue] + 1;
}
else
{
item2.Value[addValue] = 1;
}
}
}
}
}
return(0);
}
public Dictionary <int, int> GetUserInputMoneyCount(DBManager dbMgr, string userid, int zoneid, string fromDate, string toDate)
{
RankDataKey rankDataKey = new RankDataKey
{
rankType = RankType.Charge,
StartDate = fromDate,
EndDate = toDate
};
Dictionary <int, int> retDic = null;
lock (this.UserChargeMoneyCountDicLock)
{
if (this.ChargeMoneyCountDic.TryGetValue(rankDataKey.GetKey(), out retDic))
{
return(new Dictionary <int, int>(retDic));
}
retDic = DBQuery.GetUserDanBiInputMoneyCount(dbMgr, userid, zoneid, fromDate, toDate);
this.ChargeMoneyCountDic[rankDataKey.GetKey()] = retDic;
}
return(new Dictionary <int, int>(retDic));
}
public RankData InitRankData(RankDataKey key, List <int> minGateValueList, int maxPaiHang)
{
DBManager dbMgr = DBManager.getInstance();
RankData result;
if (null == dbMgr)
{
result = null;
}
else
{
RankData DBRankData = null;
if (RankType.Charge == key.rankType)
{
DBRankData = this.GetUserInputRank(dbMgr, key.StartDate, key.EndDate, minGateValueList, maxPaiHang);
}
else if (RankType.Consume == key.rankType)
{
DBRankData = this.GetUserConsumeRank(dbMgr, key.StartDate, key.EndDate, minGateValueList, maxPaiHang);
}
result = DBRankData;
}
return(result);
}
public int GetRankValue(RankDataKey key)
{
UserRankValue tmpRankData = this.GetRankValueStruct(key);
return((tmpRankData == null) ? 0 : tmpRankData.RankValue);
}
