/// <summary>
/// 获取联系人
/// </summary>
/// <returns></returns>
public ExcutedResult GetContacts(ChainModel model)
{
var user = CurrentUser;
var result = Repository.GetContacts(user.Id);
return(ExcutedResult.SuccessResult(result));
}
/// <summary>
/// 添加联系人
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ExcutedResult AddContacts(AddContactsRequest model)
{
var user = CurrentUser;
using (var trans = base.GetNewTransaction())
{
Contacts entity = new Contacts
{
Id = Guid.NewGuid(),
UserId = user.Id,
Name = model.Name,
Desc = model.Desc,
Mobile = model.Mobile
};
Create(entity, out var excuted);
foreach (var item in model.ContactAccounts)
{
ContactsAccount account = new ContactsAccount
{
ContactsId = entity.Id,
Mobile = entity.Mobile,
Name = entity.Name,
ChainCode = item.ChainCode,
Account = item.Account,
CreateTime = DateTime.UtcNow,
};
_contactsAccountRepository.Add(account);
}
trans.Commit();
}
return(ExcutedResult.SuccessResult());
}
/// <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));
}
}
/// <summary>
/// 编辑联系人
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ExcutedResult EditContacts(EditContactsRequest model)
{
var entity = GetById(model.Id);
using (var trans = base.GetNewTransaction())
{
entity.Name = model.Name;
entity.Mobile = model.Mobile;
entity.Desc = model.Desc;
_contactsAccountRepository.Delete(p => p.ContactsId == entity.Id);
List <ContactsAccount> accounts = new List <ContactsAccount>();
foreach (var item in model.ContactAccounts)
{
ContactsAccount account = new ContactsAccount
{
ContactsId = entity.Id,
Mobile = entity.Mobile,
Name = entity.Name,
ChainCode = item.ChainCode,
Account = item.Account,
CreateTime = DateTime.UtcNow,
};
accounts.Add(account);
}
_contactsAccountRepository.AddRange(accounts);
trans.Commit();
}
return(ExcutedResult.SuccessResult());
}
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));
}
}
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 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 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 override void Create(Node entity, out ExcutedResult result)
{
entity.State = (int)EnumState.Normal;
//entity.DeleteIp = "";
//entity.Deleter = "";
base.Create(entity, out result);
result.Data = entity.Id;
}
public Task <IActionResult> GetMenus()
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var rows = menuRepository.GetHomeMenusByTreeView(m => m.Activable && m.Visiable && string.IsNullOrEmpty(m.ParentId)).OrderBy(m => m.SortIndex).ToList();
return Json(ExcutedResult.SuccessResult(rows));
}));
}
public Task <IActionResult> Delete(string id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
menuRepository.Delete(id);
return Json(ExcutedResult.SuccessResult("成功删除一条数据。"));
}));
}
public async Task <ExcutedResult> TransactionBinToJson(string hexData)
{
var abiSer = new AbiSerializationProvider(new NgkApi(Configurator, new HttpHandler()));
var transaction = await abiSer.DeserializePackedTransaction(hexData);
return(ExcutedResult.SuccessResult(transaction));
}
public Task <IActionResult> GetEntities()
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var rows = TaskInfoRepository.Get().ToList();
return Json(ExcutedResult.SuccessResult(rows));
}));
}
public Task <IActionResult> Delete(int id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
TaskInfoRepository.Delete(id, false);
return Json(ExcutedResult.SuccessResult("成功删除一条数据。"));
}));
}
/// <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 Task <IActionResult> Delete(string id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var menuRepository = this.GetService <ISysMenuRepository>();
menuRepository.Delete(id);
return Json(ExcutedResult.SuccessResult("成功删除一条数据。"));
}));
}
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 Task <IActionResult> Active(string id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var entity = menuRepository.GetSingle(id);
entity.Activable = !entity.Activable;
menuRepository.Update(entity, false, "Activable");
return Json(ExcutedResult.SuccessResult(entity.Activable?"OK，已成功启用。":"OK，已成功停用"));
}));
}
public Task <IActionResult> Visualize(string id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var entity = menuRepository.GetSingle(id);
entity.Visiable = !entity.Visiable;
menuRepository.Update(entity, false, "Visiable");
return Json(ExcutedResult.SuccessResult("操作成功，请刷新当前网页或者重新进入系统。"));
}));
}
public Task <IActionResult> GetVueMenus()
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var rows = this.GetService <ISysMenuRepository>()
.GetHomeMenusByTreeView(m => m.Active && m.Visible && string.IsNullOrEmpty(m.ParentId))
.OrderBy(m => m.SortIndex).Select(ToJsonViewModel).ToList();
return Json(ExcutedResult.SuccessResult(rows));
}));
}
public Task <IActionResult> Active(string id)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
var menuRepository = this.GetService <ISysMenuRepository>();
var entity = menuRepository.GetSingle(id);
entity.Active = !entity.Active;
menuRepository.Update(entity, "Active");
return Json(ExcutedResult.SuccessResult(entity.Active?"OK，已成功启用。":"OK，已成功停用"));
}));
}
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 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 ExcutedResult QueryNoticeInfo([FromBody] QueryNoticeRequestModel model)
{
try
{
return(_panguLogic.QueryNoticeInfo(model));
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public ExcutedResult Edit([FromBody] TokenEditModel model)
{
try
{
var result = _tokensLogic.Edit(model);
return(result);
}
catch (BusinessException businessException)
{
return(ExcutedResult.FailedResult(businessException.ErrorCode, businessException.Message));
}
}
public Task <IActionResult> Edit(TaskInfo model)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return Json(ExcutedResult.FailedResult("数据验证失败"));
}
TaskInfoRepository.Edit(model, false);
return Json(ExcutedResult.SuccessResult());
}));
}
public Task <IActionResult> Add(SysRole model)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return Json(ExcutedResult.FailedResult("数据验证失败"));
}
SysRoleRepository.AddAsync(model, false);
return Json(ExcutedResult.SuccessResult());
}));
}
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());
}));
}
