/// <summary>
/// 是否注销经销商
/// </summary>
/// <returns></returns>
public JsonResult IsResAgent()
{
try
{
var userId = PreconditionAssert.IsNotEmptyString(Request["userId"], "用户编号不能为空");
var status = PreconditionAssert.IsNotEmptyString(Request["status"], "状态不能为空");
var result = ExternalClient.IsOffUserAgent(userId, status.Contains("0"));
if (result.ReturnValue.Equals("true"))
{
return(Json(new CommonResult {
code = (int)ResultCodeEnum.OK, message = result.Message
}));
}
else
{
return(Json(new CommonResult {
code = (int)ResultCodeEnum.APIError, message = result.Message
}));
}
}
catch (Exception ex)
{
return(Json(new CommonResult {
code = (int)ResultCodeEnum.APIError, message = ex.Message
}));
}
}
/// <summary>
/// 通过主键和指定类型从数据库获取对象
/// </summary>
/// <typeparam name="T">指定类型</typeparam>
/// <param name="keyValue">主键值（通常为Guid），不能为空</param>
/// <returns>从数据库中得到的对象,如果数据库中没找到对象会返回一个空对象</returns>
/// 前置条件
/// 1.keyValue不能为空
/// 2.传入的对象T只能有一个主键
public T GetByKey <T>(object keyValue)
where T : new()
{
PreconditionAssert.IsNotNull(keyValue, ErrorMessages.NullReferenceException);
ORMHelper.EntityIsMappingDatabase(typeof(T), ErrorMessages.EntityMappingError);
SelectCommandCreator dbCommandCreator = new SelectCommandCreator(_dbAccess);
dbCommandCreator.ObjectType = typeof(T);
dbCommandCreator.KeyValue = keyValue;
dbCommandCreator.SelectType = SelectType.GetOneByKeyValue;
DbCommand dbCommand = dbCommandCreator.GetDbCommand();
DataTable dt = _dbAccess.GetDataTableByCommand(dbCommand);
if (dt.Rows.Count == 0)
{
return(default(T));
}
else if (dt.Rows.Count == 1)
{
return(ORMHelper.ConvertDataRowToEntity <T>(dt.Rows[0]));
}
else
{
//引发数据获取结果错误
throw new ORMException(ErrorMessages.ResultNotUniqueMessage);
}
}
public static T ConvertDataRowToInfo <T>(DataRow dataRow) where T : new()
{
//断言传入的datarow不能为null
PreconditionAssert.IsNotNull(dataRow, ErrorMessages.NullReferenceException);
Type infoType = typeof(T);
T tempT = new T();
//var tempT = Activator.CreateInstance(infoType);
foreach (var item in infoType.GetProperties())
{
var propertyName = item.Name;
if (!dataRow.Table.Columns.Contains(propertyName))
{
continue;
}
if (dataRow[propertyName].Equals(DBNull.Value))
{
item.SetValue(tempT, null, null);
}
else
{
//Type type = Nullable.GetUnderlyingType(item.PropertyType) ?? item.PropertyType;
item.SetValue(tempT, dataRow[propertyName], null);
}
}
return(tempT);
}
/// <summary>
/// 将数据库中的行数据转换成一个实体对象
/// </summary>
/// <typeparam name="T">指定类型</typeparam>
/// <param name="dataRow">数据库中的行数据</param>
/// <returns>指定类型的实体对象</returns>
public static T ConvertDataRowToEntity <T>(DataRow dataRow) where T : new()
{
//断言传入的datarow不能为null
PreconditionAssert.IsNotNull(dataRow, ErrorMessages.NullReferenceException);
T tempT = new T();
Type entityType = typeof(T);
string fieldName;
TypeSchema entityInfo = ORMSchemaCache.GetTypeSchema(entityType);
foreach (SchemaItem mfi in entityInfo.GetAllFieldInfos())
{
fieldName = mfi.MappingFieldAttribute.FieldName;
if (string.IsNullOrEmpty(fieldName))
{
continue;
}
if (dataRow.Table.Columns.Contains(fieldName))
{
if (dataRow[fieldName].Equals(DBNull.Value))
{
mfi.ProInfo.SetValue(tempT, null, null);
}
else
{
Type type = Nullable.GetUnderlyingType(mfi.ProInfo.PropertyType) ?? mfi.ProInfo.PropertyType;
mfi.ProInfo.SetValue(tempT, dataRow[fieldName], null);
}
}
}
return(tempT);
}
public IList <T> GetList <T>(Criteria criteria, params SortInfo[] orderBy)
where T : new()
{
PreconditionAssert.IsNotNull(criteria, ErrorMessages.NullReferenceException);
try
{
SelectCommandCreator dbCommandCreator = new SelectCommandCreator(dbAccess);
dbCommandCreator.OrderBy = orderBy;
dbCommandCreator.ObjectType = typeof(T);
dbCommandCreator.Cri = criteria;
dbCommandCreator.SelectType = SelectType.GetList;
DbCommand dbCommand = dbCommandCreator.GetDbCommand();
DataTable dt = dbAccess.GetDataTableByCommand(dbCommand);
return(ORMHelper.DataTableToList <T>(dt));
}
catch (Exception ex)
{
StringBuilder errMsgBuilder = new StringBuilder();
errMsgBuilder.AppendLine("Select object list by criteria error, detail:");
errMsgBuilder.AppendLine("Criteria Info:");
errMsgBuilder.AppendLine(ORMHelper.GetCriteriaMessage(criteria));
errMsgBuilder.AppendLine("Sort Info:");
errMsgBuilder.AppendLine(ORMHelper.GetOrderInfoMessage(orderBy));
throw new ORMException(errMsgBuilder.ToString(), ex);
}
}
/// <summary>
/// 通过对象已有的主键值（可以多个主键）和指定类型从数据库获取对象
/// </summary>
/// <typeparam name="T">指定类型</typeparam>
/// <param name="entity">外部构造的对象，不能为空</param>
/// <returns>从数据库中得到的对象,如果数据库中没找到对象会返回一个空对象</returns>
/// 前置条件
/// 传入的entity对象不能为空
public T GetByKeys <T>(T entity) where T : new()
{
PreconditionAssert.IsNotNull(entity, ErrorMessages.NullReferenceException);
ORMHelper.EntityIsMappingDatabase(entity.GetType(), ErrorMessages.EntityMappingError);
ORMHelper.CheckEntityKey(entity);
SelectCommandCreator dbCommandCreator = new SelectCommandCreator(_dbAccess);
dbCommandCreator.Entity = entity;
dbCommandCreator.SelectType = SelectType.GetOneByEntityKey;
DbCommand dbCommand = dbCommandCreator.GetDbCommand();
DataTable dt = _dbAccess.GetDataTableByCommand(dbCommand);
if (dt.Rows.Count == 0)
{
return(default(T));
}
else if (dt.Rows.Count == 1)
{
return(ORMHelper.ConvertDataRowToEntity <T>(dt.Rows[0]));
}
else
{
throw new ORMException(ErrorMessages.ResultNotUniqueMessage);
}
}
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
AnteCodeNumbers = antecode.Split(Spliter);
if (GameType == "3THDX")
{
var thdx = new string[] { "111", "222", "333", "444", "555", "666" };
if (!thdx.Contains(antecode))
{
errMsg = string.Format("投注号码格式不正确 - {0}", antecode);
return(false);
}
}
if (GameType == "3THTX" && antecode != "XXX")
{
errMsg = string.Format("投注号码格式不正确 - {0}", antecode);
return(false);
}
if (GameType == "3LHTX" && antecode != "XYZ")
{
errMsg = string.Format("投注号码格式不正确 - {0}", antecode);
return(false);
}
errMsg = "";
return(true);
}
/// <summary>
/// 拒绝提现
/// </summary>
/// <returns></returns>
public JsonResult RefusedWithdrawALL()
{
try
{
string orderIds = PreconditionAssert.IsNotEmptyString(Request["orderIds"], "提现订单编号为空");
string message = PreconditionAssert.IsNotEmptyString(Request["message"], "备注不能为空");
string[] arrs = orderIds.Split(',');
if (arrs.Length == 0)
{
return(Json(new { IsSuccess = false, Msg = "请勾选订单编号" }));
}
foreach (var item in arrs)
{
var result = base.FundClient.RefusedWithdraw(item, message, CurrentUser1.UserToken);
//推送消息
var with = base.FundClient.GetWithdrawById(item, CurrentUser1.UserToken);
var pushTitle = "提现申请审核拒绝";
var pushContent = "您的" + with.RequestMoney.ToString("f") + "元的提现申请被拒绝，点击查看详情。";
base.GameClient.BackGroundDoPush(with.RequesterUserKey, PushType.Unicast, AfterOpenType.GoActivity,
pushTitle, pushContent, string.Empty, "Push_Finance_Withdraw", string.Empty);
}
return(Json(new { IsSuccess = true, Msg = "" }));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
/// <summary>
/// 检查中奖号码格式是否正确
/// </summary>
/// <param name="winNumber">中奖号码</param>
/// <param name="gameType">玩法</gameType>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckWinNumber(ISportResult winNumber, string gameType, out string errMsg)
{
if (!string.IsNullOrEmpty(gameType) && gameType != GameType)
{
var orderAnalyzer = KaSon.FrameWork.Analyzer.AnalyzerFactory.AnalyzerFactory.GetSportAnteCodeChecker(GameCode, gameType);
return(orderAnalyzer.CheckWinNumber(winNumber, null, out errMsg));
}
else
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查中奖号码格式前，必须设置彩种");
PreconditionAssert.IsNotNull(winNumber, "必须传入非空的比赛结果");
PreconditionAssert.IsNotEmptyString(winNumber.GetMatchId(GameCode), "必须传入比赛编号");
_winNumbers = EffectiveWinNumber.Split(Spliter);
var result = winNumber.GetMatchResult(GameCode, GameType);
if (result != CancelMatchResultFlag && !_winNumbers.Contains(result))
{
errMsg = string.Format("错误的比赛结果格式，允许的格式：{0}，取消结果格式：{1}，实际为：'{2}'.", EffectiveWinNumber, CancelMatchResultFlag, result);
return(false);
}
errMsg = "";
return(true);
}
}
/// <summary>
/// 检查中奖号码格式是否正确
/// </summary>
/// <param name="winNumber">中奖号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckWinNumber(string winNumber, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查中奖号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(winNumber, "必须传入非空的中奖号码");
WinNumbers = winNumber.Split(Spliter);
if (WinNumbers.Length != TotalNumber)
{
errMsg = string.Format("中奖号码必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter, TotalNumber);
return(false);
}
var count = WinNumbers.Count(a => a.Length != 1 || (!EffectiveWinNumber.Contains(a) && IsEnableWildcard && a != Wildcard));
if (count > 0)
{
errMsg = string.Format("中奖号码必须是由{0}场比赛结果数字\"{1}\"组成的字符串", TotalNumber, string.Join(",", EffectiveWinNumber.ToArray()));
return(false);
}
if (BallNumber == 14 || BallNumber == 9)
{
if (WinNumbers.Count(a => a.Equals(Wildcard)) > 6)
{
errMsg = string.Format("中奖号码超过6场没有比赛结果，{0}", string.Join(",", WinNumbers));
return(false);
}
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查一个单独号码的格式
/// </summary>
/// <param name="antecodeNumber">号码</param>
/// <param name="errMsg">错误信息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecodeNumber(ISportAnteCode antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查中奖号码格式前，必须设置彩种");
PreconditionAssert.IsNotNull(antecode, "必须传入非空的比赛结果");
PreconditionAssert.IsNotEmptyString(antecode.MatchId, "必须传入比赛编号");
PreconditionAssert.IsNotEmptyString(antecode.AnteCode, "必须传入比赛投注号码");
var tmpList = antecode.AnteCode.Split(Spliter);
if (tmpList.Length != tmpList.GroupBy(c => c).Count())
{
errMsg = "有重复的投注号码 - " + antecode.AnteCode;
return(false);
}
_anteCodes = EffectiveAnteCode.Split(Spliter);
foreach (var item in tmpList)
{
if (!_anteCodes.Contains(item))
{
errMsg = "比赛投注号码必须在\"" + EffectiveAnteCode + "\"范围内，实际为 - " + item;
return(false);
}
}
errMsg = "";
return(true);
}
public IList <T> GetAll <T>(int pageIndex, int pageSize, out int totalCount, params SortInfo[] orderBy) where T : new()
{
PreconditionAssert.IsNotNull(orderBy, ErrorMessages.NullReferenceException);
ORMHelper.EntityIsMappingDatabase(typeof(T), ErrorMessages.EntityMappingError);
try
{
SelectCommandCreator dbCommandCreator = new SelectCommandCreator(dbAccess);
dbCommandCreator.ObjectType = typeof(T);
dbCommandCreator.OrderBy = orderBy;
dbCommandCreator.SelectType = SelectType.GetAll;
dbCommandCreator.NeedPaged = true;
dbCommandCreator.PageIndex = pageIndex + 1;
dbCommandCreator.PageSize = pageSize;
DbCommand dbCommand = dbCommandCreator.GetDbCommand();
DataTable dt = dbAccess.GetDataTableByCommand(dbCommand);
if (dt.Rows.Count > 0)
{
totalCount = (int)dt.Rows[0]["TotalCount"];
}
else
{
totalCount = 0;
}
return(ORMHelper.DataTableToList <T>(dt));
}
catch (Exception ex)
{
throw new ORMException("Get all object list error, detail:\n\t" + ORMHelper.GetOrderInfoMessage(orderBy), ex);
}
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
var content = new string[] { "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32" };
AnteCodeNumbers = antecode.Split(Spliter);
foreach (var item in AnteCodeNumbers)
{
if (!(item.Length == 2))
{
errMsg = string.Format("投注号码必须为2位数！");
return(false);
}
if (!content.Contains(item))
{
errMsg = string.Format("投注号码必须在01-32之间号码！");
return(false);
}
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查中奖号码格式是否正确
/// </summary>
/// <param name="winNumber">中奖号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckWinNumber(string winNumber, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查中奖号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(winNumber, "必须传入非空的中奖号码");
WinNumbers = winNumber.Split(Spliter);
if (WinNumbers.Length != TotalNumber)
{
errMsg = string.Format("中奖号码必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter, TotalNumber);
return(false);
}
//var lastNumber = 0;
foreach (var num in WinNumbers)
{
//if (int.Parse(num) < lastNumber)
// throw new AntecodeFormatException(GameCode, GameCode, winNumber, "中奖号码格式错误");
// 检查每一个号码
if (!CheckOneAntecodeNumber(num, out errMsg))
{
return(false);
}
//lastNumber = int.Parse(num);
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
AnteCodeNumbers = antecode.Split(Spliter);
if (AnteCodeNumbers.Length != BallNumber)
{
errMsg = string.Format("投注号码必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter, BallNumber);
return(false);
}
var orderAnalyzer = AnalyzerFactory.GetOrderAnalyzer(GameCode, GameType);
var i = 0;
for (; i < BallNumber; i++)
{
// 检查每一个号码
if (!orderAnalyzer.CheckComboAntecodeNumber(AnteCodeNumbers[i], null, out errMsg))
{
return(false);
}
// 分组，以去除号码中的重复项
var group = AnteCodeNumbers[i].GroupBy(c => c);
if (group.Count() != AnteCodeNumbers[i].Length)
{
errMsg = "号码中有重复的数字 - " + antecode;
return(false);
}
}
errMsg = "";
return(true);
}
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
antecode = antecode.Replace("|", "#");
AnteCodeNumbers = antecode.Split(new string[] { ",", "#" }, StringSplitOptions.RemoveEmptyEntries);
if (AnteCodeNumbers.Length < BallNumber)
{
errMsg = string.Format("最少选择{0}位号码", BallNumber);
return(false);
}
foreach (var item in AnteCodeNumbers)
{
if (int.Parse(item) < MinValue || int.Parse(item) > MaxValue)
{
errMsg = string.Format("号码必须是 {0} - {1} 之间的数字", MinValue, MaxValue);
return(false);
}
}
if (AnteCodeNumbers.Distinct().Count() != AnteCodeNumbers.Length)
{
errMsg = "号码中不能包括重复的数字";
return(false);
}
errMsg = "";
return(true);
}
public static ILHDBTran BeginTransaction(RDatabaseType dbtype, string constr)
{
PreconditionAssert.IsNotNullOrEmpty(constr, ErrorMessages.DBConnectionStringIsNullOrEmpty);
LHDBAccess dbAccess = GetLHDBAccess(dbtype, constr);
return(new LHDBTran(dbAccess));
}
public static ILHDBAccess CreateDBAccessInstance(RDatabaseType dbtype, string constr)
{
PreconditionAssert.IsNotNullOrEmpty(constr, ErrorMessages.DBConnectionStringIsNullOrEmpty);
LHDBAccess dbAccess = GetLHDBAccess(dbtype, constr);
return(dbAccess);
}
/// <summary>
/// 检查中奖号码格式是否正确
/// </summary>
/// <param name="winNumber">中奖号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckWinNumber(string winNumber, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查中奖号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(winNumber, "必须传入非空的中奖号码");
WinNumbers = winNumber.Split(Spliter_Level1);
if (WinNumbers.Length != 2)
{
errMsg = string.Format("中奖号码必须是被\"{0}\"切分成前后两区的字符串", Spliter_Level1);
return(false);
}
WinNumbers_First = WinNumbers[0].Split(Spliter_Level2);
if (WinNumbers_First.Length != TotalNumber_First)
{
errMsg = string.Format("中奖号码前区必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter_Level2, TotalNumber_First);
return(false);
}
WinNumbers_Last = WinNumbers[1].Split(Spliter_Level2);
if (WinNumbers_Last.Length != TotalNumber_Last)
{
errMsg = string.Format("中奖号码后区必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter_Level2, TotalNumber_Last);
return(false);
}
foreach (var num in WinNumbers_First)
{
// 检查每一个号码
if (!CheckOneAntecodeNumber_First(num, out errMsg))
{
return(false);
}
}
errMsg = "";
return(true);
}
public bool CheckWinNumbers(ISportAnteCode[] antecodeList, ISportResult[] winNumberList, out string errMsg)
{
PreconditionAssert.IsTrue((winNumberList != null && winNumberList.Length > 0), "必须传入比赛结果");
//if (winNumberList.Length != winNumberList.GroupBy(a => a.GetMatchId(GameCode)).Count())
//{
// errMsg = "比赛场次重复";
// return false;
//}
foreach (var code in winNumberList)
{
var ante = antecodeList.FirstOrDefault(a => a.MatchId == code.GetMatchId(GameCode));
if (ante != null)
{
var orderAnalyzer = AnalyzerFactory.GetSportAnteCodeChecker(GameCode, GameType);
if (!orderAnalyzer.CheckWinNumber(code, ante.GameType, out errMsg))
{
return(false);
}
}
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
AnteCodeNumbers = antecode.Split(Spliter);
if (AnteCodeNumbers.Length != BallNumber)
{
errMsg = string.Format("投注号码必须是被\"{0}\"切分成 {1}个部分的字符串", Spliter, TotalNumber);
return(false);
}
var orderAnalyzer = KaSon.FrameWork.Analyzer.AnalyzerFactory.AnalyzerFactory.GetOrderAnalyzer(GameCode, GameType);
for (var i = 0; i < BallNumber; i++)
{
// 检查每一个号码
if (!orderAnalyzer.CheckComboAntecodeNumber(AnteCodeNumbers[i], null, out errMsg))
{
return(false);
}
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
AnteCodeNumbers = antecode.Split(Spliter);
if (AnteCodeNumbers.Length < BallNumber || AnteCodeNumbers.Length > AllNumber)
{
errMsg = string.Format("投注号码必须是由\"{0}\"连接的 {1} - {2}个数字组成", Spliter, BallNumber, AllNumber);
return(false);
}
var orderAnalyzer = AnalyzerFactory.GetOrderAnalyzer(GameCode, GameType);
// 检查每一个号码
if (!orderAnalyzer.CheckComboAntecodeNumber(antecode, Spliter, out errMsg))
{
return(false);
}
var groupCount = AnteCodeNumbers.GroupBy(a => a).Count();
if (groupCount != AnteCodeNumbers.Length)
{
errMsg = string.Format("投注号码有重复数字出现：{0}", antecode);
return(false);
}
errMsg = "";
return(true);
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
AnteCodeNumbers = antecode.Split(Spliter);
if (AnteCodeNumbers.Length != 2)
{
errMsg = string.Format("投注号码必须是被\"{0}\"切分成 2个部分的字符串", Spliter);
return(false);
}
if (string.IsNullOrEmpty(AnteCodeNumbers[0]) || string.IsNullOrEmpty(AnteCodeNumbers[1]))
{
errMsg = "大/小/单/双 投注内容不能为空";
return(false);
}
if (!_allowChars.Contains(AnteCodeNumbers[0]) || !_allowChars.Contains(AnteCodeNumbers[1]))
{
errMsg = "大/小/单/双 必须由对应的 2/1/5/4 四个数字表示 - " + antecode;
return(false);
}
errMsg = "";
return(true);
}
public void SaveDataTable(DataTable dt)
{
PreconditionAssert.IsNotNull(dt, ErrorMessages.CommandTextIsNullOrEmpty);
PreconditionAssert.IsNotEmptyString(dt.TableName, ErrorMessages.TableNameIsEmpty);
DoTransaction(() =>
{
DoSaveDataTable(dt);
});
}
/// <summary>
/// 验证SQL与传入参数是否匹配
/// </summary>
private void ValidateSqlStrAndParams(string str, params object[] values)
{
// 断言传入SQL语句为null或不为空串
PreconditionAssert.IsNotEmptyString(str, ErrorMessages.CommandTextIsNullOrEmpty);
// 断言传入的SQL参数与提供的参数值列表匹配
string sqlDetail = ErrorMessages.SqlParameterNotMatchValues + "\n" + DbAccessHelper.GetFormatErrorMsg(str, values);
PreconditionAssert.CanFormatString(str, values, sqlDetail);
}
/// <summary>
/// 检查投注号码格式是否正确
/// </summary>
/// <param name="antecode">投注号码</param>
/// <param name="errMsg">错误消息</param>
/// <returns>格式是否正确</returns>
public bool CheckAntecode(string antecode, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
var gameTypeArray = new string[] { "TH", "SZ", "THS", "DZ", "BZ" };
if (!gameTypeArray.Contains(GameType))
{
errMsg = string.Format("玩法编码错误,必须是：{0}中的一种", string.Join(",", gameTypeArray));
return(false);
}
var rightNumberArray = new string[] { };
switch (GameType)
{
case "TH":
//同花黑桃、同花红桃、同花梅花、同花方块、同花包选
rightNumberArray = new string[] { "TH1", "TH2", "TH3", "TH4", "THX" };
break;
case "SZ":
//顺子1、顺子2...顺子包选
rightNumberArray = new string[] { "SZ1", "SZ2", "SZ3", "SZ4", "SZ5", "SZ6", "SZ7", "SZ8", "SZ9", "SZ10", "SZ11", "SZ12", "SZ13", "SZX" };
break;
case "THS":
//同花顺黑桃、同花顺红桃、同花顺梅花、同花顺方块、同花顺包选
rightNumberArray = new string[] { "THS1", "THS2", "THS3", "THS4", "THSX" };
break;
case "DZ":
//对子1、对子1...对子包选
rightNumberArray = new string[] { "DZ1", "DZ2", "DZ3", "DZ4", "DZ5", "DZ6", "DZ7", "DZ8", "DZ9", "DZ10", "DZ11", "DZ12", "DZ13", "DZX" };
break;
case "BZ":
//豹子1、豹子2...豹子包选
rightNumberArray = new string[] { "BZ1", "BZ2", "BZ3", "BZ4", "BZ5", "BZ6", "BZ7", "BZ8", "BZ9", "BZ10", "BZ11", "BZ12", "BZ13", "BZX" };
break;
default:
break;
}
if (rightNumberArray.Length == 0 || !rightNumberArray.Contains(antecode))
{
errMsg = string.Format("投注号码:{0} 不正确", antecode);
return(false);
}
errMsg = "";
return(true);
}
public void SaveDataTable(DataTable datatb)
{
PreconditionAssert.IsNotNull(datatb, ErrorMessages.CommandTextIsNullOrEmpty);
PreconditionAssert.IsNotNullOrEmpty(datatb.TableName, ErrorMessages.TableNameIsEmpty);
DoTransaction(() =>
{
DoSaveDataTable(datatb);
});
}
/// <summary>
/// 根据数据库连接字符串初始化对象
/// </summary>
/// <param name="constr">提供数据库连接字符串，不能为null或空串</param>
protected DbAccessBase(string constr)
{
// 断言连接字符串不为null或空串
PreconditionAssert.IsFalse(string.IsNullOrEmpty(constr), ErrorMessages.DBConnectionStringIsNullOrEmpty);
_engine = new DbEngine(Factory, constr);
ConnectionTimeout = 60;
CommandTimeout = 60;
}
public JsonResult AddRoleFunction(OperationRoleModel model)
{
CommonResult r = new CommonResult();
try
{
if (!CheckRights("TJJS100"))
{
return(Json(new { IsSuccess = false, Msg = "您没有添加角色的权限" }));
}
var id = Guid.NewGuid().ToString();
AdminRole roleInfo = new AdminRole();
roleInfo.Name = PreconditionAssert.IsNotEmptyString(model.RoleName, "角色名不能为空");
roleInfo.Id = id;
roleInfo.Type = model.RoleType;
roleInfo.UpdateDate = DateTime.Now;
roleInfo.CreationDate = DateTime.Now;
roleInfo.CreatorUserId = CurUser.UserId;
roleInfo.UpdatorUserId = CurUser.UserId;
if (roleInfo.Type == IdentityManager.RoleType.SuperAdmin)
{
roleInfo.Permissions = PermissionManager.GetAllPermissions()?.Select(p =>
{
return(new AdminRolePermission()
{
RoleId = id,
PermissionId = p.Id,
CreationDate = DateTime.Now
});
}).ToList();
}
else
{
roleInfo.Permissions = model.FunctionIds.Select(p =>
{
return(new AdminRolePermission()
{
RoleId = id,
PermissionId = p,
CreationDate = DateTime.Now
});
}).ToList();
}
RoleManager.AddRole(roleInfo);
return(Json(r));
}
catch (Exception ex)
{
logger.Error("AddRoleFunciton", ex);
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
private void ValidateSqlStrAndParams(string sqlString, params object[] values)
{
PreconditionAssert.IsNotNullOrEmpty(sqlString, ErrorMessages.CommandTextIsNullOrEmpty);
try
{
string.Format(sqlString, values);
}
catch (Exception ex)
{
throw new SqlParameterNotMatchException(sqlString, "Validate sql string and params match failed.", ex, values);
}
}
