/// <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 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>
/// <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);
}
/// <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="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, "必须传入非空的投注号码");
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_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 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);
}
/// <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>
/// <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="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);
}
/// <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="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="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);
}
/// <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);
}
public void SaveDataTable(DataTable dt)
{
PreconditionAssert.IsNotNull(dt, ErrorMessages.CommandTextIsNullOrEmpty);
PreconditionAssert.IsNotEmptyString(dt.TableName, ErrorMessages.TableNameIsEmpty);
DoTransaction(() =>
{
DoSaveDataTable(dt);
});
}
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 }));
}
}
public JsonResult AddRedBagConfig(FormCollection fc)
{
try
{
string gameCode = fc["GameCode"];
decimal percent = decimal.Parse(PreconditionAssert.IsNotEmptyString(fc["UsePercent"], "使用比例不能为空"));
var r = this.ActivityClient.AddRedBagUseConfig(gameCode, percent);
return(Json(new { IsSuccess = r.IsSuccess, Msg = r.Message }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
public JsonResult TeamLogoEditJson()
{
try
{
var id = PreconditionAssert.IsNotEmptyString(Request["id"], "编号不能为空");
var imgPath = PreconditionAssert.IsNotEmptyString(Request["imgPath"], "图片url不能为空");
var result = GlobalCache.GameClient.UpdateIndexMatch(Convert.ToInt32(id), imgPath);
return(Json(new { IsSuccess = result.IsSuccess, Msg = result.Message }));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
/// <summary>
/// 提交艾付代付打款
/// </summary>
/// <returns></returns>
public JsonResult CompleteWithdrawALL_AF()
{
try
{
string orderIds = PreconditionAssert.IsNotEmptyString(Request["orderIds"], "提现订单编号为空");
string[] arrs = orderIds.Split(',');
if (arrs.Length == 0)
{
return(Json(new { IsSuccess = false, Msg = "请勾选订单编号" }));
}
string msg = "已提交\r\n";
String TempRSAStr = string.Empty;//明细串
foreach (var item in arrs)
{
var with = base.FundClient.GetWithdrawById(item, CurrentUser1.UserToken);
//检查是否支持该银行
string bankCode = Common.Pay.af.afPay.checkBankName(with.BankName);
if (bankCode == "0")
{
msg += string.Format("该订单提交失败,原因是艾付暂不支持该银行打款,订单号:{0},银行名字：{1}\r\n", item, with.BankName);
continue;
}
//MD5签名串
string src = string.Format(@"merchant_no={0}&order_no={1}&card_no={2}&account_name={3}&bank_branch={4}&cnaps_no={5}&bank_code={6}&bank_name={7}&amount={8}&pay_pwd={9}",
this.af_merchant_no, with.OrderId, with.BankCardNumber, Common.Pay.af.afUtil.EncodeBase64(Encoding.UTF8, with.RequesterRealName), "", "", bankCode, Common.Pay.af.afUtil.EncodeBase64(Encoding.UTF8, with.BankName), with.ResponseMoney.Value.ToString("f2"), this.af_pay_pwd);
src += "&key=" + af_key;
string sign = Common.Pay.af.afUtil.MD5(src, Encoding.UTF8);
src += "&sign=" + sign;
string responseStr = Common.Pay.af.afUtil.HttpPost(af_url + "?" + src.ToString(), "", Encoding.UTF8);
var json = Newtonsoft.Json.Linq.JObject.Parse(responseStr);
//代付申请成功
if (json["result_code"].ToString() == "000000")
{
var result = base.FundClient.ReuqestWithdraw(item, CurrentUser1.UserToken, this.af_merchant_no.ToString());
}
else
{
msg += string.Format("该订单提交失败,原因是代付平台返回错误信息,订单号:{0},错误信息：{1}\r\n", item, json["result_msg"].ToString());
}
}
return(Json(new { IsSuccess = true, Msg = msg }));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
public void SaveDataRow(string tableName, DataRow row)
{
PreconditionAssert.IsNotNull(row, ErrorMessages.CommandTextIsNullOrEmpty);
PreconditionAssert.IsNotEmptyString(tableName, ErrorMessages.TableNameIsEmpty);
_engine.DoCommand((cmd) =>
{
using (DbDataAdapter adapter = _engine.CreateDataAdapter())
{
adapter.SelectCommand = cmd;
using (DbCommandBuilder dbCmdBuilder = _engine.CreateCommandBuilder())
{
this.DoSaveDataRow(adapter, dbCmdBuilder, tableName, row);
}
}
});
}
/// <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.CheckOneAntecodeNumber(AnteCodeNumbers[i], out errMsg))
{
return(false);
}
}
var groupCount = AnteCodeNumbers.GroupBy(a => a).Count();
if (groupCount == 1)
{
errMsg = string.Format("投注号码不能是三个数字都相同的豹子：", antecode);
return(false);
}
else if (groupCount == 3)
{
errMsg = string.Format("投注号码不能是三个数字都不相同的组六：", antecode);
return(false);
}
else if (groupCount == 2)
{
errMsg = "";
return(true);
}
else
{
errMsg = string.Format("分析投注号码未知错误：", antecode);
return(false);
}
}
/// <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);
}
if (!CheckComboAntecodeNumber(winNumber, ',', out errMsg))
{
return(false);
}
errMsg = "";
return(true);
}
/// <summary>
/// 人工打款
/// </summary>
/// <returns></returns>
public JsonResult CompleteWithdrawALL()
{
try
{
string orderIds = PreconditionAssert.IsNotEmptyString(Request["orderIds"], "提现订单编号为空");
string[] arrs = orderIds.Split(',');
if (arrs.Length == 0)
{
return(Json(new { IsSuccess = false, Msg = "请勾选订单编号" }));
}
string msg = string.Empty;
foreach (var item in arrs)
{
var result = base.FundClient.CompleteWithdraw(item, "接受提现，已打款", CurrentUser1.UserToken);
//提款成功发送短信给用户
if (result.IsSuccess)
{
try
{
var with = base.FundClient.GetWithdrawById(item, CurrentUser1.UserToken);
var mobile = with.RequesterMobile;
var content = "尊敬的 " + with.RequesterRealName + " 您好，您申请【" + with.RequestMoney.ToString("f") + "元】已处理，请注意查收。";
var returned = SendMessage(mobile, content);
//推送消息
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);
}
catch
{
}
}
}
return(Json(new { IsSuccess = true, Msg = "" }));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
public bool CheckAntecode(ISportAnteCode[] antecodeList, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsTrue((antecodeList != null && antecodeList.Length > 0), "必须传入投注号码");
//if (antecodeList.Length != antecodeList.GroupBy(a => a.MatchId).Count())
//{
// errMsg = "选择的比赛场次重复";
// return false;
//}
if (antecodeList.Length != antecodeList.GroupBy(a => new { MatchId = a.MatchId, GameType = a.GameType }).Count())
{
errMsg = "选择的比赛场次重复";
return(false);
}
if (antecodeList.Length < BaseCount)
{
errMsg = "选择的比赛不够，当前串关方式至少需要 " + BaseCount + "场比赛";
return(false);
}
TuoNumbers = antecodeList.Where(a => !a.IsDan).ToArray();
DanNumbers = antecodeList.Where(a => a.IsDan).ToArray();
if (DanNumbers.Length > BaseCount)
{
errMsg = "胆码太多，当前串关方式最多允许 " + BaseCount + "个胆码";
return(false);
}
foreach (var code in antecodeList)
{
var type = string.IsNullOrEmpty(code.GameType) ? GameType : code.GameType;
var orderAnalyzer = AnalyzerFactory.GetSportAnteCodeChecker(GameCode, type);
if (!orderAnalyzer.CheckAntecodeNumber(code, out errMsg))
{
return(false);
}
}
errMsg = "";
return(true);
}
private bool CheckAntecode(string antecode, out int num, out string errMsg)
{
// 前置验证 - 彩种、玩法、投注号码
PreconditionAssert.IsNotEmptyString(GameCode, "检查投注号码格式前，必须设置彩种");
PreconditionAssert.IsNotEmptyString(GameType, "检查投注号码格式前，必须设置玩法");
PreconditionAssert.IsNotEmptyString(antecode, "必须传入非空的投注号码");
if (!int.TryParse(antecode, out num))
{
errMsg = "投注号码必须是整数";
return(false);
}
if (num < MinValue * BallNumber || num > MaxValue * BallNumber)
{
errMsg = string.Format("投注号码必须是介于{0}与{1}之间的数字", MinValue * BallNumber, MaxValue * BallNumber);
return(false);
}
errMsg = "";
return(true);
}
public JsonResult CompleteRecharge()
{
try
{
string orderId = PreconditionAssert.IsNotEmptyString(Request["orderId"], "订单ID不能为空");
if (!string.IsNullOrWhiteSpace(Request["sta"]) && Request["sta"] == "Fail")
{
var result = base.FundClient.ManualCompleteFillMoneyOrder(orderId, GameBiz.Core.FillMoneyStatus.Failed, CurrentUser1.UserToken);
AdminOperLogManager operLog = new AdminOperLogManager();
operLog.AddOperationLog(new AdminOperationLog()
{
CreationDate = DateTime.Now,
Description = string.Format("操作员【{0}】充值手工置为失败【{1}】，订单号【{2}】", User.Identity.Name, result.IsSuccess ? "成功" : "失败", orderId),
OperationName = "手工充值",
OperUserId = CurUser.UserId,
UserId = ""
});
return(Json(new { IsSuccess = result.IsSuccess, Msg = (result.IsSuccess ? "手工置为失败成功" : "手工置为失败失败") }));
}
else
{
var result = base.FundClient.ManualCompleteFillMoneyOrder(orderId, GameBiz.Core.FillMoneyStatus.Success, CurrentUser1.UserToken);
AdminOperLogManager operLog = new AdminOperLogManager();
operLog.AddOperationLog(new AdminOperationLog()
{
CreationDate = DateTime.Now,
Description = string.Format("操作员【{0}】充值手工置为成功【{1}】，订单号【{2}】", User.Identity.Name, result.IsSuccess ? "成功" : "失败", orderId),
OperationName = "手工充值",
OperUserId = CurUser.UserId,
UserId = ""
});
return(Json(new { IsSuccess = result.IsSuccess, Msg = result.Message }));
}
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
/// <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 (MinCount == -1 && MaxCount == -1)
{
if (AnteCodeNumbers.Length < BallNumber)
{
errMsg = string.Format("投注号码必须至少包含 {0}个数字", BallNumber);
return(false);
}
}
else
{
if (AnteCodeNumbers.Length < MinCount || AnteCodeNumbers.Length > MaxCount)
{
if (MinCount == MaxCount)
{
errMsg = string.Format("投注号码必须包含 {0}个数字", MinCount);
}
else
{
errMsg = string.Format("投注号码必须至少包含 {0} - {1}个数字", MinCount, MaxCount);
}
return(false);
}
}
var orderAnalyzer = KaSon.FrameWork.Analyzer.AnalyzerFactory.AnalyzerFactory.GetOrderAnalyzer(GameCode, GameType);
if (!orderAnalyzer.CheckComboAntecodeNumber(antecode, ',', out errMsg))
{
return(false);
}
errMsg = "";
return(true);
}
/// <summary>
/// 生成奖期数据
/// </summary>
public JsonResult PrizePeriodCreateJson()
{
try
{
var gameCode = PreconditionAssert.IsNotEmptyString(Request.Form["gameCode"], "彩种不能为空！");
var startTime = PreconditionAssert.IsNotEmptyString(Request.Form["startTime"], "开始时间不能为空！");
var endTime = PreconditionAssert.IsNotEmptyString(Request.Form["endTime"], "停止时间不能为空！");
if (new string[] { "CQSSC", "JX11X5", "JSKS", "SD11X5", "GD11X5", "GDKLSF", "SDKLPK3" }.Any(t => t == gameCode))//高频彩
{
var openPrizePeriodResult = GlobalCache.GameClient.OpenIssuseBatch_Fast(gameCode, Convert.ToDateTime(startTime), Convert.ToDateTime(endTime));
return(Json(new { IsSuccess = openPrizePeriodResult.IsSuccess, Msg = openPrizePeriodResult.Message }));
}
else if (gameCode == "BJPK10")//北京PK10
{
var startIssue = Request["startIssue"] == null ? 0 : Convert.ToInt64(Request["startIssue"]);
if (startIssue < 1)
{
throw new Exception("期号不正确");
}
var openPrizePeriodResult = GlobalCache.GameClient.OpenIssuseBatch_Fast_2(gameCode, Convert.ToDateTime(startTime), Convert.ToDateTime(endTime), startIssue);
return(Json(new { IsSuccess = openPrizePeriodResult.IsSuccess, Msg = openPrizePeriodResult.Message }));
}
else if (gameCode == "SSQ" || gameCode == "DLT")//低频彩
{
var openPrizePeriodResult = GlobalCache.GameClient.OpenIssuseBatch_Slow(gameCode, Convert.ToInt32(startTime), Convert.ToInt32(endTime));
return(Json(new { IsSuccess = openPrizePeriodResult.IsSuccess, Msg = openPrizePeriodResult.Message }));
}
else if (gameCode == "FC3D" || gameCode == "PL3")//每日
{
var openPrizePeriodResult = GlobalCache.GameClient.OpenIssuseBatch_Daily(gameCode, Convert.ToInt32(startTime), Convert.ToInt32(endTime));
return(Json(new { IsSuccess = openPrizePeriodResult.IsSuccess, Msg = openPrizePeriodResult.Message }));
}
return(Json(new { IsSuccess = false, Msg = "提交失败" }));
}
catch (Exception ex)
{
return(Json(new { IsSuccess = false, Msg = ex.Message }));
}
}
