public async Task <ActionResult <ExcutedResult> > Register([FromBody] Blog_Users user)
{
try
{
//请求状态
int statecode = (int)ExcutedResult.status.成功;
user.CreationTime = DateTimeHelper.GettimeStamp();
//执行添加
var result = await _userService.Register(user);
if (result == null)
{
statecode = (int)ExcutedResult.status.添加数据失败;
return(ExcutedResult.SuccessResult("添加数据失败", statecode));
}
return(ExcutedResult.SuccessResult(result, statecode));
}
catch (Exception ex)
{
return(ExcutedResult.FailedResult(ex.Message, (int)ExcutedResult.status.请求失败));
}
}
public ExcutedResult UpdatePassWord([FromBody] UpdatePassWordModel model)
{
try
{
if (model == null ||
String.IsNullOrEmpty(model.OldPassword) ||
String.IsNullOrEmpty(model.NewPassword) ||
String.IsNullOrEmpty(model.ConfirmPassword))
{
throw new BusinessException("UE0001", "请核对参数！");
}
else if (model.ConfirmPassword != model.NewPassword)
{
throw new BusinessException("UE0002", "确认密码和新密码不匹配！");
}
else
{
bool isSuccess = _managerLogic.UpdatePassword(model.OldPassword, model.NewPassword);
return(ExcutedResult.SuccessResult(isSuccess));
}
}
catch (BusinessException bex)
{
return(ExcutedResult.FailedResult(bex.ErrorCode, bex.Message));
}
catch (Exception)
{
return(ExcutedResult.FailedResult(SysResultCode.ServerException, ""));
}
}
public async Task <ExcutedResult> SendAsync(string phoneNumber, string content, int client, String countryNumber = "", string templateCode = "")
{
var result = await Send(phoneNumber, content, client, countryNumber, templateCode);
IHttpContextAccessor httpContextAccessor = AspectCoreContainer.Resolve <IHttpContextAccessor>();
var clientIp = httpContextAccessor.HttpContext.GetRequestIp4Address().ToString();
var smsSend = new SmsSend
{
Id = Guid.NewGuid(),
Mobile = result.PhoneNumber,
Content = result.Content,
CreateTime = DateTime.UtcNow,
SmsProxy = Name,
SmsProxyResp = result.ResponseStr,
IsSuccess = result.IsSuccess,
Client = client,
LoginIp = clientIp
};
ISmsSendRepository smsSendRepository = AspectCoreContainer.Resolve <ISmsSendRepository>();
smsSendRepository.Insert(smsSend);
if (result.IsSuccess)
{
return(ExcutedResult.SuccessResult());
}
return(ExcutedResult.FailedResult(BusinessResultCode.SmsSendFail, "短信发送失败"));
}
/// <summary>
/// 逻辑删除
/// </summary>
/// <returns></returns>
public void DeleteLogic(Guid guid, out ExcutedResult result)
{
try
{
//查询原始数据
var model = Repository.Get(x => x.Id == guid && x.State == (int)EnumState.Normal).FirstOrDefault();
//如果原始数据不存在，返回提示
if (model == null)
{
result = ExcutedResult.FailedResult(BusinessResultCode.ArgumentError, "操作失败,数据不存在");
return;
}
model.State = (int)EnumState.Deleted;
model.Deleter = CurrentUser.UserName;
model.DeleteTime = DateTime.UtcNow;
model.DeleteIp = CurrentUser.ClientIP;
using (var trans = base.GetNewTransaction())
{
base.Update(model, out result);
if (result.Status != EnumStatus.Success)
{
throw new Exception("更新配置实体失败");
}
trans.Commit();
}
}
catch (Exception e)
{
result = ExcutedResult.FailedResult(BusinessResultCode.OperationFailed, $"{BusinessResultCode.OperationFailed}:{e.Message}");
Log4NetHelper.WriteError(GetType(), e, $"版本删除失败Id:{guid}");
return;
}
}
public ExcutedResult QueryLoginLog(LoginLogParam model)
{
try
{
if (model == null)
{
throw new BusinessException(BusinessResultCode.ArgumentError, "参数错误或无效");
}
if (String.IsNullOrEmpty(model.SortName))
{
model.SortName = "CreateTime";
model.IsSortOrderDesc = true;
model.SortList = new Dictionary <string, bool> {
{ model.SortName, model.IsSortOrderDesc }
};
}
var dataInfo = Repository.GetQuery(model);
return(ExcutedResult.SuccessResult(dataInfo));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
catch (Exception exception)
{
return(ExcutedResult.FailedResult(SysResultCode.ServerException, "网络异常，请稍后重试或联系管理员！"));
}
}
public async Task <ExcutedResult <IdentityToken> > GetToken(string userId, string userInfo)
{
Dictionary <string, string> dict = new Dictionary <string, string>
{
["client_id"] = _identityParams.ClientId,
["client_secret"] = _identityParams.ClientSecret,
["grant_type"] = "password",
["username"] = _identityParams.UserName,
["password"] = _identityParams.Password,
["UInfo"] = userInfo,
["UId"] = userId
};
var client = _httpClientFactory.CreateClient();
using (var content = new FormUrlEncodedContent(dict))
{
var msg = await client.PostAsync($"{_identityParams.Uri}/connect/token", content);
if (!msg.IsSuccessStatusCode)
{
return(ExcutedResult <IdentityToken> .FailedResult(((int)msg.StatusCode).ToString(),
"获取AccessToken失败"));
}
return(ExcutedResult <IdentityToken> .SuccessResult(await msg.Content.ReadAsAsync <IdentityToken>()));
}
}
public ExcutedResult GetQuery(string name, int?number, int?clientType, int pageIndex = 1, int pageSize = 10, string sortName = "", bool?order = null)
{
try
{
VersionParam param = new VersionParam()
{
Name = name,
Number = number,
ClientType = clientType,
PageIndex = pageIndex,
PageSize = pageSize,
SortName = "date",
IsSortOrderDesc = true
};
if (!string.IsNullOrEmpty(sortName))
{
param.SortName = sortName;
}
if (order.HasValue)
{
param.IsSortOrderDesc = order.Value;
}
var result = _versionLogic.GetQuery(param);
return(ExcutedResult.SuccessResult(result));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public ExcutedResult Query(string name, string tag, int pageIndex = 1, int pagesize = 10, string sortName = "", bool?order = null)
{
try
{
TokenParam param = new TokenParam()
{
Name = name,
PageIndex = pageIndex,
PageSize = pagesize,
SortName = "Order",
IsSortOrderDesc = true
};
if (!string.IsNullOrEmpty(sortName))
{
param.SortName = sortName;
}
if (order.HasValue)
{
param.IsSortOrderDesc = order.Value;
}
var result = _tokensLogic.AdvQuery(param);
return(ExcutedResult.SuccessResult(result));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
/// <summary>
/// 获取用户信息
/// </summary>
/// <param name="account">账户名</param>
public async Task <ExcutedResult <AccountInfo> > GetAccountInfo(string account)
{
try
{
var info = await Client.GetAccount(account);
var accountInfo = MapperHelper <GetAccountResponse, AccountInfo> .Map(info);
return(ExcutedResult <AccountInfo> .SuccessResult(accountInfo));
}
catch (ApiErrorException aex)
{
Log4NetHelper.WriteError(GetType(), aex, $"Point:{Point.HttpAddress} Account:{account}");
return(ExcutedResult <AccountInfo> .SuccessResult("", null));
}
catch (ApiException ex)
{
NodeRepository.ApiException();
Log4NetHelper.WriteError(GetType(), ex, $"Point:{Point.HttpAddress} StatusCode:{ex.StatusCode} Content:{ex.Content}");
return(ExcutedResult <AccountInfo> .FailedResult(BusinessResultCode.ChainRequestError, "EOS request error."));
}
catch (Exception ex)
{
Log4NetHelper.WriteError(GetType(), ex, $"Point:{Point.HttpAddress} Account:{account}");
return(ExcutedResult <AccountInfo> .FailedResult(SysResultCode.ServerException, ""));
}
}
public ExcutedResult <ArticleModel> GetByCode(string code)
{
if (string.IsNullOrEmpty(code))
{
return(ExcutedResult <ArticleModel> .FailedResult(BusinessResultCode.ArgumentError, "参数错误或无效"));
}
var langType = LanguageHelper.GetEnumLanguageType(_httpContextAccessor.HttpContext);
string newCode = "";
if (langType != EnumLanguageType.Zh)
{
newCode = $"{code}_{langType.ToString().ToLower()}";
}
var entity = _articleLogic.GetByCode(newCode);
if (entity == null)
{
entity = _articleLogic.GetByCode(code);
}
if (entity != null)
{
var obj = new ArticleModel
{
Code = entity.Code,
Title = entity.Title,
Content = entity.Content,
};
return(ExcutedResult <ArticleModel> .SuccessResult(obj));
}
return(ExcutedResult <ArticleModel> .SuccessResult());
}
/// <summary>
/// 获取信息
/// </summary>
/// <returns></returns>
public async Task <ExcutedResult> GetInfo()
{
try
{
var result = await Client.GetInfo();
if (result == null)
{
return(ExcutedResult.FailedResult(BusinessResultCode.ChainRequestError, "Chain request error"));
}
return(ExcutedResult.SuccessResult(result));
}
catch (ApiException ex)
{
NodeRepository.ApiException();
Log4NetHelper.WriteError(typeof(InfoClient), ex,
$"Point:{Point.HttpAddress} StatusCode:{ex.StatusCode} Content:{ex.Content}");
return(ExcutedResult.FailedResult(BusinessResultCode.ChainRequestError, "Chain request error."));
}
catch (Exception ex)
{
Log4NetHelper.WriteError(GetType(), ex, $"Point:{Point.HttpAddress}");
return(ExcutedResult.FailedResult(SysResultCode.ServerException, ""));
}
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <ExcutedResult> GetSpeed(Guid id)
{
var point = Repository.GetSingle(id);
if (point == null)
{
return(ExcutedResult.FailedResult("", ""));
}
try
{
var contract = _contractFactory.GetService <IInfoClient>(point.ChainCode);
var asynResult = await contract.TestNetSpeed(point.TimeOut, point.HttpAddress);
var result = asynResult;
if (result.Status != EnumStatus.Success)
{
point.ErrorCount += 1;
Repository.Update(point);
}
return(result);
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public async Task <ExcutedResult> SignIn([FromBody] SignInModel model)
{
try
{
var result = _managerLogic.SignIn(model.UserName, model.Password, model.AuthenticateNum);
if (result.Status == EnumStatus.Success)
{
var managerInfo = (PrincipalUser)result.Data;
//用户标识
var identity = new ClaimsIdentity("Cookie", JwtClaimTypes.Name, JwtClaimTypes.Role);
identity.AddClaim(new Claim(JwtClaimTypes.Id, managerInfo.Id.ToString()));
identity.AddClaim(new Claim(JwtClaimTypes.Name, managerInfo.UserName));
identity.AddClaim(new Claim(JwtClaimTypes.Role, managerInfo.Role?.ToString()));
identity.AddClaim(new Claim("sub", managerInfo.Id.ToString()));
identity.AddClaim(new Claim("baseInfo", JsonConvert.SerializeObject(managerInfo)));
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(identity));
return(ExcutedResult.SuccessResult(managerInfo));
}
return(result);
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
protected virtual async Task <ExcutedResult <string> > PushAction(Action action)
{
var trans = new Transaction
{
actions = new List <Action>
{
action
}
};
try
{
var result = await Client.CreateTransaction(trans);
if (string.IsNullOrEmpty(result))
{
return(ExcutedResult <string> .FailedResult(BusinessResultCode.DataNotExist, "数据不存在，请刷新!."));
}
return(ExcutedResult <string> .SuccessResult("", result));
}
catch (ApiErrorException e)
{
Log4NetHelper.WriteError(GetType(), e, $"Point:{Point.HttpAddress} Code:{e.code} ErrorName:{e.error.name} Error:{e.error.what} \nAction:{JsonConvert.SerializeObject(action)}");
return(ExcutedResult <string> .FailedResult(BusinessResultCode.ChainRequestApiError, "EOS request api error."));
}
catch (ApiException ex)
{
NodeRepository.ApiException();
Log4NetHelper.WriteError(GetType(), ex, $"Point:{Point.HttpAddress} StatusCode:{ex.StatusCode} Content:{ex.Content}");
return(ExcutedResult <string> .FailedResult(BusinessResultCode.ChainRequestError, "EOS request error."));
}
}
public ExcutedResult Create([FromBody] VersionCreateRequest model)
{
try
{
var versionModle = _versionLogic.GetCurrentVersion(model.ClientType);
if (versionModle != null)
{
if (model.Number <= versionModle.Number)
{
return(ExcutedResult.FailedResult(BusinessResultCode.VersionIsSmallError, "当前版本号小于历史版本号"));
}
}
//VersionCreateRequest two = JsonConvert.DeserializeObject<VersionCreateRequest>(obj.ToString());
// return null;
// var model = new VersionEditRequest();
var entity = MapperHelper <VersionCreateRequest, Version> .Map(model);
_versionLogic.Create(entity, out var result);
return(result);
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
/// <summary>
/// 增
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ExcutedResult InsertNoticeInfo(NoticeRequestModel model)
{
try
{
if (model == null)
{
throw new BusinessException(BusinessResultCode.ArgumentError, "参数错误或无效");
}
model.InsertVerify();;
Notice notice = new Notice
{
Id = Guid.NewGuid(),
Title = model.Title,
ServiceName = model.ServiceName,
Content = model.Content,
IsShutdownSystem = model.IsShutdownSystem,
IsOnlyOne = model.IsOnlyOne,
CreateTime = model.ExpireTime
};
_noticeRepository.Insert(notice);
return(ExcutedResult.SuccessResult());
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
catch (Exception ex)
{
return(ExcutedResult.FailedResult(SysResultCode.ServerException, "发生异常，请稍后再试或联系管理员"));
}
}
/// <summary>
/// 发送验证码
/// </summary>
/// <param name="phoneNumber">手机号</param>
/// <param name="countryCode">国际电话区号,发送国际短信为必传字段</param>
/// <returns>执行结果</returns>
public async Task <ExcutedResult <string> > SendCaptcha(string phoneNumber, string countryCode)
{
try
{
var oldCaptcha = Repository.CheckMobileCaptcha(phoneNumber);
if (oldCaptcha != null)
{
return(ExcutedResult <string> .SuccessResult("", oldCaptcha.Id.ToString()));
}
IConfiguration config = AspectCoreContainer.Resolve <IConfiguration>();
var expireSeconds = int.Parse(config["Captcha:Common:ExpireSeconds"]);
var captcha = CodeHelper.CreateMobileCode(phoneNumber);
var entity = new DataAccess.Entities.Captcha
{
Id = Guid.NewGuid(),
Code = captcha,
CountryCode = countryCode,
ExpireTime = DateTime.UtcNow.AddSeconds(expireSeconds),
Type = (int)EnumCaptchaType.Sms,
CreateTime = DateTime.UtcNow,
Mobile = phoneNumber,
State = (int)EnumState.Normal
};
Create(entity, out var excutedResult);
if (excutedResult.Status != EnumStatus.Success)
{
return(ExcutedResult <string> .FailedResult(excutedResult.Code, excutedResult.Message));
}
#region 新版短信
//短信模板
var templateCode = "";
if (!countryCode.Contains("86"))
{
templateCode = _configDataLogic.GetByKey(ConfigDataKey.EnSmsTemplate);
}
else
{
templateCode = _configDataLogic.GetByKey(ConfigDataKey.SmsTemplate);
}
//短信渠道
SmsClient smsClient = AspectCoreContainer.Resolve <YunPianSmsClient>();
string content = string.Format(templateCode, captcha);
int client = 1;//固定传web
excutedResult = await smsClient.SendAsync(phoneNumber, content, client, countryCode, templateCode);
if (excutedResult.Status != EnumStatus.Success || excutedResult.Code != SysResultCode.Success)
{
return(ExcutedResult <string> .FailedResult(excutedResult.Code, excutedResult.Message));
}
#endregion
return(ExcutedResult <string> .SuccessResult("", entity.Id.ToString()));
}
catch (Exception ex)
{
Log4NetHelper.WriteError(GetType(), ex, "发送验证码错误");
throw;
}
}
public ExcutedResult <VersionModel> GetCurrentVersion(int clientType)
{
try
{
if (!Enum.IsDefined(typeof(EnumClientType), clientType))
{
return(ExcutedResult <VersionModel> .FailedResult(BusinessResultCode.ArgumentError, "参数错误或无效"));
}
var version = _versionLogic.GetCurrentVersion(clientType);
if (version == null)
{
return(ExcutedResult <VersionModel> .SuccessResult());
}
var anUrl = _configDataLogic.GetByKeyAndLang(ConfigDataKey.AndroidDownUrl);
var iosUrl = _configDataLogic.GetByKeyAndLang(ConfigDataKey.IosDownUrl);
var data = new VersionModel
{
Name = version.Name,
Version = version.Number.Value,
Introduce = version.Desc,
IsForce = version.IsMustUpdate,
DownUrl = (clientType == (int)EnumClientType.Android) ? anUrl : ((clientType == (int)EnumClientType.Ios) ? iosUrl : "")
};
return(ExcutedResult <VersionModel> .SuccessResult(data));
}
catch (BusinessException businessException)
{
return(ExcutedResult <VersionModel> .FailedResult(businessException.ErrorCode, businessException.Message));
}
}
/// <summary>
/// 删
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ExcutedResult DeleteNoticeInfo(string id)
{
try
{
Guid guid = Guid.Empty;
if (string.IsNullOrEmpty(id) || !Guid.TryParse(id, out guid))
{
throw new BusinessException(BusinessResultCode.ArgumentError, "参数错误或无效");
}
var notice = _noticeRepository.GetById(guid);
if (notice == null)
{
throw new BusinessException(BusinessResultCode.DataNotExist, "数据不存在，请刷新!");
}
else
{
_noticeRepository.Delete(notice);
return(ExcutedResult.SuccessResult());
}
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
catch (Exception ex)
{
return(ExcutedResult.FailedResult(SysResultCode.ServerException, "发生异常，请稍后再试或联系管理员"));
}
}
/// <summary>
/// 检测帐号名是否可用
/// </summary>
/// <param name="model"></param>
/// <returns>结果</returns>
public ExcutedResult CheckAccountUseable(ChainAccountRequest model)
{
if (!RegexHelper.IsAccount(model.Account))
{
return(ExcutedResult.FailedResult(BusinessResultCode.AccountNotInRule, "帐号不符合规则"));
}
var flag = Repository.CheckAccountUseable(model);
if (flag)
{
var contract = _contractFactory.GetService <IAccountClient>(model.ChainCode.ToUpper());
var id = contract.GetAccountInfo(model.Account);
id.Wait();
var result = id.Result;
if (result.Status == EnumStatus.Success)
{
if (result.Data == null)
{
return(ExcutedResult.SuccessResult());
}
else
{
return(ExcutedResult.FailedResult(BusinessResultCode.AccountExist, "帐号已存在"));
}
}
return(new ExcutedResult(result.Status, result.Message, result.Code, null));
}
return(ExcutedResult.FailedResult(BusinessResultCode.AccountExist, "帐号已存在"));
}
public void SaveFile(FileHeader fileHeader, byte[] content, out ExcutedResult result)
{
if (fileHeader.Id == default(Guid))
{
fileHeader.Id = Guid.NewGuid();
}
fileHeader.Key = GetKey(content);
fileHeader.CreateTime = DateTimeOffset.Now;
fileHeader.State = 1;
PreSaveFile(fileHeader.Key, out result);
if (result.Status == EnumStatus.Success)
{
return;
}
var file = new File {
Id = fileHeader.Id, Content = content, ContentType = fileHeader.ContentType
};
try
{
_fileRepository.Insert(file);
_fileHeaderRepository.Insert(fileHeader);
result = ExcutedResult.SuccessResult(FileModel.FileHeaderToModel(fileHeader));
}
catch (Exception ex)
{
Log4NetHelper.WriteError(GetType(), ex);
result = ExcutedResult.FailedResult(BusinessResultCode.FileSaveFail, "");
}
}
public ExcutedResult GetQuery(string configKey, int pageIndex = 1, int pageSize = 10, string sortName = "", bool?order = null)
{
try
{
ConfigDataParam param = new ConfigDataParam()
{
ConfigKey = configKey,
PageIndex = pageIndex,
PageSize = pageSize,
SortName = "CreateTime",
IsSortOrderDesc = true
};
if (!string.IsNullOrEmpty(sortName))
{
param.SortName = sortName;
}
if (order.HasValue)
{
param.IsSortOrderDesc = order.Value;
}
var result = _configDataLogic.GetCconfigListQuery(param);
return(ExcutedResult.SuccessResult(result));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
/// <summary>
/// 更新节点信息
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ExcutedResult UpdateNode(UpdateNodeRequestModel model)
{
try
{
var user = CurrentUser;
if (model == null)
{
throw new BusinessException(BusinessResultCode.ArgumentError, "参数错误或无效");
}
model.Vefity();
var node = Repository.GetSingle(model.Id);
var oldNode = node;
if (!String.IsNullOrEmpty(model.Name))
{
node.Name = model.Name;
}
if (!String.IsNullOrEmpty(model.HttpAddress))
{
node.HttpAddress = model.HttpAddress;
}
node.IsSuper = model.IsSuper;
if (model.TimeOut == default(int))
{
node.TimeOut = model.TimeOut;
}
if (model.Priority == default(int))
{
node.Priority = model.Priority;
}
node.QueryAlternative = model.QueryAlternative;
node.PlayerAlternative = model.PlayerAlternative;
node.ServerAlternative = model.ServerAlternative;
if (!String.IsNullOrEmpty(model.Address))
{
node.Address = model.Address;
}
Repository.Update(node);
OperateLog log = new OperateLog();
log.Id = Guid.NewGuid();
log.ClientIp = user.ClientIP;
log.CreateTime = DateTime.UtcNow;
log.ManagerAccount = user.Mobile;
log.ManagerId = user.Id;
log.OriginalValue = JsonConvert.SerializeObject(oldNode);
log.NewValue = JsonConvert.SerializeObject(node);
log.Operate = "Update";
log.Function = "更新节点信息";
_operateLogRepository.Insert(log);
return(ExcutedResult.SuccessResult());
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public void Update(VersionEditRequest entity, out ExcutedResult result)
{
try
{
//查询原始数据
var model = Repository.Get(x => x.Id == entity.Id && x.State == (int)EnumState.Normal).FirstOrDefault();
//如果原始数据不存在，返回提示
if (model == null)
{
result = ExcutedResult.FailedResult(BusinessResultCode.ArgumentError, "操作失败,数据不存在");
return;
}
if (!string.IsNullOrEmpty(entity.Name))
{
model.Name = entity.Name;
}
if (entity.Number != null)
{
model.Number = entity.Number;
}
if (entity.Date != null)
{
model.Date = entity.Date;
}
model.IsMustUpdate = entity.IsMustUpdate;
if (!string.IsNullOrEmpty(entity.Desc))
{
model.Desc = entity.Desc;
}
if (!string.IsNullOrEmpty(entity.Connect))
{
model.Connect = entity.Connect;
}
using (var trans = base.GetNewTransaction())
{
base.Update(model, out result);
if (result.Status != EnumStatus.Success)
{
throw new Exception("更新配置实体失败");
}
trans.Commit();
}
}
catch (Exception e)
{
result = ExcutedResult.FailedResult(BusinessResultCode.OperationFailed, $"{BusinessResultCode.OperationFailed}:{e.Message}");
Log4NetHelper.WriteError(GetType(), e, $"Id:{entity.Id},new Name:{entity.Name},new Number:{entity.Number}");
return;
}
}
public override Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
var request = context.HttpContext.Request;
if (request.Method == "POST")
{
IHttpContextAccessor httpContextAccessor = AspectCoreContainer.CreateScope().Resolve <IHttpContextAccessor>();
var configDataLogic = AspectCoreContainer.CreateScope().Resolve <IConfigDataLogic>();
var ip = httpContextAccessor.HttpContext.GetRequestIp4Address()?.ToString();
var ipWhiteList = configDataLogic.GetByKey(ConfigDataKey.IpWhiteList);
var timestampOffsetMinute = configDataLogic.GetByKey(ConfigDataKey.TimestampOffsetMinute);
double.TryParse(timestampOffsetMinute, out var minute);
var actionParams = StreamHelper.GetStreamText(request.Body);
Dictionary <string, object> jsonDict = JsonConvert.DeserializeObject <Dictionary <string, Object> >(actionParams);
var d = new SortedDictionary <string, object>(jsonDict);
var sss = JsonConvert.SerializeObject(d);
var timeHeader = request.Headers["timestamp"].ToString();
var signHeader = request.Headers["sign"].ToString();
if (timeHeader == "" || signHeader == "")
{
context.Result = new JsonResult(ExcutedResult.FailedResult(BusinessResultCode.NoSign, "调用错误"));
}
else
{
if (long.TryParse(timeHeader, out var timestamp))
{
var time = DateTimeHelper.ConvertFromTimeStamp(timestamp);
if (time == null || time.Value.AddMinutes(minute).ToUniversalTime() < DateTime.UtcNow)
{
context.Result = new JsonResult(ExcutedResult.FailedResult(BusinessResultCode.NoSign, "调用错误"));
}
var sign = ShaHelper.Encrypt(sss + timeHeader);
if (sign != signHeader)
{
context.Result = new JsonResult(ExcutedResult.FailedResult(BusinessResultCode.SignError, "签名错误"));
}
}
else
{
context.Result = new JsonResult(ExcutedResult.FailedResult(BusinessResultCode.NoSign, "调用错误"));
}
}
if (!string.IsNullOrEmpty(ipWhiteList))
{
if (!string.IsNullOrEmpty(ip) && !ipWhiteList.Contains(ip))
{
context.Result =
new JsonResult(ExcutedResult.FailedResult(SysResultCode.ServerException, "Your ip not access"));
}
}
}
return(base.OnActionExecutionAsync(context, next));
}
public ExcutedResult QueryNoticeInfo([FromBody] QueryNoticeRequestModel model)
{
try
{
return(_panguLogic.QueryNoticeInfo(model));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public ExcutedResult GetTimestamp()
{
try
{
return(ExcutedResult.SuccessResult(DateTimeHelper.GetTimeStamp(DateTime.UtcNow, true)));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public ExcutedResult <TransactionDetailModel> GetTransfer(string trxId)
{
if (string.IsNullOrWhiteSpace(trxId))
{
return(ExcutedResult <TransactionDetailModel> .FailedResult(SysResultCode.ParameterInvalid, "参数无效或错误"));
}
var transfer = _accountServiceModel.GetTransfer(trxId);
return(ExcutedResult <TransactionDetailModel> .SuccessResult(transfer));
}
public void PreSaveFile(string key, out ExcutedResult result)
{
var fileHeader = _fileHeaderRepository.FirstOrDefault(p => p.Key == key);
if (fileHeader == null)
{
result = ExcutedResult.FailedResult(BusinessResultCode.FileNotExistYet, "");
return;
}
result = ExcutedResult.SuccessResult(FileModel.FileHeaderToModel(fileHeader));
}
public Task <IActionResult> Edit(SysMenu menu)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return Json(ExcutedResult.FailedResult("数据验证失败"));
}
menuRepository.Edit(menu, true);
return Json(ExcutedResult.SuccessResult());
}));
}