/// <summary>Gets the inventory tags.</summary>
public async Task <OperationDataResult <List <CommonTagModel> > > GetInventoryTags()
{
try
{
var inventoryTags = await _dbContext.InventoryTags
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsNoTracking()
.Select(x => new CommonTagModel
{
Id = x.Id,
Name = x.Name
}).OrderBy(x => x.Name).ToListAsync();
return(new OperationDataResult <List <CommonTagModel> >(
true,
inventoryTags));
}
catch (Exception e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
return(new OperationDataResult <List <CommonTagModel> >(
false,
_inventoryLocalizationService.GetString("ErrorWhileObtainingInventoryTags")));
}
}
public async Task <OperationDataResult <InventorySettingsModel> > GetSettings()
{
var sdkCore =
await _coreService.GetCore();
await using var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
try
{
var option = _options.Value;
var siteIds = _dbContext.AssignedSites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(site => site.SiteUid)
.ToList();
var assignetSites = sdkDbContext.Sites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => siteIds.Contains((int)x.MicrotingUid))
.Select(x => new SiteNameDto((int)x.MicrotingUid, x.Name, x.CreatedAt, x.UpdatedAt))
.ToList();
var settings = new InventorySettingsModel
{
AssignedSites = assignetSites,
FolderId = option.FolderId,
};
return(new OperationDataResult <InventorySettingsModel>(true, settings));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <InventorySettingsModel>(false,
_inventoryLocalizationService.GetString("ErrorWhileObtainingInventorySettings")));
}
}
public async Task <OperationDataResult <Paged <ItemGroupModel> > > GetItemGroups(ItemGroupRequestModel itemGroupRequestModel)
{
try
{
var inventoryItemGroupQuery = _dbContext.ItemGroups
.AsQueryable();
// sort
var excludeSort = new List <string> {
"ParentGroup"
};
inventoryItemGroupQuery = QueryHelper.AddSortToQuery(inventoryItemGroupQuery,
itemGroupRequestModel.Sort, itemGroupRequestModel.IsSortDsc, excludeSort);
// filter by name
if (!string.IsNullOrEmpty(itemGroupRequestModel.NameFilter))
{
inventoryItemGroupQuery = inventoryItemGroupQuery
.Where(x => x.Name.Contains(itemGroupRequestModel.NameFilter));
}
inventoryItemGroupQuery = inventoryItemGroupQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
// calculate total before pagination
var total = await inventoryItemGroupQuery.Select(x => x.Id).CountAsync();
var inventoryItemGroupQueryMapped = AddSelectToItemGroupQuery(inventoryItemGroupQuery);
if (itemGroupRequestModel.Sort == "ParentGroup")
{
if (itemGroupRequestModel.IsSortDsc)
{
inventoryItemGroupQueryMapped = inventoryItemGroupQueryMapped
.OrderByDescending(x => x.Parent.Name);
}
else
{
inventoryItemGroupQueryMapped = inventoryItemGroupQueryMapped
.OrderBy(x => x.Parent.Name);
}
}
// pagination
inventoryItemGroupQueryMapped
= inventoryItemGroupQueryMapped
.Skip(itemGroupRequestModel.Offset)
.Take(itemGroupRequestModel.PageSize);
// add select and take objects from db
var inventoryItemGroupsFromDb = await inventoryItemGroupQueryMapped.ToListAsync();
var returnValue = new Paged <ItemGroupModel>
{
Entities = inventoryItemGroupsFromDb,
Total = total,
};
return(new OperationDataResult <Paged <ItemGroupModel> >(true, returnValue));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <Paged <ItemGroupModel> >(false,
_inventoryLocalizationService.GetString("ErrorObtainingItemGroups")));
}
}
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 <OperationDataResult <Paged <ItemModel> > > GetItems(ItemRequestModel itemRequest)
{
try
{
var inventoryItemQuery = _dbContext.Items
.AsQueryable();
inventoryItemQuery = inventoryItemQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
// filter by name
if (!string.IsNullOrEmpty(itemRequest.SnFilter))
{
inventoryItemQuery = inventoryItemQuery
.Where(x => x.SN.Contains(itemRequest.SnFilter));
}
// filter by item group
if (itemRequest.ItemGroupId.HasValue)
{
inventoryItemQuery = inventoryItemQuery
.Where(x => x.ItemType.ItemGroupId == itemRequest.ItemGroupId);
}
// calculate total before pagination
var total = await inventoryItemQuery.Select(x => x.Id).CountAsync();
// pagination
inventoryItemQuery
= inventoryItemQuery
.Skip(itemRequest.Offset)
.Take(itemRequest.PageSize);
// add select
var inventoryItemQueryWithSelect = AddSelectToItemQuery(inventoryItemQuery);
// sort
if (!string.IsNullOrEmpty(itemRequest.Sort))
{
if (itemRequest.IsSortDsc)
{
if (itemRequest.Sort == "ItemType")
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.OrderByDescending(x => x.ItemType.Name);
}
else if (itemRequest.Sort == "ItemGroup")
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.OrderByDescending(x => x.ItemGroup.Name);
}
else
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.CustomOrderByDescending(itemRequest.Sort);
}
}
else
{
if (itemRequest.Sort == "ItemType")
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.OrderBy(x => x.ItemType.Name);
}
else if (itemRequest.Sort == "ItemGroup")
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.OrderBy(x => x.ItemGroup.Name);
}
else
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.CustomOrderBy(itemRequest.Sort);
}
}
}
else
{
inventoryItemQueryWithSelect = inventoryItemQueryWithSelect
.OrderBy(x => x.Id);
}
// take objects from db
var inventoryItemsFromDb = await inventoryItemQueryWithSelect.ToListAsync();
var returnValue = new Paged <ItemModel>
{
Entities = inventoryItemsFromDb,
Total = total,
};
return(new OperationDataResult <Paged <ItemModel> >(true, returnValue));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <Paged <ItemModel> >(false,
_inventoryLocalizationService.GetString("ErrorObtainingItems")));
}
}