public async Task <ApiResult> UpdateColumnAsync(ColumnInfoDO model)
{
var state = this.State;
if (state.ColumnInfos.Any(m => m.Id == model.Id))
{
var columnInfo = state.ColumnInfos.First(mbox => mbox.Id == model.Id);
columnInfo.IsDel = model.IsDel;
columnInfo.SelfColumn = string.IsNullOrWhiteSpace(model.SelfColumn) ? columnInfo.SelfColumn : model.SelfColumn;
columnInfo.ModelColumn = string.IsNullOrWhiteSpace(model.ModelColumn) ? columnInfo.ModelColumn : model.ModelColumn;
columnInfo.Desc = string.IsNullOrWhiteSpace(model.Desc) ? columnInfo.Desc : model.Desc;
columnInfo.SortNo = model.SortNo > 0 ? model.SortNo : columnInfo.SortNo;
columnInfo.DisplayName = string.IsNullOrWhiteSpace(model.DisplayName) ? columnInfo.DisplayName : model.DisplayName;
columnInfo.Version++;
columnInfo.ModityDate = DateTime.Now;
bool bRet = await _columnInfoRepository.SetAsync(columnInfo);
if (!bRet)
{
return(ApiResultUtil.IsFailed("更新失败！"));
}
//刷新缓存
var groupCodes = new List <string> {
this.State.TableInfos.First(mbox => mbox.Id == columnInfo.TableId).GroupCode
};
await RefrshGroupState(groupCodes.ToList());
await this.Persist(Kaneko.Core.Contract.ProcessAction.Update, this.State);
}
return(ApiResultUtil.IsFailed($"列ID【{model.Id}】不存在！"));
}
public async Task <ApiResult> UpdateTableAsync(TableInfoDO model)
{
var state = this.State;
if (state.TableInfos.Any(m => m.Id == model.Id))
{
var tableInfoDO = state.TableInfos.First(mbox => mbox.Id == model.Id);
tableInfoDO.IsDel = model.IsDel;
tableInfoDO.TableName = string.IsNullOrWhiteSpace(model.TableName) ? tableInfoDO.TableName : model.TableName;
tableInfoDO.GroupCode = string.IsNullOrWhiteSpace(model.GroupCode) ? tableInfoDO.GroupCode : model.GroupCode;
tableInfoDO.Desc = string.IsNullOrWhiteSpace(model.Desc) ? tableInfoDO.Desc : model.Desc;
tableInfoDO.Version++;
tableInfoDO.ModityDate = DateTime.Now;
bool bRet = await _tableInfoRepository.SetAsync(tableInfoDO);
if (!bRet)
{
return(ApiResultUtil.IsFailed("更新失败！"));
}
//刷新缓存
var groupCodes = new List <string> {
tableInfoDO.GroupCode
};
await RefrshGroupState(groupCodes.ToList());
await this.Persist(Kaneko.Core.Contract.ProcessAction.Update, this.State);
}
return(ApiResultUtil.IsFailed($"表ID【{model.Id}】不存在！"));
}
public async Task <ApiResult> UpdateAsync(SubmitDTO <XsReceReceivableDTO> model)
{
var dto = model.Data;
if (dto.Version != this.State.Version)
{
return(ApiResultUtil.IsFailed("数据已被修改，请重新再加载！"));
}
dto.Version++;
XsReceReceivableState xsReceReceivableState = this.State;
if (dto.IsDel != 1)
{
}
xsReceReceivableState.IsDel = dto.IsDel;
xsReceReceivableState.ModityBy = model.UserId;
xsReceReceivableState.ModityByName = model.UserName;
xsReceReceivableState.ModityDate = System.DateTime.Now;
xsReceReceivableState.Version = dto.Version;
XsReceReceivableDO xsLadeBaseDO = this.ObjectMapper.Map <XsReceReceivableDO>(xsReceReceivableState);
bool bRet = await _xsReceReceivableRepository.SetAsync(xsLadeBaseDO);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
await this.Persist(ProcessAction.Update, xsReceReceivableState);
return(ApiResultUtil.IsSuccess());
}
public async Task <ApiResult> DeleteAsync(long id)
{
if (id <= 0)
{
return(ApiResultUtil.IsFailed("主键ID不能为空！"));
}
if (!this.State.Balance.Any(m => m.Id == id))
{
return(ApiResultUtil.IsFailed("不存在该字典！"));
}
var currentState = this.State.Balance.First(m => m.Id == id);
bool bRet = await _dictRepository.SetAsync(() => new { is_del = 1, version = (currentState.Version + 1), modity_date = System.DateTime.Now }, oo => oo.Id == id);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
currentState.IsDel = 1;
currentState.ModityDate = System.DateTime.Now;
currentState.Version++;
await this.Persist(ProcessAction.Update, this.State);
return(ApiResultUtil.IsSuccess());
}
/// <summary>
/// 获取详情
/// </summary>
/// <returns></returns>
public async Task <ApiResult <HyFormulaMaterVO> > GetAsync()
{
var state = this.State;
var xsLadeRimpactVO = this.ObjectMapper.Map <HyFormulaMaterVO>(state);
return(await Task.FromResult(ApiResultUtil.IsSuccess(xsLadeRimpactVO)));
}
/// <summary>
/// 删除
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ApiResult> DelAsync(SubmitDTO <HyFormulaMaterDTO> model)
{
var dto = model.Data;
if (dto.Version != this.State.Version)
{
return(ApiResultUtil.IsFailed("数据已被修改，请重新再加载！"));
}
dto.Version++;
HyFormulaMaterState hyFormulaMaterState = this.State;
hyFormulaMaterState.IsDel = 1;
hyFormulaMaterState.ModityBy = model.UserId;
hyFormulaMaterState.ModityByName = model.UserName;
hyFormulaMaterState.ModityDate = System.DateTime.Now;
hyFormulaMaterState.Version = dto.Version;
HyFormulaMaterDO xsLadeRimpactDO = this.ObjectMapper.Map <HyFormulaMaterDO>(hyFormulaMaterState);
bool bRet = await _hyFormulaMaterRepository.SetAsync(xsLadeRimpactDO);;
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
await this.Persist(ProcessAction.Update, hyFormulaMaterState);
return(ApiResultUtil.IsSuccess("处理成功！"));
}
public async Task <ApiResult> UpdateUserInfo(UserInfoModel model)
{
var identity = User.Identity as ClaimsIdentity;
if (identity == null)
{
return(ApiResultUtil.Fail <UserDto>("无法获取Identity信息！"));
}
var userIdClaim = identity.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Prn);
if (userIdClaim == null)
{
return(ApiResultUtil.Fail <UserDto>("无法获取Identity信息"));
}
var userId = userIdClaim.Value;
try
{
await _userService.UpdateInfoAsync(userId, model);
return(ApiResultUtil.Success());
}
catch (Exception ex)
{
_logger.LogError(0, ex, "更新用户信息失败：" + ApiResultUtil.GetMessage(ex));
return(ApiResultUtil.Fail <TokenEntity>("更新用户信息失败！"));
}
}
public async Task <ApiResult> AddAsync(SubmitDTO <ScheduleTaskDTO> model)
{
//参数校验
if (!model.Data.IsValid(out string exMsg))
{
return(ApiResultUtil.IsFailed(exMsg));
}
//转换为数据库实体
ScheduleTaskDO scheduleDO = this.ObjectMapper.Map <ScheduleTaskDO>(model.Data);
scheduleDO.CreateBy = model.UserId;
scheduleDO.CreateDate = System.DateTime.Now;
scheduleDO.ModityBy = model.UserId;
scheduleDO.ModityDate = System.DateTime.Now;
bool bRet = await _scheduleRepository.AddAsync(scheduleDO);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据插入失败！"));
}
//更新服务状态
ScheduleTaskState scheduleTaskState = this.ObjectMapper.Map <ScheduleTaskState>(scheduleDO);
await this.Persist(ProcessAction.Create, scheduleTaskState);
return(ApiResultUtil.IsSuccess(model.Data.Id.ToString()));
}
public async Task <ApiResult <TokenEntity> > Login(LoginModel model)
{
if (!ModelState.IsValid)
{
return(ApiResultUtil.Fail <TokenEntity>("数据不合法!"));
}
var userName = model.UserName;
var password = model.Password;
try
{
var user = await _userService.LoginAsync(userName, password);
if (user == null)
{
return(ApiResultUtil.Fail <TokenEntity>("用户名或密码不正确!"));
}
var tp = TokenUtil.GetProvider();
var token = tp.GenerateToken(user);
return(ApiResultUtil.Success(token));
}
catch (Exception ex)
{
_logger.LogError(0, ex, "登录失败：" + ApiResultUtil.GetMessage(ex));
return(ApiResultUtil.Fail <TokenEntity>("登录失败！"));
}
}
public async Task <ApiResult <UserDto> > GetUserInfo()
{
var identity = User.Identity as ClaimsIdentity;
if (identity == null)
{
return(ApiResultUtil.Fail <UserDto>("无法获取Identity信息！"));
}
var userIdClaim = identity.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Prn);
if (userIdClaim == null)
{
return(ApiResultUtil.Fail <UserDto>("无法获取Identity信息"));
}
try
{
var user = await _userService.GetInfoAsync(userIdClaim.Value);
return(ApiResultUtil.Success(user));
}
catch (Exception ex)
{
_logger.LogError(0, ex, "获取用户信息失败：" + ApiResultUtil.GetMessage(ex));
return(ApiResultUtil.Fail <UserDto>("获取用户信息失败！"));
}
}
public async Task <ApiResult> UpdateAsync(SubmitDTO <ScheduleTaskDTO> model)
{
var dto = model.Data;
if (dto.Version != this.State.Version)
{
return(ApiResultUtil.IsFailed("数据已被修改，请重新再加载！"));
}
bool bRet = await _scheduleRepository.SetAsync(() => new { task_name = dto.TaskName, line_code = dto.LineCode, version = (dto.Version + 1) }, oo => oo.Id == this.GrainId);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
ScheduleTaskState scheduleTaskState = this.State;
scheduleTaskState.TaskName = dto.TaskName;
scheduleTaskState.LineCode = dto.LineCode;
scheduleTaskState.Version++;
///任务完成 进行系统对接
if (dto.TaskState == TaskState.Complete)
{
TaskListModel scheduleTaskModel = new TaskListModel()
{
TaskCode = dto.TaskCode
};
await Observer.PublishAsync(EventContract.ComConcrete.TaskListToZK, scheduleTaskModel);
}
await this.Persist(ProcessAction.Update, scheduleTaskState);
return(ApiResultUtil.IsSuccess());
}
/// <summary>
/// 查看发货单作废
/// </summary>
/// <returns></returns>
public async Task <ApiResult <XsLadeRimpactVO> > GetAsync()
{
var state = this.State;
var xsLadeRimpactVO = this.ObjectMapper.Map <XsLadeRimpactVO>(state);
//获取企业数据
if (!string.IsNullOrEmpty(xsLadeRimpactVO.XLR_Firm))
{
var itemResult = await _orleansClient.GetGrain <IPbBasicFirmStateGrain>(GrainIdKey.UtcUIDGrainKey.ToString()).GetAllSync(new PbBasicFirmDTO
{
Ids = new List <string> {
xsLadeRimpactVO.XLR_Firm
}
});
if (itemResult.Success)
{
xsLadeRimpactVO.XLR_FirmName = itemResult.Data.FirstOrDefault().PBF_ShortName;
}
}
//获取发货单编码
if (!string.IsNullOrEmpty(xsLadeRimpactVO.XLR_Lade))
{
var itemResult = await GrainFactory.GetGrain <IXsLadeBaseStateGrain>(xsLadeRimpactVO.XLR_Lade).GetAsync();
if (itemResult.Success)
{
xsLadeRimpactVO.XLB_LadeId = itemResult.Data.XLB_LadeId;
}
}
return(await Task.FromResult(ApiResultUtil.IsSuccess(xsLadeRimpactVO)));
}
public Task <ApiResultList <DictVO> > GetListAsync()
{
var balance = this.State.Balance;
List <DictVO> dictVOs = this.ObjectMapper.Map <List <DictVO> >(balance);
return(Task.FromResult(ApiResultUtil.IsSuccess <DictVO>(dictVOs)));
}
public Task <ApiResult <XsLadeBaseVO> > GetAsync()
{
var state = this.State;
var scheduleVO = this.ObjectMapper.Map <XsLadeBaseVO>(state);
return(Task.FromResult(ApiResultUtil.IsSuccess(scheduleVO)));
}
public async Task <ApiResult <TestVO> > GetResultTest1(TestDTO dto)
{
//参数校验
if (!dto.IsValid(out Exception ex))
{
throw ex;
}
var expression = dto.GetExpression();
var orders = dto.GetOrder();
//var count = await _testRepository.CountAsync(expression);
//var updateResult1 = await _testRepository.SetAsync(() => new { user_id = "eeeee" }, oo => oo.UserId == "4444");
TestDO demoDO = new TestDO {
UserId = dto?.UserId, UserName = this.CurrentUser?.UserName
};
//var updateResult3 = await _testRepository.SetAsync(demoDO);
TestVO demoVO = this.ObjectMapper.Map <TestVO>(demoDO);
var result = ApiResultUtil.IsSuccess(demoVO);
return(await Task.FromResult(result));
}
/// <summary>
/// 重置状态数据
/// </summary>
/// <returns></returns>
public virtual async Task <ApiResult> ReinstantiateState(TState state = default)
{
try
{
TState result = (TState)state;
if (result == null)
{
var onReadDbTask = OnReadFromDbAsync();
if (!onReadDbTask.IsCompletedSuccessfully)
{
await onReadDbTask;
}
result = onReadDbTask.Result;
}
if (result != null)
{
State = result;
await WriteStateAsync();
}
else
{
await ClearStateAsync();
}
return(ApiResultUtil.IsSuccess());
}
catch (Exception ex)
{
Logger.LogError("刷新状态", ex);
return(ApiResultUtil.IsFailed(ex.Message));
}
}
public async Task <ApiResult> AddAsync(SubmitDTO <XsReceReceivableDTO> model)
{
var dto = model.Data;
//转换为数据库实体
XsReceReceivableDO xsReceReceivableDO = this.ObjectMapper.Map <XsReceReceivableDO>(dto);
xsReceReceivableDO.CreateBy = model.UserId;
xsReceReceivableDO.CreateByName = model.UserName;
xsReceReceivableDO.CreateDate = System.DateTime.Now;
xsReceReceivableDO.ModityBy = model.UserId;
xsReceReceivableDO.ModityByName = model.UserName;
xsReceReceivableDO.ModityDate = System.DateTime.Now;
bool bRet = await _xsReceReceivableRepository.AddAsync(xsReceReceivableDO);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据插入失败！"));
}
//string sql = _xsLadeRimpactRepository.ExecuteScript;
//更新服务状态
XsReceReceivableState xsLadeBaseState = this.ObjectMapper.Map <XsReceReceivableState>(xsReceReceivableDO);
await this.Persist(ProcessAction.Create, xsLadeBaseState);
return(ApiResultUtil.IsSuccess(dto.Id.ToString()));
}
public async Task <ApiResult> UpdateAsync(SubmitDTO <ScheduleTaskDTO> model)
{
var dto = model.Data;
if (dto.Version != this.State.Version)
{
return(ApiResultUtil.IsFailed("数据已被修改，请重新再加载！"));
}
bool bRet = await _scheduleRepository.SetAsync(() => new { task_name = dto.TaskName, line_code = dto.LineCode, version = (dto.Version + 1) }, oo => oo.Id == this.GrainId);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据更新失败！"));
}
ScheduleTaskState scheduleTaskState = this.State;
scheduleTaskState.TaskName = dto.TaskName;
scheduleTaskState.LineCode = dto.LineCode;
scheduleTaskState.Version++;
///任务完成 进行系统对接
if (dto.TaskState == TaskState.Complete)
{
ScheduleTaskVO scheduleTaskVO = this.ObjectMapper.Map <ScheduleTaskVO>(this.State);
await PublishAsync(scheduleTaskVO);
}
await this.Persist(ProcessAction.Update, scheduleTaskState);
return(ApiResultUtil.IsSuccess());
}
public async Task <ApiResult <MaterialDO> > GetSync(MaterialDTO model)
{
var expression = model.GetExpression();
var entities = await _materialRepository.GetAsync(expression);
return(ApiResultUtil.IsSuccess(entities));
}
/// <summary>
/// 获取列表数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ApiResultList <XsLadeBaseDO> > GetAllSync(XsLadeBaseDTO model)
{
var expression = model.GetExpression();
var orders = model.GetOrder();
var entities = await _xsLadeBaseRepository.GetAllAsync(expression, isMaster : false, orderByFields : orders);
return(ApiResultUtil.IsSuccess <XsLadeBaseDO>(entities?.ToList()));
}
/// <summary>
/// 发布
/// </summary>
/// <returns></returns>
public Task <ApiResult> CapBusTest()
{
//发送消息给客户端，第一个参值数"kjframe.test"为消息队列的topic
_capBus.PublishAsync("kanoko.test", DateTime.Now);
var result = ApiResultUtil.IsSuccess();
return(Task.FromResult(result));
}
/// <summary>
/// 获取列表数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public Task <ApiResultList <PbCodeMaterialDO> > GetAllSync(PbCodeMaterialDTO model)
{
if (this.State.Balance.Any(mbox => model.Ids.Contains(mbox.PCM_ID)))
{
return(Task.FromResult(ApiResultUtil.IsSuccess <PbCodeMaterialDO>(this.State.Balance.Where(mbox => model.Ids.Contains(mbox.PCM_ID))?.ToList())));
}
return(Task.FromResult(ApiResultUtil.IsFailedList <PbCodeMaterialDO>("无数据！")));
}
public Task <ApiResult> DeleteAsync(string Id)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(Task.FromResult(ApiResultUtil.IsFailed("Id不能为空！")));
}
return(factory.GetGrain <IXsLadeBaseStateGrain>(Id).DeleteAsync());
}
public Task <ApiResultList <DictVO> > GetListAsync(string dataType)
{
if (string.IsNullOrEmpty(dataType))
{
return(Task.FromResult(ApiResultUtil.IsFailedList <DictVO>("字典类型不能为空！")));
}
return(factory.GetGrain <IDictDataTypeStateGrain>(dataType).GetListAsync());
}
public Task <ApiResult> DeleteAsync(string dataType, long id)
{
if (string.IsNullOrEmpty(dataType))
{
return(Task.FromResult(ApiResultUtil.IsFailed("字典类型不能为空！")));
}
return(factory.GetGrain <IDictDataTypeStateGrain>(dataType).DeleteAsync(id));
}
public Task <ApiResult> UpdateAsync([FromForm] SubmitDTO <ScheduleTaskDTO> model)
{
if (model.Data.Id <= 0)
{
return(Task.FromResult(ApiResultUtil.IsFailed("Id不能为空！")));
}
return(factory.GetGrain <IScheduleTaskStateGrain>(model.Data.Id).UpdateAsync(model));
}
public Task <ApiResult> DelAsync([FromForm] SubmitDTO <HyFormulaMaterDTO> model)
{
if (string.IsNullOrWhiteSpace(model.Data.Id))
{
return(Task.FromResult(ApiResultUtil.IsFailed("Id不能为空！")));
}
return(factory.GetGrain <IHyFormulaMaterStateGrain>(model.Data.Id).DelAsync(model));
}
/// <summary>
/// 获取列表数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public Task <ApiResultList <XsCompyBaseDO> > GetAllSync(XsCompyBaseDTO model)
{
if (this.State.Balance.Any(mbox => model.Ids.Contains(mbox.XOB_ID)))
{
return(Task.FromResult(ApiResultUtil.IsSuccess <XsCompyBaseDO>(this.State.Balance.Where(mbox => model.Ids.Contains(mbox.XOB_ID))?.ToList())));
}
return(Task.FromResult(ApiResultUtil.IsFailedList <XsCompyBaseDO>("无数据！")));
}
public Task <ApiResult> UpdateAsync([FromForm] SubmitDTO <DictDTO> model)
{
if (string.IsNullOrEmpty(model.Data.DataType))
{
return(Task.FromResult(ApiResultUtil.IsFailed("字典类型不能为空！")));
}
return(factory.GetGrain <IDictDataTypeStateGrain>(model.Data.DataType).UpdateAsync(model));
}
public Task <ApiResult> UpdateAsync([FromForm] SubmitDTO <XsLadeBaseDTO> model)
{
if (string.IsNullOrWhiteSpace(model.Data.Id))
{
return(Task.FromResult(ApiResultUtil.IsFailed("Id不能为空！")));
}
return(factory.GetGrain <IXsLadeBaseStateGrain>(model.Data.Id).UpdateAsync(model));
}
