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 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());
}
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()));
}
/// <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));
}
}
/// <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)));
}
public async Task <ApiResult <MaterialDO> > GetSync(MaterialDTO model)
{
var expression = model.GetExpression();
var entities = await _materialRepository.GetAsync(expression);
return(ApiResultUtil.IsSuccess(entities));
}
/// <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 <ApiResult <XsLadeBaseVO> > GetAsync()
{
var state = this.State;
var scheduleVO = this.ObjectMapper.Map <XsLadeBaseVO>(state);
return(Task.FromResult(ApiResultUtil.IsSuccess(scheduleVO)));
}
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());
}
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>
/// <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> 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> 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()));
}
/// <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 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>
/// <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>("无数据！")));
}
/// <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 async Task <ApiResult <ScheduleTaskVO> > GetAsync()
{
await Task.WhenAll(Enumerable.Range(0, 10).Select(x => NewLongID(x)));
var state = this.State;
var scheduleVO = this.ObjectMapper.Map <ScheduleTaskVO>(state);
return(await Task.FromResult(ApiResultUtil.IsSuccess(scheduleVO)));
}
public Task <ApiResult <TestVO> > GetResult(TestDTO dto)
{
var ddd = this.State;
this.State.UID = System.DateTime.Now.ToString();
this.WriteStateAsync();
var result = ApiResultUtil.IsSuccess(new TestVO());
return(Task.FromResult(result));
}
public async Task <ApiResult <ScheduleTaskVO> > GetAsync()
{
var state = this.State;
var scheduleVO = this.ObjectMapper.Map <ScheduleTaskVO>(state);
var dd = await this.GrainFactory.GetGrain <IScheduleTaskGrain>("1").GetPageSync(new SearchDTO <ScheduleTaskDTO> {
PageIndex = 1, PageSize = 10
});
return(await Task.FromResult(ApiResultUtil.IsSuccess(scheduleVO)));
}
public Task <ApiResult <DictVO> > GetAsync(long id)
{
if (this.State.Balance.Any(m => m.Id == id))
{
var dictDO = this.State.Balance.First(m => m.Id == id);
DictVO dictVO = this.ObjectMapper.Map <DictVO>(dictDO);
return(Task.FromResult(ApiResultUtil.IsSuccess(dictVO)));
}
return(Task.FromResult(ApiResultUtil.IsFailed <DictVO>("无数据！")));
}
public async Task <ApiResult> AddColumnAsync(List <ColumnInfoDTO> model)
{
//参数校验
if (!model.IsValid(out string exMsg))
{
return(ApiResultUtil.IsFailed(exMsg));
}
List <ColumnInfoDO> columnInfos = new List <ColumnInfoDO>();
List <string> groupCodes = new List <string>();
foreach (var column in model)
{
if (columnInfos.Any(mbox => mbox.SelfColumn == column.SelfColumn))
{
return(ApiResultUtil.IsFailed($"列名称【{column.SelfColumn}】重复！"));
}
if (!this.State.TableInfos.Any(mbox => mbox.Id == column.TableId))
{
return(ApiResultUtil.IsFailed($"表ID【{column.TableId}】不存在！"));
}
groupCodes.Add(this.State.TableInfos.First(mbox => mbox.Id == column.TableId).GroupCode);
long columnId = await this.GrainFactory.GetGrain <IUtcUID>(GrainIdKey.UtcUIDGrainKey).NewLongID();
var columnInfo = this.ObjectMapper.Map <ColumnInfoDO>(column);
columnInfo.Id = columnId;
columnInfo.CreateDate = System.DateTime.Now;
columnInfo.ModityDate = System.DateTime.Now;
columnInfos.Add(columnInfo);
}
bool bRet = await _columnInfoRepository.AddAsync(columnInfos.ToArray());
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据保存失败！"));
}
var state = this.State;
state.ColumnInfos.AddRange(columnInfos);
//刷新缓存
await RefrshGroupState(groupCodes.Distinct().ToList());
await this.Persist(Kaneko.Core.Contract.ProcessAction.Create, state);
return(ApiResultUtil.IsSuccess());
}
public Task <ApiResultPage <TestVO> > GetResultTest2(TestDTO dto)
{
var dd = RequestContext.Get("ddd").ToString();
List <TestDO> demoDO = new List <TestDO>()
{
new TestDO {
UserId = dd, UserName = dto.UserId
}
};
List <TestVO> demoVO = this.ObjectMapper.Map <List <TestVO> >(demoDO);
var result = ApiResultUtil.IsSuccess(demoVO, 2);
return(Task.FromResult(result));
}
public async Task <ApiResult> DeleteAsync()
{
if (string.IsNullOrEmpty(this.GrainId))
{
return(ApiResultUtil.IsFailed("主键ID不能为空！"));
}
bool bRet = await _xsLadeBaseRepository.DeleteAsync(oo => oo.Id == this.GrainId);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据删除失败！"));
}
await this.Persist(ProcessAction.Delete);
return(ApiResultUtil.IsSuccess());
}
public async Task <ApiResult> DeleteAsync()
{
if (this.GrainId <= 0)
{
return(ApiResultUtil.IsFailed("主键ID不能为空！"));
}
bool bRet = await _scheduleRepository.DeleteAsync(oo => oo.Id == this.GrainId);
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据删除失败！"));
}
await this.Persist(ProcessAction.Delete);
return(ApiResultUtil.IsSuccess());
}
/// <summary>
/// 分布式事务
/// </summary>
/// <returns></returns>
public async Task <ApiResult> CapWithTransaction()
{
var bRet = await _scheduleRepository.BeginTransactionAsync(async transaction =>
{
bool result = await _scheduleRepository.SetAsync(() => new { task_name = "cesces" }, oo => oo.Id == this.GrainId);
TaskListModel scheduleTaskModel = new TaskListModel()
{
TaskCode = "sssss"
};
await this.PublishAsync(scheduleTaskModel);
transaction.Commit();
return(result);
});
return(ApiResultUtil.IsSuccess());
}
/// <summary>
/// 获取分页列表数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ApiResultPageLR <XsLadeBaseVO> > GetPageLRSync(SearchDTO <XsLadeBaseDTO> model)
{
var dto = model.Data;
var expression = dto.GetExpression();
var orders = dto.GetOrder();
var count = await _xsLadeBaseRepository.CountAsync(expression, isMaster : false);
if (count == 0)
{
return(ApiResultUtil.IsFailedPageLR <XsLadeBaseVO>("无数据！"));
}
var entities = await _xsLadeBaseRepository.GetListAsync(model.PageIndex, model.PageSize, expression, isMaster : false, orderByFields : orders);
var scheduleTaskVOs = this.ObjectMapper.Map <List <XsLadeBaseVO> >(entities);
return(ApiResultUtil.IsSuccess(scheduleTaskVOs, count, model.PageIndex, model.PageSize));
}
/// <summary>
/// 获取分页列表数据
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ApiResultPageLR <HyFormulaMaterVO> > GetPageLRSync(SearchDTO <HyFormulaMaterDTO> model)
{
var dto = model.Data;
//根据查询条件获取分页列表数据
var expression = dto.GetExpression();
var orders = dto.GetOrder();
var count = await _hyFormulaMaterRepository.CountAsync(expression);
if (count == 0)
{
return(ApiResultUtil.IsFailedPageLR <HyFormulaMaterVO>("无数据！"));
}
var entities = await _hyFormulaMaterRepository.GetListAsync(model.PageIndex, model.PageSize, expression, isMaster : false, orderByFields : orders);
var hyFormulaMaterVOs = this.ObjectMapper.Map <List <HyFormulaMaterVO> >(entities);
return(ApiResultUtil.IsSuccess(hyFormulaMaterVOs, count, model.PageIndex, model.PageSize));
}
/// <summary>
/// 新增
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <ApiResult> AddAsync(SubmitDTO <HyFormulaMaterDTO> model)
{
var dto = model.Data;
HyFormulaMaterDO hyFormulaMaterDO = this.ObjectMapper.Map <HyFormulaMaterDO>(dto);
hyFormulaMaterDO.Create(model.UserId, model.UserName);
bool bRet = await _hyFormulaMaterRepository.AddAsync(hyFormulaMaterDO);;
if (!bRet)
{
return(ApiResultUtil.IsFailed("数据插入失败！"));
}
//更新服务状态
HyFormulaMaterState hyFormulaMaterState = this.ObjectMapper.Map <HyFormulaMaterState>(hyFormulaMaterDO);
await this.Persist(ProcessAction.Create, hyFormulaMaterState);
return(ApiResultUtil.IsSuccess("处理成功！"));
}