public async Task <OperationDataResult <ItemsListsModel> > Index(ItemsListRequestModel pnRequestModel)
{
try
{
var listsModel = new ItemsListsModel();
var itemListsQuery = _dbContext.ItemLists
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
itemListsQuery =
QueryHelper.AddSortToQuery(itemListsQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc);
if (!string.IsNullOrEmpty(pnRequestModel.NameFilter))
{
itemListsQuery = itemListsQuery.Where(x => x.Name.Contains(pnRequestModel.NameFilter));
}
listsModel.Total = await itemListsQuery.Select(x => x.Id).CountAsync();
itemListsQuery
= itemListsQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
listsModel.Lists = await itemListsQuery
.Select(x => new ItemsListPnModel
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
RepeatEvery = x.RepeatEvery,
RepeatType = x.RepeatType,
RepeatUntil = x.RepeatUntil,
DayOfWeek = x.DayOfWeek,
DayOfMonth = x.DayOfMonth,
RelatedEFormId = x.RelatedEFormId,
RelatedEFormName = x.RelatedEFormName,
}).ToListAsync();
return(new OperationDataResult <ItemsListsModel>(true, listsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <ItemsListsModel>(false,
_itemsPlanningLocalizationService.GetString("ErrorObtainingLists")));
}
}
public async Task <OperationDataResult <Paged <EmailRecipientModel> > > GetEmailRecipients(
EmailRecipientsRequestModel requestModel)
{
try
{
var emailRecipientsModel = new Paged <EmailRecipientModel>();
var emailRecipientsQuery = _dbContext.EmailRecipients
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
emailRecipientsQuery = QueryHelper.AddSortToQuery(emailRecipientsQuery, requestModel.Sort, requestModel.IsSortDsc);
// Tag ids
if (requestModel.TagIds.Any())
{
emailRecipientsQuery = emailRecipientsQuery
.Where(x => x.TagRecipients
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Any(y => requestModel.TagIds.Contains(y.EmailTagId)));
}
emailRecipientsModel.Total = await emailRecipientsQuery.Select(x => x.Id).CountAsync();
emailRecipientsQuery = emailRecipientsQuery
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
var emailRecipientList = await AddSelectToEmailRecipientsQuery(emailRecipientsQuery)
.ToListAsync();
emailRecipientsModel.Entities = emailRecipientList;
return(new OperationDataResult <Paged <EmailRecipientModel> >(
true,
emailRecipientsModel));
}
catch (Exception e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
return(new OperationDataResult <Paged <EmailRecipientModel> >(false,
_localizationService.GetString("ErrorWhileObtainingEmailRecipients")));
}
}
public async Task <OperationDataResult <InnerResourcesModel> > Index(InnerResourceRequestModel requestModel)
{
try
{
var innerResourcesModel = new InnerResourcesModel();
var query = _dbContext.InnerResources
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsNoTracking()
.AsQueryable();
query = QueryHelper.AddSortToQuery(query, requestModel.Sort, requestModel.IsSortDsc);
innerResourcesModel.Total = await query.Select(x => x.Id).CountAsync();
query = query
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
innerResourcesModel.InnerResourceList = await query
.Select(x => new InnerResourceModel
{
Name = x.Name,
Id = x.Id,
ExternalId = x.ExternalId,
RelatedOuterResourcesIds = _dbContext.OuterInnerResources.Where(y =>
y.InnerResourceId == x.Id && y.WorkflowState != Constants.WorkflowStates.Removed).Select(z => z.OuterResourceId).ToList()
}).ToListAsync();
innerResourcesModel.Name = _dbContext.PluginConfigurationValues
.FirstOrDefault(x => x.Name == "OuterInnerResourceSettings:InnerResourceName")
?.Value;
return(new OperationDataResult <InnerResourcesModel>(true, innerResourcesModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <InnerResourcesModel>(false,
_localizationService.GetString("ErrorObtainInnerResources")));
}
}
public async Task <OperationDataResult <InstallationsModel> > Index(InstallationRequestModel pnRequestModel)
{
try
{
var installationsModel = new InstallationsModel();
var installationsQuery = _dbContext.Installations
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
if (!pnRequestModel.NameFilter.IsNullOrEmpty() && pnRequestModel.NameFilter != "")
{
installationsQuery = installationsQuery.Where(x => x.Name.Contains(pnRequestModel.NameFilter));
}
QueryHelper.AddSortToQuery(installationsQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc);
installationsModel.Total = installationsQuery.Count();
installationsQuery
= installationsQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
var installations = await installationsQuery.Select(x => new InstallationModel
{
Id = x.Id,
Name = x.Name
}).ToListAsync();
installationsModel.InstallationList = installations;
return(new OperationDataResult <InstallationsModel>(true, installationsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_coreHelper.LogException(e.Message);
return(new OperationDataResult <InstallationsModel>(false,
_trashInspectionLocalizationService.GetString("ErrorObtainingInstallations")));
}
}
public async Task <OperationDataResult <Paged <EntityGroup> > > Index(
AdvEntitySelectableGroupListRequestModel requestModel)
{
try
{
var core = await _coreHelper.GetCore();
var sdkDbContext = core.DbContextHelper.GetDbContext();
var entityGroupList = new Paged <EntityGroup>();
// get query
var entitySelectableGroupQuery = sdkDbContext.EntityGroups
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.Type == Constants.FieldTypes.EntitySelect)
.AsNoTracking()
.AsQueryable();
if (!string.IsNullOrEmpty(requestModel.NameFilter))
{
entitySelectableGroupQuery = entitySelectableGroupQuery
.Where(x => x.Name.Contains(requestModel.NameFilter));
}
// sort
entitySelectableGroupQuery = QueryHelper.AddSortToQuery(entitySelectableGroupQuery, requestModel.Sort, requestModel.IsSortDsc);
// count elements
entityGroupList.Total = await entitySelectableGroupQuery.Select(x => x.Id).CountAsync();
// pagination
entitySelectableGroupQuery =
entitySelectableGroupQuery
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
// select and take from db
var entityGroups = await entitySelectableGroupQuery
.Select(x => new EntityGroup
{
Description = x.Description,
WorkflowState = x.WorkflowState,
CreatedAt = x.CreatedAt,
Id = x.Id,
MicrotingUUID = x.MicrotingUid,
Name = x.Name,
Type = x.Type,
UpdatedAt = x.UpdatedAt,
EntityGroupItemLst = new List <EntityItem>(),
}).ToListAsync();
entityGroupList.Entities = entityGroups;
var plugins = await _dbContext.EformPlugins.Select(x => x.PluginId).ToListAsync();
foreach (var entityGroup in entityGroupList.Entities)
{
foreach (var _ in plugins.Where(plugin => entityGroup.Name.Contains(plugin)))
{
entityGroup.IsLocked = true;
}
}
return(new OperationDataResult <Paged <EntityGroup> >(true, entityGroupList));
}
catch (Exception)
{
return(new OperationDataResult <Paged <EntityGroup> >(false,
_localizationService.GetString("SelectableGroupLoadingFailed")));
}
}
public async Task <OperationDataResult <ItemsListCasePnModel> > GetSingleList(ItemListCasesPnRequestModel requestModel)
{
try
{
var newItems = (_dbContext.Items.Where(item => item.ItemListId == requestModel.ListId)
.Join(_dbContext.ItemCases, item => item.Id, itemCase => itemCase.ItemId,
(item, itemCase) => new
{
itemCase.Id,
item.Name,
item.Description,
item.Type,
item.BuildYear,
item.ItemNumber,
itemCase.Comment,
itemCase.Location,
itemCase.FieldStatus,
itemCase.NumberOfImages,
itemCase.WorkflowState,
itemCase.CreatedAt,
itemCase.MicrotingSdkCaseId,
itemCase.MicrotingSdkeFormId,
itemCase.Status
}));
newItems
= newItems
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
newItems = QueryHelper.AddSortToQuery(newItems, requestModel.Sort, requestModel.IsSortDsc);
var total = await newItems.Select(x => x.BuildYear).CountAsync();
newItems
= newItems
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
if (newItems.Any())
{
var itemsListCasePnModel = new ItemsListCasePnModel
{
Items = await newItems.Select(x => new ItemsListPnItemCaseModel()
{
Id = x.Id,
Date = x.CreatedAt,
CreatedAt = x.CreatedAt,
Name = x.Name,
ItemNumber = x.ItemNumber,
BuildYear = x.BuildYear,
Description = x.Description,
Type = x.Type,
Comment = x.Comment,
Location = x.Location,
FieldStatus = x.FieldStatus,
NumberOfImages = x.NumberOfImages,
SdkCaseId = x.MicrotingSdkCaseId,
SdkeFormId = x.MicrotingSdkeFormId,
Status = x.Status
}).ToListAsync(),
Total = total,
};
return(new OperationDataResult <ItemsListCasePnModel>(
true,
itemsListCasePnModel));
}
else
{
return(new OperationDataResult <ItemsListCasePnModel>(
false, ""));
}
}
catch (Exception ex)
{
return(new OperationDataResult <ItemsListCasePnModel>(
false, ex.Message));
}
}
private async Task <ItemListPnCaseResultListModel> GetTableData(ItemListCasesPnRequestModel requestModel)
{
var pluginConfigurationValue = _options.Value.Token;
var itemList = await _dbContext.ItemLists
.SingleOrDefaultAsync(x => x.Id == requestModel.ListId);
var core = await _core.GetCore();
await using var microtingDbContext = core.DbContextHelper.GetDbContext();
var locale = await _userService.GetCurrentUserLocale();
var language = microtingDbContext.Languages.Single(x => x.LanguageCode.ToLower() == locale.ToLower());
var allFields = await core.Advanced_TemplateFieldReadAll(itemList.RelatedEFormId, language);
// filter fields
allFields = allFields.Where(x => x.FieldType != Constants.FieldTypes.SaveButton).ToList();
var itemListPnCaseResultListModel = new ItemListPnCaseResultListModel
{
LabelEnabled = itemList.LabelEnabled,
DescriptionEnabled = itemList.DescriptionEnabled,
DeployedAtEnabled = itemList.DeployedAtEnabled,
DoneAtEnabled = itemList.DoneAtEnabled,
DoneByUserNameEnabled = itemList.DoneByUserNameEnabled,
UploadedDataEnabled = itemList.UploadedDataEnabled,
ItemNumberEnabled = itemList.ItemNumberEnabled,
LocationCodeEnabled = itemList.LocationCodeEnabled,
BuildYearEnabled = itemList.BuildYearEnabled,
TypeEnabled = itemList.TypeEnabled,
NumberOfImagesEnabled = itemList.NumberOfImagesEnabled,
SdkeFormId = itemList.RelatedEFormId,
FieldEnabled1 = itemList.SdkFieldEnabled1,
FieldEnabled2 = itemList.SdkFieldEnabled2,
FieldEnabled3 = itemList.SdkFieldEnabled3,
FieldEnabled4 = itemList.SdkFieldEnabled4,
FieldEnabled5 = itemList.SdkFieldEnabled5,
FieldEnabled6 = itemList.SdkFieldEnabled6,
FieldEnabled7 = itemList.SdkFieldEnabled7,
FieldEnabled8 = itemList.SdkFieldEnabled8,
FieldEnabled9 = itemList.SdkFieldEnabled9,
FieldEnabled10 = itemList.SdkFieldEnabled10,
FieldName1 = itemList.SdkFieldEnabled1 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId1)?.Label : "",
FieldName2 = itemList.SdkFieldEnabled2 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId2)?.Label : "",
FieldName3 = itemList.SdkFieldEnabled3 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId3)?.Label : "",
FieldName4 = itemList.SdkFieldEnabled4 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId4)?.Label : "",
FieldName5 = itemList.SdkFieldEnabled5 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId5)?.Label : "",
FieldName6 = itemList.SdkFieldEnabled6 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId6)?.Label : "",
FieldName7 = itemList.SdkFieldEnabled7 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId7)?.Label : "",
FieldName8 = itemList.SdkFieldEnabled8 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId8)?.Label : "",
FieldName9 = itemList.SdkFieldEnabled9 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId9)?.Label : "",
FieldName10 = itemList.SdkFieldEnabled10 ? allFields.SingleOrDefault(x => x.Id == itemList.SdkFieldId10)?.Label : "",
};
var newItems = _dbContext.Items
.Where(item => item.ItemListId == requestModel.ListId)
.Join(_dbContext.ItemCases, item => item.Id, itemCase => itemCase.ItemId,
(item, itemCase) => new
{
itemCase.Id,
item.Name,
item.Description,
item.BuildYear,
item.LocationCode,
item.ItemNumber,
item.Type,
itemCase.MicrotingSdkCaseDoneAt,
itemCase.MicrotingSdkCaseId,
itemCase.Status,
itemCase.CreatedAt,
itemCase.DoneByUserName,
itemCase.SdkFieldValue1,
itemCase.SdkFieldValue2,
itemCase.SdkFieldValue3,
itemCase.SdkFieldValue4,
itemCase.SdkFieldValue5,
itemCase.SdkFieldValue6,
itemCase.SdkFieldValue7,
itemCase.SdkFieldValue8,
itemCase.SdkFieldValue9,
itemCase.SdkFieldValue10,
itemCase.WorkflowState,
itemCase.NumberOfImages
});
if (requestModel.DateFrom != null)
{
newItems = newItems.Where(x =>
x.CreatedAt >= new DateTime(requestModel.DateFrom.Value.Year, requestModel.DateFrom.Value.Month, requestModel.DateFrom.Value.Day, 0, 0, 0));
}
if (requestModel.DateTo != null)
{
newItems = newItems.Where(x =>
x.CreatedAt <= new DateTime(requestModel.DateTo.Value.Year, requestModel.DateTo.Value.Month, requestModel.DateTo.Value.Day, 23, 59, 59));
}
// Add sort
newItems = QueryHelper.AddSortToQuery(newItems, requestModel.Sort, requestModel.IsSortDsc);
newItems = newItems
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
// Get total
itemListPnCaseResultListModel.Total = await newItems.Select(x => x.Id).CountAsync();
// Pagination
newItems
= newItems
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
// add select and get from db
itemListPnCaseResultListModel.Items = newItems
.Select(x => new ItemsListPnCaseResultModel
{
Id = x.Id,
DoneAt = x.MicrotingSdkCaseDoneAt,
DeployedAt = x.CreatedAt,
DoneByUserName = x.DoneByUserName,
Label = x.Name,
Description = x.Description,
ItemNumber = x.ItemNumber,
LocationCode = x.LocationCode,
BuildYear = x.BuildYear,
Type = x.Type,
NumberOfImages = x.NumberOfImages,
Field1 = x.SdkFieldValue1,
Field2 = x.SdkFieldValue2,
Field3 = x.SdkFieldValue3,
Field4 = x.SdkFieldValue4,
Field5 = x.SdkFieldValue5,
Field6 = x.SdkFieldValue6,
Field7 = x.SdkFieldValue7,
Field8 = x.SdkFieldValue8,
Field9 = x.SdkFieldValue9,
Field10 = x.SdkFieldValue10,
SdkCaseId = x.MicrotingSdkCaseId,
SdkeFormId = itemList.RelatedEFormId,
Status = x.Status,
Token = pluginConfigurationValue,
})
.ToList();
return(itemListPnCaseResultListModel);
}
public async Task <OperationDataResult <Paged <InstallationModel> > > Index(InstallationsRequestModel requestModel)
{
try
{
var core = await _coreHelper.GetCore();
var options = _options.Value;
var listModel = new Paged <InstallationModel>();
var listQuery = _installationCheckingContext.Installations
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
if (requestModel.State != null)
{
listQuery = listQuery.Where(x => x.State == requestModel.State);
}
if (requestModel.Type != null)
{
listQuery = listQuery.Where(x => x.Type == requestModel.Type);
}
if (!string.IsNullOrWhiteSpace(requestModel.NameFilter))
{
listQuery = listQuery.Where(x => x.CompanyName.Contains(requestModel.NameFilter));
}
listQuery = QueryHelper.AddSortToQuery(listQuery, requestModel.Sort, requestModel.IsSortDsc);
listModel.Total = await listQuery.Select(x => x.Id).CountAsync();
listQuery = listQuery
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
var list = await AddSelectToQuery(listQuery).ToListAsync();
foreach (var item in list.Where(x => x.InstallationEmployeeId != null))
{
item.InstallationFormId = int.Parse(options.InstallationFormId);
if (item.Type == InstallationType.Installation)
{
var site = await core.SiteRead(item.InstallationEmployeeId.GetValueOrDefault());
item.AssignedTo = site.FirstName + " " + site.LastName;
if (item.InstallationSdkCaseId != null)
{
var sdkCaseId = (int)item.InstallationSdkCaseId;
var caseLookup = await core.CaseLookupMUId(sdkCaseId);
if (caseLookup?.CheckUId != null && caseLookup.CheckUId != 0)
{
item.InstallationSdkCaseDbId = await core.CaseIdLookup(sdkCaseId, (int)caseLookup.CheckUId);
}
}
}
}
foreach (var item in list.Where(x => x.RemovalEmployeeId != null))
{
item.InstallationFormId = int.Parse(options.InstallationFormId);
if (item.Type == InstallationType.Removal)
{
var site = await core.SiteRead(item.RemovalEmployeeId.GetValueOrDefault());
item.AssignedTo = site.FirstName + " " + site.LastName;
if (item.RemovalSdkCaseId != null)
{
var sdkCaseId = (int)item.RemovalSdkCaseId;
var caseLookup = await core.CaseLookupMUId(sdkCaseId);
if (caseLookup?.CheckUId != null && caseLookup?.CheckUId != 0)
{
item.RemovalSdkCaseDbId = await core.CaseIdLookup(sdkCaseId, (int)caseLookup.CheckUId);
}
}
if (item.InstallationSdkCaseId != null)
{
var sdkCaseId = (int)item.InstallationSdkCaseId;
var caseLookup = await core.CaseLookupMUId(sdkCaseId);
if (caseLookup?.CheckUId != null && caseLookup?.CheckUId != 0)
{
item.InstallationSdkCaseDbId = await core.CaseIdLookup(sdkCaseId, (int)caseLookup.CheckUId);
}
}
}
}
listModel.Entities = list;
return(new OperationDataResult <Paged <InstallationModel> >(true, listModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <Paged <InstallationModel> >(false, _localizationService.GetString("ErrorGettingInstallationsList")));
}
}
public async Task <OperationDataResult <Paged <TrashInspectionModel> > > Index(TrashInspectionRequestModel pnRequestModel)
{
try
{
var trashInspectionSettings = _options.Value;
var trashInspectionsQuery = _dbContext.TrashInspections
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsNoTracking()
.AsQueryable();
if (!string.IsNullOrEmpty(pnRequestModel.NameFilter))
{
if (int.TryParse(pnRequestModel.NameFilter, out var i))
{
trashInspectionsQuery = trashInspectionsQuery.Where(x =>
x.Id == i);
}
else
{
if (DateTime.TryParse(pnRequestModel.NameFilter, out var dateTime))
{
trashInspectionsQuery = trashInspectionsQuery.Where(x =>
x.Date.Year == dateTime.Year &&
x.Date.Month == dateTime.Month &&
x.Date.Day == dateTime.Day);
}
else
{
trashInspectionsQuery = trashInspectionsQuery.Where(x =>
x.Comment.Contains(pnRequestModel.NameFilter) ||
x.WeighingNumber.Contains(pnRequestModel.NameFilter));
}
}
}
trashInspectionsQuery = QueryHelper.AddSortToQuery(trashInspectionsQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc);
var total = await trashInspectionsQuery.Select(x => x.Id).CountAsync();
trashInspectionsQuery = trashInspectionsQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
var timeZoneInfo = await _userService.GetCurrentUserTimeZoneInfo();
var trashInspections = await AddSelectToQuery(trashInspectionsQuery, timeZoneInfo, trashInspectionSettings.Token)
.ToListAsync();
var core = await _coreHelper.GetCore();
var eFormIds = new List <KeyValuePair <int, int> >(); // <FractionId, eFormId>
foreach (var trashInspectionModel in trashInspections)
{
var fractionEFormId = await _dbContext.Fractions
.Where(y => y.Id == trashInspectionModel.FractionId)
.Select(x => x.eFormId)
.FirstOrDefaultAsync();
if (trashInspectionModel.Status == 100)
{
var result = await _dbContext.TrashInspectionCases
.Where(x => x.TrashInspectionId == trashInspectionModel.Id)
.Where(x => x.Status == 100)
.ToListAsync();
if (result.Any())
{
trashInspectionModel.SdkCaseId = int.Parse(result.First().SdkCaseId);
trashInspectionModel.SdkCaseId =
(int)core.CaseLookupMUId(trashInspectionModel.SdkCaseId).Result.CaseId;
}
if (eFormIds.Any(x => x.Key == trashInspectionModel.FractionId))
{
trashInspectionModel.SdkeFormId = eFormIds.First(x => x.Key == trashInspectionModel.FractionId).Value;
}
else
{
try
{
var locale = await _userService.GetCurrentUserLocale();
var language = core.DbContextHelper.GetDbContext().
Languages
.Single(x => x.LanguageCode == locale);
var eForm = await core.TemplateItemRead(fractionEFormId, language);
trashInspectionModel.SdkeFormId = eForm.Id;
var kvp =
new KeyValuePair <int, int>(fractionEFormId, eForm.Id);
eFormIds.Add(kvp);
}
catch
{
// KeyValuePair<int, int> kvp = new KeyValuePair<int, int>(fraction.eFormId, "");
// eFormIds.Add(kvp);
}
}
}
}
var trashInspectionsModel = new Paged <TrashInspectionModel>
{
Total = total,
Entities = trashInspections
};
return(new OperationDataResult <Paged <TrashInspectionModel> >(true, trashInspectionsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <Paged <TrashInspectionModel> >(false,
_trashInspectionLocalizationService.GetString("ErrorObtainingTrashInspections")));
}
}
public async Task <OperationDataResult <Paged <FractionModel> > > Index(FractionRequestModel pnRequestModel)
{
try
{
var fractionsModel = new Paged <FractionModel>();
var fractionsQuery = _dbContext.Fractions
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
//if (!pnRequestModel.NameFilter.IsNullOrEmpty() && pnRequestModel.NameFilter != "")
//{
// fractionsQuery = fractionsQuery.Where(x =>
// x.Name.Contains(pnRequestModel.NameFilter) ||
// x.Description.Contains(pnRequestModel.NameFilter));
//}
fractionsQuery = QueryHelper.AddSortToQuery(fractionsQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc);
fractionsModel.Total = await fractionsQuery.Select(x => x.Id).CountAsync();
fractionsQuery
= fractionsQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
var fractions = await fractionsQuery
.Select(x => new FractionModel
{
Id = x.Id,
Name = x.Name,
eFormId = x.eFormId,
Description = x.Description,
LocationCode = x.LocationCode,
ItemNumber = x.ItemNumber
})
.ToListAsync();
fractionsModel.Entities = fractions;
var core = await _coreHelper.GetCore();
var eFormNames = new List <KeyValuePair <int, string> >();
var locale = await _userService.GetCurrentUserLocale();
var language = core.DbContextHelper.GetDbContext().Languages.Single(x => x.LanguageCode == locale);
foreach (var fractionModel in fractionsModel.Entities)
{
if (fractionModel.eFormId > 0)
{
if (eFormNames.Any(x => x.Key == fractionModel.eFormId))
{
fractionModel.SelectedTemplateName = eFormNames.First(x => x.Key == fractionModel.eFormId).Value;
}
else
{
try
{
var eFormName = core.TemplateItemRead(fractionModel.eFormId, language).Result.Label;
fractionModel.SelectedTemplateName = eFormName;
var kvp =
new KeyValuePair <int, string>(fractionModel.eFormId, eFormName);
eFormNames.Add(kvp);
}
catch
{
var kvp = new KeyValuePair <int, string>(fractionModel.eFormId, "");
eFormNames.Add(kvp);
}
}
}
}
return(new OperationDataResult <Paged <FractionModel> >(true, fractionsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_coreHelper.LogException(e.Message);
return(new OperationDataResult <Paged <FractionModel> >(false,
_trashInspectionLocalizationService.GetString("ErrorObtainingFractions")));
}
}
public async Task <OperationDataResult <Paged <StatByYearModel> > > GetFractionsStatsByYear(FractionPnYearRequestModel pnRequestModel)
{
try
{
var trashInspectionsQuery = _dbContext.TrashInspections
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.Date.Year == pnRequestModel.Year)
.AsQueryable();
var fractionsStatsByYearModel = new Paged <StatByYearModel>();
var fractionQuery = _dbContext.Fractions
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
//if (!pnRequestModel.NameFilter.IsNullOrEmpty() && pnRequestModel.NameFilter != "")
//{
// fractionQuery = fractionQuery.Where(x =>
// x.Name.Contains(pnRequestModel.NameFilter) ||
// x.Description.Contains(pnRequestModel.NameFilter));
//}
var exludeSort = new List <string>
{
"Weighings",
"ControlPercentage",
"AmountOfWeighingsControlled",
"ApprovedPercentage",
"NotApprovedPercentage",
"ConditionalApprovedPercentage"
};
fractionQuery = QueryHelper.AddSortToQuery(fractionQuery, pnRequestModel.Sort, pnRequestModel.IsSortDsc, exludeSort);
fractionsStatsByYearModel.Total = await fractionQuery.Select(x => x.Id).CountAsync();
var fractionsStatsByYear = await fractionQuery
.Select(x => new StatByYearModel
{
Id = x.Id,
Name = x.Name,
Weighings = trashInspectionsQuery.Count(t => t.FractionId == x.Id),
ControlPercentage = 0,
AmountOfWeighingsControlled = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.Status == 100),
ApprovedPercentage = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.IsApproved && t.Status == 100),
NotApprovedPercentage = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.ApprovedValue == "3" && t.Status == 100),
ConditionalApprovedPercentage = trashInspectionsQuery.Count(t => t.FractionId == x.Id && t.ApprovedValue == "2" && t.Status == 100)
})
.ToListAsync();
foreach (var statByYearModel in fractionsStatsByYear)
{
if (statByYearModel.Weighings > 0)
{
statByYearModel.ControlPercentage = Math.Round((statByYearModel.AmountOfWeighingsControlled / statByYearModel.Weighings) * 100, 1);
}
if (statByYearModel.ApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
{
statByYearModel.ApprovedPercentage =
Math.Round((statByYearModel.ApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
}
else
{
statByYearModel.ApprovedPercentage = 0;
}
if (statByYearModel.ConditionalApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
{
statByYearModel.ConditionalApprovedPercentage =
Math.Round((statByYearModel.ConditionalApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
}
else
{
statByYearModel.ConditionalApprovedPercentage = 0;
}
if (statByYearModel.NotApprovedPercentage > 0 && statByYearModel.AmountOfWeighingsControlled > 0)
{
statByYearModel.NotApprovedPercentage =
Math.Round((statByYearModel.NotApprovedPercentage / statByYearModel.AmountOfWeighingsControlled) * 100, 1);
}
else
{
statByYearModel.NotApprovedPercentage = 0;
}
}
if (!string.IsNullOrEmpty(pnRequestModel.Sort) && exludeSort.Contains(pnRequestModel.Sort))
{
fractionsStatsByYear = pnRequestModel.IsSortDsc
? fractionsStatsByYear.OrderByDescending(x => x.GetPropValue(pnRequestModel.Sort)).ToList()
: fractionsStatsByYear.OrderBy(x => x.GetPropValue(pnRequestModel.Sort)).ToList();
}
fractionsStatsByYearModel.Entities = fractionsStatsByYear;
return(new OperationDataResult <Paged <StatByYearModel> >(true, fractionsStatsByYearModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_coreHelper.LogException(e.Message);
return(new OperationDataResult <Paged <StatByYearModel> >(false,
_trashInspectionLocalizationService.GetString("ErrorObtainingFractions")));
}
}
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 <Paged <ItemTypeSimpleModel> > > GetItemTypes(
ItemTypeRequest itemTypeRequest)
{
try
{
var inventoryItemTypeQuery = _dbContext.ItemTypes
.AsQueryable();
// filter by name
if (!string.IsNullOrEmpty(itemTypeRequest.NameFilter))
{
inventoryItemTypeQuery = inventoryItemTypeQuery
.Where(x => x.Name.Contains(itemTypeRequest.NameFilter));
}
// filter by tags
if (itemTypeRequest.TagIds.Any())
{
foreach (var tagId in itemTypeRequest.TagIds)
{
inventoryItemTypeQuery = inventoryItemTypeQuery
.Where(x => x.ItemTypeTags
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Any(y => y.InventoryTagId == tagId));
}
}
inventoryItemTypeQuery = inventoryItemTypeQuery
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed);
// calculate total before pagination
var total = await inventoryItemTypeQuery.Select(x => x.Id).CountAsync();
// pagination
inventoryItemTypeQuery
= inventoryItemTypeQuery
.Skip(itemTypeRequest.Offset)
.Take(itemTypeRequest.PageSize);
// get userIds for get full name users
var fullNamesUserWithId = new List <KeyValuePair <int, string> >();
foreach (var userId in inventoryItemTypeQuery.Select(x => x.CreatedByUserId).Distinct())
{
// get full names users
fullNamesUserWithId.Add(new KeyValuePair <int, string>(userId, await _userService.GetFullNameUserByUserIdAsync(userId)));
}
// add select
var inventoryItemTypeMappedQuery = AddSelectToItemTypeQuery(inventoryItemTypeQuery);
// sort
inventoryItemTypeMappedQuery = QueryHelper.AddSortToQuery(inventoryItemTypeMappedQuery, itemTypeRequest.Sort,
itemTypeRequest.IsSortDsc);
// take objects from db
var inventoryItemTypeFromDb = await inventoryItemTypeMappedQuery.ToListAsync();
foreach (var(userId, fullNameUser) in fullNamesUserWithId)
{
foreach (var itemTypeSimpleModel in inventoryItemTypeFromDb.Where(x => x.CreatedByUserId == userId))
{
itemTypeSimpleModel.CreatedBy = fullNameUser;
}
}
var returnValue = new Paged <ItemTypeSimpleModel>
{
Entities = inventoryItemTypeFromDb,
Total = total,
};
return(new OperationDataResult <Paged <ItemTypeSimpleModel> >(true, returnValue));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <Paged <ItemTypeSimpleModel> >(false,
_inventoryLocalizationService.GetString("ErrorObtainingLists")));
}
}
public async Task <OperationDataResult <CustomersModel> > Index(
CustomersRequestModel pnRequestModel)
{
try
{
// CustomerModel customerModel = new CustomerModel();
var customersQuery = _dbContext.Customers
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
customersQuery = QueryHelper.AddSortToQuery(customersQuery, pnRequestModel.SortColumnName,
pnRequestModel.IsSortDsc);
if (!string.IsNullOrEmpty(pnRequestModel.Name))
{
customersQuery = customersQuery.Where(x =>
x.CompanyName.ToLower().Contains(pnRequestModel.Name.ToLower()) ||
x.ContactPerson.ToLower().Contains(pnRequestModel.Name.ToLower()) ||
x.CompanyAddress.ToLower().Contains(pnRequestModel.Name.ToLower()) ||
x.CompanyAddress2.ToLower().Contains(pnRequestModel.Name.ToLower()) ||
x.CityName.ToLower().Contains(pnRequestModel.Name.ToLower()) ||
x.Phone.Contains(pnRequestModel.Name) ||
x.VatNumber.Contains(pnRequestModel.Name) ||
x.EanCode.Contains(pnRequestModel.Name) ||
x.Email.ToLower().Contains(pnRequestModel.Name.ToLower()));
}
customersQuery = customersQuery
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
var customers = await customersQuery.Select(x => new CustomerModel
{
Id = x.Id,
Description = x.Description,
Email = x.Email,
ContactPerson = x.ContactPerson,
CompanyName = x.CompanyName,
Phone = x.Phone,
CityName = x.CityName,
CompanyAddress = x.CompanyAddress,
CompanyAddress2 = x.CompanyAddress2,
CountryCode = x.CountryCode,
CreatedBy = x.CreatedBy,
CreatedDate = x.CreatedDate,
CustomerNo = x.CustomerNo,
EanCode = x.EanCode,
VatNumber = x.VatNumber,
ZipCode = x.ZipCode,
CrmId = x.CrmId,
CadastralNumber = x.CadastralNumber,
PropertyNumber = x.PropertyNumber,
ApartmentNumber = x.ApartmentNumber,
CompletionYear = x.CompletionYear,
FloorsWithLivingSpace = x.FloorsWithLivingSpace,
CreatedAt = x.CreatedAt,
UpdateAt = x.UpdatedAt,
RelatedEntityId = x.RelatedEntityId,
CreatedByUserId = x.CreatedByUserId,
UpdatedByUserId = x.UpdatedByUserId,
WorkflowState = x.WorkflowState,
Version = x.Version,
CadastralType = x.CadastralType,
FullName = $"{x.CompanyName} - {x.ContactPerson} - {x.CompanyAddress} - {x.CityName} - {x.Phone}"
}).ToListAsync();
var customersPnModel = new CustomersModel
{
Total = await customersQuery.Select(x => x.Id).CountAsync(),
Customers = customers
};
return(new OperationDataResult <CustomersModel>(true, customersPnModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <CustomersModel>(false,
_customersLocalizationService.GetString("ErrorObtainingCustomersInfo") + e.Message));
}
}
public async Task <OperationDataResult <CasePostsListModel> > GetAllPosts(
CasePostsRequest requestModel)
{
try
{
var core = await _coreService.GetCore();
var language = await _userService.GetCurrentUserLanguage();
var casePostsListModel = new CasePostsListModel();
var casePostsQuery = _dbContext.CasePosts.AsQueryable();
casePostsQuery = QueryHelper.AddSortToQuery(casePostsQuery, requestModel.Sort, requestModel.IsSortDsc);
casePostsQuery = casePostsQuery
.Where(x => x.CaseId == requestModel.CaseId);
casePostsListModel.Total = await casePostsQuery.CountAsync();
casePostsQuery = casePostsQuery
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
var templateDto = await core.TemplateItemRead(requestModel.TemplateId, language);
var caseDto = await core.CaseLookupCaseId(requestModel.CaseId);
if (caseDto?.MicrotingUId == null || caseDto.CheckUId == null)
{
throw new InvalidOperationException("caseDto not found");
}
var replyElement = await core.CaseRead((int)caseDto.MicrotingUId, (int)caseDto.CheckUId, language).ConfigureAwait(false);
if (replyElement.DocxExportEnabled || replyElement.JasperExportEnabled)
{
casePostsListModel.PdfReportAvailable = true;
}
casePostsListModel.CaseId = requestModel.CaseId;
casePostsListModel.CaseDoneAt = replyElement.DoneAt;
var casePostList = await casePostsQuery
.Select(x => new CasePostModel()
{
Id = x.Id,
Subject = x.Subject,
Text = x.Text,
Date = x.PostDate,
From = _dbContext.Users
.Where(y => y.Id == x.CreatedByUserId)
.Select(y => $"{y.FirstName} {y.LastName}")
.FirstOrDefault(),
ToRecipients = x.Recipients
.Select(y => $"{y.EmailRecipient.Name} ({y.EmailRecipient.Email})")
.ToList(),
ToRecipientsTags = x.Tags
.Select(y => y.EmailTag.Name)
.ToList(),
}).ToListAsync();
await using var dbContext = core.DbContextHelper.GetDbContext();
var caseEntity = await dbContext.Cases
.AsNoTracking()
.Include(x => x.Site)
.SingleOrDefaultAsync(x => x.Id == requestModel.CaseId);
if (caseEntity == null)
{
return(new OperationDataResult <CasePostsListModel>(
false,
_localizationService.GetString("CaseNotFound")));
}
if (caseEntity.Site?.MicrotingUid != null)
{
var site = await core.SiteRead((int)caseEntity.Site.MicrotingUid);
casePostsListModel.WorkerName = site.SiteName;
}
casePostsListModel.EFormName = templateDto.Label;
if (templateDto.Field1 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field1.Label,
Value = caseEntity.FieldValue1 == "null" ? "" : caseEntity.FieldValue1
});
}
if (templateDto.Field2 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field2.Label,
Value = caseEntity.FieldValue2 == "null" ? "" : caseEntity.FieldValue2
});
}
if (templateDto.Field3 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field3.Label,
Value = caseEntity.FieldValue3 == "null" ? "" : caseEntity.FieldValue3
});
}
if (templateDto.Field4 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field4.Label,
Value = caseEntity.FieldValue4 == "null" ? "" : caseEntity.FieldValue4
});
}
if (templateDto.Field5 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field5.Label,
Value = caseEntity.FieldValue5 == "null" ? "" : caseEntity.FieldValue5
});
}
if (templateDto.Field6 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field6.Label,
Value = caseEntity.FieldValue6 == "null" ? "" : caseEntity.FieldValue6
});
}
if (templateDto.Field7 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field7.Label,
Value = caseEntity.FieldValue7 == "null" ? "" : caseEntity.FieldValue7
});
}
if (templateDto.Field8 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field8.Label,
Value = caseEntity.FieldValue8 == "null" ? "" : caseEntity.FieldValue8
});
}
if (templateDto.Field9 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field9.Label,
Value = caseEntity.FieldValue9 == "null" ? "" : caseEntity.FieldValue9
});
}
if (templateDto.Field10 != null)
{
casePostsListModel.AdditionalFields.Add(
new KeyValueStringModel
{
Key = templateDto.Field10.Label,
Value = caseEntity.FieldValue10 == "null" ? "" : caseEntity.FieldValue10
});
}
casePostsListModel.CasePostsList = casePostList;
return(new OperationDataResult <CasePostsListModel>(true, casePostsListModel));
}
catch (Exception e)
{
Console.WriteLine(e);
_logger.LogError(e.Message);
return(new OperationDataResult <CasePostsListModel>(false,
_localizationService.GetString("ErrorWhileObtainingPosts")));
}
}
public async Task <OperationDataResult <Paged <PlanningPnModel> > > Index(PlanningsRequestModel pnRequestModel)
{
try
{
var sdkCore =
await _coreService.GetCore();
await using var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
var planningsQuery = _dbContext.Plannings
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsQueryable();
if (!string.IsNullOrEmpty(pnRequestModel.NameFilter))
{
planningsQuery = planningsQuery.Where(x =>
x.NameTranslations.Any(y => y.Name.Contains(pnRequestModel.NameFilter)));
}
if (!string.IsNullOrEmpty(pnRequestModel.DescriptionFilter))
{
planningsQuery = planningsQuery.Where(x =>
x.Description.Contains(pnRequestModel.DescriptionFilter));
}
var excludeSort = new List <string> {
"TranslatedName"
};
// sort
planningsQuery = QueryHelper.AddSortToQuery(planningsQuery, pnRequestModel.Sort,
pnRequestModel.IsSortDsc, excludeSort);
// ReSharper disable once ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator
foreach (var tagId in pnRequestModel.TagIds)
{
planningsQuery = planningsQuery.Where(x => x.PlanningsTags.Any(y =>
y.PlanningTagId == tagId && y.WorkflowState != Constants.WorkflowStates.Removed));
}
// ReSharper disable once ForeachCanBeConvertedToQueryUsingAnotherGetEnumerator
foreach (var deviceUserId in pnRequestModel.DeviceUserIds)
{
planningsQuery = planningsQuery.Where(x => x.PlanningSites
.Where(y => y.WorkflowState != Constants.WorkflowStates.Removed)
.Select(y => y.SiteId)
.Contains(deviceUserId));
}
// calculate total before pagination
var total = await planningsQuery.Select(x => x.Id).CountAsync();
// add select
var localeString = await _userService.GetCurrentUserLocale();
if (string.IsNullOrEmpty(localeString))
{
return(new OperationDataResult <Paged <PlanningPnModel> >(false,
_itemsPlanningLocalizationService.GetString("LocaleDoesNotExist")));
}
var language = sdkDbContext.Languages.Single(x => x.LanguageCode == localeString);
var languageIemPlanning = _dbContext.Languages.Single(x => x.Id == language.Id);
var planningQueryWithSelect = AddSelectToPlanningQuery(planningsQuery, languageIemPlanning);
if (pnRequestModel.Sort == "TranslatedName")
{
planningQueryWithSelect = pnRequestModel.IsSortDsc
? planningQueryWithSelect.OrderByDescending(x => x.TranslatedName)
: planningQueryWithSelect.OrderBy(x => x.TranslatedName);
}
planningQueryWithSelect
= planningQueryWithSelect
.Skip(pnRequestModel.Offset)
.Take(pnRequestModel.PageSize);
var checkListIds = await planningsQuery.Select(x => x.RelatedEFormId).ToListAsync();
var checkListWorkflowState = sdkDbContext.CheckLists.Where(x => checkListIds.Contains(x.Id))
.Select(checkList => new KeyValuePair <int, string>(checkList.Id, checkList.WorkflowState))
.ToList();
// add select and take objects from db
var sql = planningQueryWithSelect.ToQueryString();
List <PlanningPnModel> plannings = await planningQueryWithSelect.ToListAsync();
// get site names
var assignedSitesFromPlanning = plannings.SelectMany(y => y.AssignedSites).ToList();
var sites = await sdkDbContext.Sites
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => assignedSitesFromPlanning.Select(y => y.SiteId).Contains(x.Id))
.Select(x => new CommonDictionaryModel
{
Id = x.Id,
Name = x.Name,
}).ToListAsync();
foreach (var planning in plannings)
{
foreach (var assignedSite in assignedSitesFromPlanning)
{
foreach (var site in sites.Where(site => site.Id == assignedSite.SiteId))
{
assignedSite.Name = site.Name;
}
}
var(_, value) = checkListWorkflowState.SingleOrDefault(x => x.Key == planning.BoundEform.RelatedEFormId);
planning.BoundEform.IsEformRemoved = value == Constants.WorkflowStates.Removed;
// This is done to update existing Plannings to using EFormSdkFolderId instead of EFormSdkFolderName
if ((planning.Folder.EFormSdkFolderId == 0 || planning.Folder.EFormSdkFolderId == null) && planning.Folder.EFormSdkFolderName != null)
{
var locateFolder = await sdkDbContext.Folders
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.Name == planning.Folder.EFormSdkFolderName)
.FirstOrDefaultAsync();
if (locateFolder != null)
{
var thePlanning = await _dbContext.Plannings.SingleAsync(x => x.Id == planning.Id);
thePlanning.SdkFolderId = locateFolder.Id;
await thePlanning.Update(_dbContext);
planning.Folder.EFormSdkFolderId = locateFolder.Id;
}
}
var folder = await sdkDbContext.Folders
.Include(x => x.Parent)
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(y => y.Id == planning.Folder.EFormSdkFolderId)
.Select(x => new
{
x.Name,
x.Parent,
x.Id,
})
.FirstOrDefaultAsync();
if (folder != null)
{
planning.Folder.EFormSdkFolderId = folder.Id;
if (folder.Parent != null)
{
planning.Folder.EFormSdkParentFolderName = folder.Parent.Name;
}
else
{
planning.Folder.EFormSdkFolderName = null;
}
}
}
var planningsModel = new Paged <PlanningPnModel>
{
Total = total,
Entities = plannings
};
return(new OperationDataResult <Paged <PlanningPnModel> >(true, planningsModel));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
return(new OperationDataResult <Paged <PlanningPnModel> >(false,
_itemsPlanningLocalizationService.GetString("ErrorObtainingLists")));
}
}
