public async Task <OperationDataResult <int> > CreateItemType(ItemTypeCreateModel itemTypeCreateModel)
{
try
{
var tags = new List <InventoryTag>();
if (itemTypeCreateModel.TagIds.Count > 0)
{
tags = _dbContext.InventoryTags
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => itemTypeCreateModel.TagIds.Contains(x.Id))
.ToList();
//if (tags.Count != itemTypeCreateModel.TagIds.Count)
//{
// return new OperationResult(false,
// _inventoryLocalizationService.GetString("TagsNotFound"));
//}
}
var itemType = new ItemType
{
Name = itemTypeCreateModel.Name,
Description = itemTypeCreateModel.Description,
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
Usage = itemTypeCreateModel.Usage,
RiskDescription = itemTypeCreateModel.RiskDescription,
ItemGroupId = itemTypeCreateModel.ItemGroupId,
};
await itemType.Create(_dbContext);
// create dependencies
foreach (var dependency in itemTypeCreateModel.Dependencies)
{
if (await _dbContext.ItemGroups.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed).Where(x => x.Id == dependency.ItemGroupId).AnyAsync())
{
// create item group dependency
var dependencyItemGroup = new ItemGroupDependency
{
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
ItemGroupId = (int)dependency.ItemGroupId,
ItemTypeId = itemType.Id,
};
await dependencyItemGroup.Create(_dbContext);
// create item type dependency
foreach (var dependencyItemTypesId in dependency.ItemTypesIds)
{
if (await _dbContext.ItemTypes.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed).Where(x => x.Id == dependencyItemTypesId).AnyAsync())
{
var dependencyItemType = new ItemTypeDependency
{
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
ParentItemTypeId = itemType.Id,
DependItemTypeId = dependencyItemTypesId,
};
await dependencyItemType.Create(_dbContext);
}
}
}
}
// creating a dependency between tag and item type
foreach (var itemTypeTag in tags.Select(inventoryTag => new ItemTypeTag
{
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
InventoryTagId = inventoryTag.Id,
ItemTypeId = itemType.Id,
}))
{
await itemTypeTag.Create(_dbContext);
}
return(new OperationDataResult <int>(true, itemType.Id));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <int>(false,
_inventoryLocalizationService.GetString("ErrorWhileCreatingItemType")));
}
}
public async Task <OperationResult> UpdateItemType(ItemTypeUpdateModel updateModel)
{
try
{
var itemTypesFromDb = await _dbContext.ItemTypes
.Where(x => x.Id == updateModel.Id)
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Include(x => x.ItemTypeTags)
.Include(x => x.ItemGroupDependencies)
.Include(x => x.ItemTypeUploadedDatas)
.FirstOrDefaultAsync();
if (itemTypesFromDb == null)
{
return(new OperationResult(false, _inventoryLocalizationService.GetString("InventoryItemTypeNotFount")));
}
var tagIds = itemTypesFromDb.ItemTypeTags
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(x => x.InventoryTagId)
.ToList();
var tagsForDelete = itemTypesFromDb.ItemTypeTags
.Where(x => !updateModel.TagIds.Contains(x.InventoryTagId))
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.ToList();
var tagsForAdd = updateModel.TagIds
.Where(x => !tagIds.Contains(x))
.ToList();
// delete tags from item type
foreach (var itemTypeTag in tagsForDelete)
{
await itemTypeTag.Delete(_dbContext);
}
// add tags to item type
foreach (var tagId in tagsForAdd)
{
var tag = await _dbContext.InventoryTags
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.Id == tagId)
.FirstOrDefaultAsync();
if (tag != null)
{
var itemTypeTag = new ItemTypeTag
{
InventoryTagId = tag.Id,
ItemTypeId = itemTypesFromDb.Id,
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
};
await itemTypeTag.Create(_dbContext);
}
}
var dependItemTypes = _dbContext.ItemTypeDependencies
.Where(x => x.ParentItemTypeId == itemTypesFromDb.Id)
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.ToList();
var itemGroupDependenciesForDelete = itemTypesFromDb.ItemGroupDependencies
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => updateModel.DependenciesIdsForDelete.Contains(x.Id))
.ToList();
var itemGroupIdsDependenciesForAdd = updateModel.Dependencies.Where(x =>
!itemTypesFromDb.ItemGroupDependencies
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Select(y => y.ItemGroupId).ToList()
.Contains((int)x.ItemGroupId))
.Select(x => x.ItemGroupId);
var itemTypeDependenciesForDelete = dependItemTypes.Where(x =>
updateModel.Dependencies.Any(y => y.ItemTypesIds.Any(z => z != x.DependItemTypeId))).ToList();
var itemTypeDependenciesForAdd = updateModel.Dependencies
.SelectMany(x => x.ItemTypesIds)
.Where(x => !dependItemTypes.Select(y => y.DependItemTypeId).Contains(x));
// remove item group Dependency from item type
foreach (var itemGroupDependency in itemGroupDependenciesForDelete)
{
await itemGroupDependency.Delete(_dbContext);
}
foreach (var itemTypeDependency in itemTypeDependenciesForDelete)
{
await itemTypeDependency.Delete(_dbContext);
}
// add item group Dependency to item type
foreach (var dependency in itemGroupIdsDependenciesForAdd)
{
if (await _dbContext.ItemGroups.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed).Where(x => x.Id == dependency).AnyAsync())
{
// create item group dependency
var dependencyItemGroup = new ItemGroupDependency
{
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
ItemGroupId = (int)dependency,
ItemTypeId = itemTypesFromDb.Id,
};
await dependencyItemGroup.Create(_dbContext);
}
}
// create item type dependency
foreach (var dependencyItemTypesId in itemTypeDependenciesForAdd)
{
if (await _dbContext.ItemTypes.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed).Where(x => x.Id == dependencyItemTypesId).AnyAsync())
{
var dependencyItemType = new ItemTypeDependency
{
CreatedByUserId = _userService.UserId,
UpdatedByUserId = _userService.UserId,
ParentItemTypeId = itemTypesFromDb.Id,
DependItemTypeId = dependencyItemTypesId,
};
await dependencyItemType.Create(_dbContext);
}
}
// delete uploaded images
foreach (var uploadedDataType in itemTypesFromDb.ItemTypeUploadedDatas
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed))
{
if (uploadedDataType.Type == TypeUploadedData.Pictogram &&
updateModel.PictogramImagesForDelete.Contains(uploadedDataType.Id) ||
uploadedDataType.Type == TypeUploadedData.Danger &&
updateModel.DangerLabelImagesForDelete.Contains(uploadedDataType.Id))
{
uploadedDataType.UpdatedByUserId = _userService.UserId;
await uploadedDataType.Delete(_dbContext);
}
}
itemTypesFromDb.RiskDescription = updateModel.RiskDescription;
itemTypesFromDb.UpdatedByUserId = _userService.UserId;
itemTypesFromDb.ItemGroupId = updateModel.ItemGroupId;
itemTypesFromDb.Description = updateModel.Description;
itemTypesFromDb.Usage = updateModel.Usage;
itemTypesFromDb.Name = updateModel.Name;
await itemTypesFromDb.Update(_dbContext);
return(new OperationResult(true,
_inventoryLocalizationService.GetString("InventoryItemTypeUpdatedSuccessfully")));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationResult(false,
_inventoryLocalizationService.GetString("ErrorWhileUpdateInventoryItemType")));
}
}
