public async Task Scrap(AuthorizedDto <PipelineDto> dto)
{
await Execute(async() => {
using (UnitOfWork db = new UnitOfWork())
{
PipelineEntity pipeline = await db.GetRepo <PipelineEntity>().FirstOrDefault(
p => p.id == dto.Data.Id.Value
);
foreach (PipelineItemEntity pipelineItem in pipeline.PipelineItems)
{
pipelineItem.pipeline_id = null;
pipelineItem.InputPipelineItems.Clear();
pipelineItem.OutputPipelineItems.Clear();
pipelineItem.InputStorageCells.Clear();
pipelineItem.OutputStorageCells.Clear();
}
foreach (StorageCellEntity storageCell in pipeline.StorageCells)
{
storageCell.pipeline_id = null;
}
await db.Save();
}
});
}
public PipelineModel ToPipelineModel(PipelineEntity pipeline)
{
PipelineModel pipelineModel = new PipelineModel();
pipelineModel.Id = pipeline.id;
pipelineModel.CompanyId = pipeline.company_id;
pipelineModel.Connections = new List <PipelineItemConnectionModel>();
foreach (PipelineItemEntity pipelineItem in pipeline.PipelineItems)
{
PipelineItemConnectionModel connectionModel = new PipelineItemConnectionModel();
connectionModel.PipelineItem = pipelineItem.ToModel <PipelineItemModel>();
connectionModel.InputPipelineItems = ModelEntityMapper.Mapper.Map <ICollection <PipelineItemModel> >(
pipelineItem.InputPipelineItems
);
connectionModel.OutputPipelineItems = ModelEntityMapper.Mapper.Map <ICollection <PipelineItemModel> >(
pipelineItem.OutputPipelineItems
);
connectionModel.InputStorageCells = ModelEntityMapper.Mapper.Map <ICollection <StorageCellModel> >(
pipelineItem.InputStorageCells
);
connectionModel.OutputStorageCells = ModelEntityMapper.Mapper.Map <ICollection <StorageCellModel> >(
pipelineItem.OutputStorageCells
);
pipelineModel.Connections.Add(connectionModel);
}
return(pipelineModel);
}
public async Task <PipelineModel> Get(AuthorizedDto <PipelineDto> dto)
{
return(await Execute(async() => {
using (UnitOfWork db = new UnitOfWork())
{
PipelineEntity pipeline = await db.GetRepo <PipelineEntity>().Get(dto.Data.Id.Value);
return ToPipelineModel(pipeline);
}
}));
}
public HrmResultEntity <bool> SavePipeline(PipelineEntity pipeline, List <PipelineStepType> pipelineStep, string dbName)
{
var par = new DynamicParameters();
par.Add("@Id", pipeline.Id);
par.Add("@Name", pipeline.Name);
par.Add("@MenuId", pipeline.MenuId);
par.Add("@Description", pipeline.Description);
par.Add("@IsDefault", pipeline.IsDefault);
par.Add("@CreatedBy", pipeline.CreatedBy);
par.Add("@UpdatedBy", pipeline.UpdatedBy);
par.Add("@DbName", dbName);
par.Add("@PipelineStep", pipelineStep.ConvertToUserDefinedDataTable(), DbType.Object);
return(Procedure("Pipeline_Update_SavePipeline", par));
}
public async Task <PipelineModel> Create(AuthorizedDto <PipelineDto> dto)
{
return(await Execute(async() => {
using (UnitOfWork db = new UnitOfWork())
{
CompanyEntity company = await db.GetRepo <CompanyEntity>().FirstOrDefault(
c => c.owner_id == dto.Data.CompanyId.Value
);
int[] pipelineItemIds = dto.Data.PipelineItemPlacements.Select(p => p.PipelineItemId.Value).ToArray();
int[] storageCellIds = dto.Data.StorageCellPlacements.Select(s => s.StorageCellId.Value).ToArray();
IList <PipelineItemEntity> pipelineItems = await db.GetRepo <PipelineItemEntity>().Get(
pipelineItem => pipelineItem.PipelineItemPrefab.company_id == company.owner_id
);
IList <StorageCellEntity> storageCells = await db.GetRepo <StorageCellEntity>().Get(
storageCell => storageCell.StorageCellPrefab.company_id == company.owner_id
);
PipelineItemEntity[] updatedPipelineItems = pipelineItems.Where(p => pipelineItemIds.Contains(p.id)).ToArray();
StorageCellEntity[] updatedStorageCells = storageCells.Where(s => storageCellIds.Contains(s.id)).ToArray();
this.ValidatePipelineItems(updatedPipelineItems, null);
this.ValidateStorageCells(updatedStorageCells, null);
this.UpdatePipelineItemPlacements(company, updatedPipelineItems, dto.Data.PipelineItemPlacements);
this.UpdateStorageCellPlacements(company, updatedStorageCells, dto.Data.StorageCellPlacements);
PipelineEntity pipeline = new PipelineEntity();
pipeline.company_id = company.owner_id;
await db.GetRepo <PipelineEntity>().Create(pipeline);
this.UpdatePipelineConnections(updatedPipelineItems, updatedStorageCells, dto.Data, pipeline);
await db.Save();
return ToPipelineModel(pipeline);
}
}));
}
private void UpdatePipelineConnections(
ICollection <PipelineItemEntity> pipelineItems,
ICollection <StorageCellEntity> storageCells,
PipelineDto pipelineDto, PipelineEntity pipeline
)
{
foreach (PipelineConnectionDto connection in pipelineDto.Connections)
{
PipelineItemEntity pipelineItemEntity = pipelineItems.FirstOrDefault(
pi => pi.id == connection.PipelineItemId.Value
);
pipelineItemEntity.pipeline_id = pipeline.id;
PipelineItemEntity[] inputPipelineItems = connection.InputPipelineItems.Select(
inputPipelineItem => pipelineItems.FirstOrDefault(pi => pi.id == inputPipelineItem.Id.Value)
).ToArray();
foreach (PipelineItemEntity pipelineItemToRemove in pipelineItemEntity.InputPipelineItems.Except(inputPipelineItems).ToArray())
{
pipelineItemEntity.InputPipelineItems.Remove(pipelineItemToRemove);
}
foreach (PipelineItemEntity pipelineItemToAdd in inputPipelineItems.Except(pipelineItemEntity.InputPipelineItems).ToArray())
{
pipelineItemEntity.InputPipelineItems.Add(pipelineItemToAdd);
}
PipelineItemEntity[] outputPipelineItems = connection.OutputPipelineItems.Select(
outputPipelineItem => pipelineItems.FirstOrDefault(pi => pi.id == outputPipelineItem.Id.Value)
).ToArray();
foreach (PipelineItemEntity pipelineItemToRemove in pipelineItemEntity.OutputPipelineItems.Except(outputPipelineItems).ToArray())
{
pipelineItemEntity.OutputPipelineItems.Remove(pipelineItemToRemove);
}
foreach (PipelineItemEntity pipelineItemToAdd in outputPipelineItems.Except(pipelineItemEntity.OutputPipelineItems).ToArray())
{
pipelineItemEntity.OutputPipelineItems.Add(pipelineItemToAdd);
}
StorageCellEntity[] inputStorageCells = connection.InputStorageCells.Select(
inputStorageCell => storageCells.FirstOrDefault(pi => pi.id == inputStorageCell.Id.Value)
).ToArray();
foreach (StorageCellEntity storageCell in inputStorageCells)
{
storageCell.pipeline_id = pipeline.id;
}
foreach (StorageCellEntity storageCellToRemove in pipelineItemEntity.InputStorageCells.Except(inputStorageCells).ToArray())
{
pipelineItemEntity.InputStorageCells.Remove(storageCellToRemove);
}
foreach (StorageCellEntity storageCellToAdd in inputStorageCells.Except(pipelineItemEntity.InputStorageCells).ToArray())
{
pipelineItemEntity.InputStorageCells.Add(storageCellToAdd);
}
StorageCellEntity[] outputStorageCells = connection.OutputStorageCells.Select(
outputStorageCell => storageCells.FirstOrDefault(pi => pi.id == outputStorageCell.Id.Value)
).ToArray();
foreach (StorageCellEntity storageCell in outputStorageCells)
{
storageCell.pipeline_id = pipeline.id;
}
foreach (StorageCellEntity storageCellToRemove in pipelineItemEntity.OutputStorageCells.Except(outputStorageCells).ToArray())
{
pipelineItemEntity.OutputStorageCells.Remove(storageCellToRemove);
}
foreach (StorageCellEntity storageCellToAdd in outputStorageCells.Except(pipelineItemEntity.OutputStorageCells).ToArray())
{
pipelineItemEntity.OutputStorageCells.Add(storageCellToAdd);
}
}
}
public string SavePipeline(PipelineEntity pipeline, List <PipelineStepType> pipelineStep)
{
var response = this._pipelineRepository.SavePipeline(pipeline, pipelineStep, _dbName);
return(JsonConvert.SerializeObject(response));
}
