public async Task <OperationDataResult <List <CommonDictionaryModel> > > GetSurveys()
{
try
{
var core = await _coreHelper.GetCore();
using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var surveys = await sdkContext.QuestionSets
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Select(x => new CommonDictionaryModel()
{
Id = x.Id,
Name = x.Name,
}).ToListAsync();
return(new OperationDataResult <List <CommonDictionaryModel> >(true, surveys));
}
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <List <CommonDictionaryModel> >(false,
_localizationService.GetString("ErrorWhileObtainingSurveys")));
}
}
public async Task <OperationDataResult <InsightDashboardBaseSettings> > GetSettings()
{
try
{
var option = _options.Value;
if (option?.SdkConnectionString == "...")
{
var connectionString = _dbContext.Database.GetDbConnection().ConnectionString;
var dbNameSection = Regex.Match(connectionString, @"(Database=(...)_eform-angular-\w*-plugin;)").Groups[0].Value;
var dbPrefix = Regex.Match(connectionString, @"Database=(\d*)_").Groups[1].Value;
var sdk = $"Database={dbPrefix}_SDK;";
connectionString = connectionString.Replace(dbNameSection, sdk);
await _options.UpdateDb(settings => { settings.SdkConnectionString = connectionString; }, _dbContext, UserId);
}
return(new OperationDataResult <InsightDashboardBaseSettings>(true, option));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <InsightDashboardBaseSettings>(false,
_localizationService.GetString("ErrorWhileObtainingDashboardSettings")));
}
}
public async Task <OperationDataResult <AnswerViewModel> > GetAnswerByMicrotingUid(int microtingUid)
{
try
{
var core = await _coreHelper.GetCore();
AnswerViewModel result;
await using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var answersQueryable = AnswerHelper.GetAnswerQueryByMicrotingUid(microtingUid, sdkContext);
result = answersQueryable.FirstOrDefault();
}
if (result == null)
{
return(new OperationDataResult <AnswerViewModel>(
false,
_localizationService.GetString("AnswerNotFound")));
}
if (result.AnswerValues == null)
{
return(new OperationDataResult <AnswerViewModel>(
false,
_localizationService.GetString("AnswerValuesNotFound")));
}
return(new OperationDataResult <AnswerViewModel>(true, result));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <AnswerViewModel>(false,
_localizationService.GetString("ErrorWhileObtainingGetAnswer")));
}
}
public async Task <OperationDataResult <FileStreamModel> > GenerateFile(
DashboardItemExportRequestModel requestModel)
{
string excelFile = null;
try
{
var reportDataResult = await _dashboardService
.GetSingleForView(
requestModel.DashboardId,
true,
requestModel.ItemId);
if (!reportDataResult.Success)
{
return(new OperationDataResult <FileStreamModel>(false, reportDataResult.Message));
}
var dashboardItemView = reportDataResult.Model.Items.FirstOrDefault();
if (dashboardItemView == null)
{
return(new OperationDataResult <FileStreamModel>(
false,
_localizationService.GetString("DashboardItemNotFound")));
}
var interviews = new List <InterviewsExportModel>();
foreach (var textQuestionData in dashboardItemView.TextQuestionData)
{
var interviewsExportModel = new InterviewsExportModel
{
Id = textQuestionData.Id,
Comments = textQuestionData.Commentary,
Tag = textQuestionData.LocationName,
Date = textQuestionData.Date,
Question = dashboardItemView.FirstQuestionName,
FilterQuestion = dashboardItemView.FilterQuestionName,
FilterAnswer = dashboardItemView.FilterAnswerName,
};
interviews.Add(interviewsExportModel);
}
excelFile = _interviewsExcelService.CopyTemplateForNewAccount("interviews-template");
bool writeResult = _interviewsExcelService.WriteInterviewsExportToExcelFile(
interviews,
excelFile);
if (!writeResult)
{
throw new Exception($"Error while writing excel file {excelFile}");
}
var result = new FileStreamModel()
{
FilePath = excelFile,
FileStream = new FileStream(excelFile, FileMode.Open),
};
return(new OperationDataResult <FileStreamModel>(true, result));
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(excelFile) && File.Exists(excelFile))
{
File.Delete(excelFile);
}
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <FileStreamModel>(
false,
_localizationService.GetString("ErrorWhileExportingInterviews")));
}
}
public async Task <OperationDataResult <Stream> > GenerateWordDashboard(int dashboardId, List <IFormFile> files)
{
try
{
var reportDataResult = await _dashboardService
.GetSingleForView(
dashboardId,
false);
if (!reportDataResult.Success)
{
return(new OperationDataResult <Stream>(false, reportDataResult.Message));
}
var dashboardView = reportDataResult.Model;
// Read html and template
var resourceString = "InsightDashboard.Pn.Resources.Templates.WordExport.page.html";
var assembly = Assembly.GetExecutingAssembly();
var resourceStream = assembly.GetManifestResourceStream(resourceString);
string html;
using (var reader = new StreamReader(resourceStream ?? throw new InvalidOperationException($"{nameof(resourceStream)} is null")))
{
html = reader.ReadToEnd();
}
resourceString = "InsightDashboard.Pn.Resources.Templates.WordExport.file.docx";
var docxFileResourceStream = assembly.GetManifestResourceStream(resourceString);
if (docxFileResourceStream == null)
{
throw new InvalidOperationException($"{nameof(docxFileResourceStream)} is null");
}
var docxFileStream = new MemoryStream();
await docxFileResourceStream.CopyToAsync(docxFileStream);
var word = new WordProcessor(docxFileStream);
// Add dashboard page
html = html.Replace("{%DashboardName%}", dashboardView.DashboardName);
html = html.Replace("{%DashboardNameString%}", _localizationService.GetString("Dashboard"));
html = html.Replace("{%SurveyName%}", dashboardView.SurveyName);
html = html.Replace("{%SurveyNameString%}", _localizationService.GetString("Survey"));
html = html.Replace("{%LocationTag%}", dashboardView.LocationName ?? dashboardView.TagName);
html = html.Replace("{%LocationTagString%}", _localizationService.GetString("LocationTag"));
// Period
if (dashboardView.AnswerDates.DateFrom != null)
{
var periodFromTemplate = $@"<p><b>{_localizationService.GetString("PeriodFrom")}:</b> {dashboardView.AnswerDates.DateFrom:dd-MM-yyyy}</p>";
html = html.Replace("{%PeriodFrom%}", periodFromTemplate);
}
else
{
html = html.Replace("{%PeriodFrom%}", string.Empty);
}
if (dashboardView.AnswerDates.Today)
{
var periodToTemplate = $@"<p><b>{_localizationService.GetString("PeriodTo")}:</b> {DateTime.Now:dd-MM-yyyy}</p>";
html = html.Replace("{%PeriodTo%}", periodToTemplate);
}
else if (dashboardView.AnswerDates.DateFrom != null)
{
var periodToTemplate = $@"<p><b>{_localizationService.GetString("PeriodTo")}:</b> {dashboardView.AnswerDates.DateTo:dd-MM-yyyy}</p>";
html = html.Replace("{%PeriodTo%}", periodToTemplate);
}
else
{
html = html.Replace("{%PeriodTo%}", string.Empty);
}
var itemsHtml = "";
foreach (var dashboardItem in dashboardView.Items)
{
var isText = dashboardItem.FirstQuestionType == "text";
itemsHtml += @"<div style=""page-break-before:always"">";
itemsHtml += $@"<p><b>{_localizationService.GetString("Question")}:</b> {dashboardItem.FirstQuestionName}</p>";
if (!string.IsNullOrEmpty(dashboardItem.FilterQuestionName))
{
itemsHtml += $@"<p><b>{_localizationService.GetString("FilterQuestion")}:</b> {dashboardItem.FilterQuestionName}</p>";
}
if (!string.IsNullOrEmpty(dashboardItem.FilterAnswerName))
{
itemsHtml += $@"<p><b>{_localizationService.GetString("FilterAnswer")}</b> {dashboardItem.FilterAnswerName}</p>";
}
if (isText)
{
itemsHtml += @"<br/>";
itemsHtml += @"<table width=""100%"" border=""1"">";
// Table header
itemsHtml += @"<tr style=""background-color:#f5f5f5;font-weight:bold"">";
itemsHtml += $@"<td>{_localizationService.GetString("Date")}</td>";
itemsHtml += $@"<td>{_localizationService.GetString("Tag")}</td>";
itemsHtml += $@"<td>{_localizationService.GetString("Comments")}</td>";
itemsHtml += @"</tr>";
foreach (var dataModel in dashboardItem.TextQuestionData)
{
itemsHtml += @"<tr>";
itemsHtml += $@"<td>{dataModel.Date:dd-MM-yyyy}</td>";
itemsHtml += $@"<td>{dataModel.LocationName}</td>";
itemsHtml += $@"<td>{dataModel.Commentary}</td>";
itemsHtml += @"</tr>";
}
itemsHtml += @"</table>";
}
else
{
if (dashboardItem.IgnoredAnswerValues.Any())
{
var ignoredAnswerValuesString = string.Join(
", ",
dashboardItem.IgnoredAnswerValues
.Select(x => x.Name)
.ToArray());
itemsHtml += $@"<p><b>{_localizationService.GetString("IgnoredValues")}:</b> {ignoredAnswerValuesString}</p>";
}
itemsHtml += $@"<p><img src=""data:image/png;base64,pngBase64String_{dashboardItem.Id}"" width=""650px"" alt=""Image"" /></p>";
var imageFile = files.FirstOrDefault(x => x.FileName == dashboardItem.Id.ToString());
if (imageFile == null)
{
throw new InvalidOperationException($"{nameof(imageFile)} is null");
}
using (var image = Image.FromStream(imageFile.OpenReadStream()))
{
using (var memoryStream = new MemoryStream())
{
image.Save(memoryStream, image.RawFormat);
var imageBytes = memoryStream.ToArray();
// Convert byte[] to Base64 String
var base64String = Convert.ToBase64String(imageBytes);
itemsHtml = itemsHtml.Replace($"pngBase64String_{dashboardItem.Id}", base64String);
}
}
// Tables
foreach (var rawDataItem in dashboardItem.ChartData.RawData)
{
itemsHtml += @"<table style=""background-color:#fff"" width=""100%"" border=""1"">";
// multiStacked data chart with inverted values
if (dashboardItem.ChartType == DashboardChartTypes.GroupedStackedBarChart)
{
// Table header
itemsHtml += @"<tr style=""font-weight:bold"">";
itemsHtml += @"<th></th>";
itemsHtml += @"<th></th>";
foreach (var rawHeader in rawDataItem.RawHeaders)
{
itemsHtml += $@"<th>{rawHeader}</th>";
}
itemsHtml += @"</tr>";
var totalItemNumber = 0;
// Table elements
foreach (var dataModel in rawDataItem.RawDataItems)
{
// Table percents and average
for (var i = 0; i < dataModel.RawDataValues.Count; i++)
{
var dataValue = dataModel.RawDataValues[i];
// add row counter
totalItemNumber++;
var isEven = totalItemNumber % 2 == 0;
// open
itemsHtml += @"<tr>";
// add first table text (year/location)
if (i == 0)
{
var rowCount = dataModel.RawDataValues.Count;
itemsHtml +=
$@"<td rowspan=""{rowCount}"" style=""background-color:#fff"">{dataModel.RawValueName}</td>";
}
// location or year name
itemsHtml +=
$@"<td {AddStyles(false, isEven)}>{dataValue.ValueName}</td>";
// for percents
for (var percentIndex = 0;
percentIndex < dataValue.Percents.Length;
percentIndex++)
{
var valuePercent = dataValue.Percents[percentIndex];
if (percentIndex == dataValue.Percents.Length - 1)
{
itemsHtml += $@"<td {AddStyles(true, isEven)}>{valuePercent}%</td>";
}
else
{
itemsHtml += $@"<td {AddStyles(false, isEven)}>{valuePercent}%</td>";
}
}
// for amounts
for (var amountIndex = 0; amountIndex < dataValue.Amounts.Length; amountIndex++)
{
var amountPercent = dataValue.Amounts[amountIndex];
if (amountIndex == dataValue.Amounts.Length - 1)
{
itemsHtml += $@"<td {AddStyles(true, isEven)}>{amountPercent}</td>";
}
else
{
itemsHtml += $@"<td {AddStyles(false, isEven)}>{amountPercent}</td>";
}
}
// close
itemsHtml += @"</tr>";
}
}
}
else
{
// Other tables for single and multi data
for (int y = 0; y < rawDataItem.RawDataItems.Count; y++)
{
var dataModel = rawDataItem.RawDataItems[y];
// Table header
itemsHtml += @"<tr style=""font-weight:bold"">";
itemsHtml += $@"<td>{dataModel.RawValueName}</td>";
foreach (var rawHeader in rawDataItem.RawHeaders)
{
itemsHtml += $@"<td>{rawHeader}</td>";
}
itemsHtml += @"</tr>";
// Table percents and average
for (var i = 0; i < dataModel.RawDataValues.Count; i++)
{
var dataValue = dataModel.RawDataValues[i];
if (i == dataModel.RawDataValues.Count - 1)
{
itemsHtml += @"<tr style=""font-weight:bold"">";
}
else
{
itemsHtml += @"<tr>";
}
itemsHtml += $@"<td>{dataValue.ValueName}</td>";
foreach (var valuePercent in dataValue.Percents)
{
if (dashboardItem.CalculateAverage)
{
itemsHtml += $@"<td>{valuePercent}</td>";
}
else
{
itemsHtml += $@"<td>{valuePercent}%</td>";
}
}
itemsHtml += @"</tr>";
}
itemsHtml += @"<tr><td></td></tr>";
// Table amounts
for (var i = 0; i < dataModel.RawDataValues.Count; i++)
{
var dataValue = dataModel.RawDataValues[i];
if (i == dataModel.RawDataValues.Count - 1)
{
itemsHtml += @"<tr style=""font-weight:bold"">";
}
else
{
itemsHtml += @"<tr>";
}
itemsHtml += $@"<td>{dataValue.ValueName}</td>";
foreach (var valueAmount in dataValue.Amounts)
{
itemsHtml += $@"<td>{valueAmount}</td>";
}
itemsHtml += @"</tr>";
}
// Empty table row
if (y < dashboardItem.ChartData.RawData.Count - 1)
{
itemsHtml += @"<tr style=""font-weight:bold; background-color:#fff"">";
foreach (var unused in rawDataItem.RawHeaders)
{
itemsHtml += $@"<td></td>";
}
itemsHtml += @"</tr>";
}
}
}
itemsHtml += @"</table>";
}
}
itemsHtml += @"<div/>";
}
html = html.Replace("{%ItemList%}", itemsHtml);
word.AddHtml(html);
word.Dispose();
docxFileStream.Position = 0;
return(new OperationDataResult <Stream>(true, docxFileStream));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <Stream>(
false,
_localizationService.GetString("ErrorWhileCreatingWordFile")));
}
}
public static List <DashboardViewChartRawDataModel> ConvertSingleData(
IInsightDashboardLocalizationService localizationService,
List <DashboardViewChartDataSingleModel> singleData,
bool isMulti,
int answersCount)
{
const int columnsCount = 1;
var result = new List <DashboardViewChartRawDataModel>();
var data = new DashboardViewChartRawDataModel();
var chartRawDataModel = new DashboardViewChartRawDataItemModel
{
RawValueName = string.Empty, // Empty location
};
// Headers
data.RawHeaders.Add(
localizationService.GetString("TotalPeriod"));
// Rows
var rawDataList = new List <DashboardViewChartRawDataValuesModel>();
// Get row names
foreach (var singleModel in singleData)
{
var rawDataValuesModel = new DashboardViewChartRawDataValuesModel
{
ValueName = singleModel.Name,
Percents = new decimal[columnsCount],
Amounts = new decimal[columnsCount],
};
rawDataList.Add(rawDataValuesModel);
}
var totalRow = new DashboardViewChartRawDataValuesModel
{
ValueName = localizationService.GetString("Total"),
Percents = new decimal[columnsCount],
Amounts = new decimal[columnsCount],
};
rawDataList.Add(totalRow);
// by Item
if (isMulti)
{
var percentageList = new List <decimal>();
for (var y = 0; y < singleData.Count; y++)
{
var dataSingleModel = singleData[y];
decimal percentage = Math.Round((decimal)dataSingleModel.DataCount / (decimal)answersCount * 100m, 0, MidpointRounding.AwayFromZero);
percentageList.Add(percentage);
rawDataList[y].Percents[0] = percentage;
rawDataList[y].Amounts[0] = dataSingleModel.DataCount;
}
// calculate total
var lastRow = singleData.Count;
rawDataList[lastRow].Percents[0] = percentageList.Sum(x => x);
rawDataList[lastRow].Amounts[0] = answersCount;
}
else
{
for (var y = 0; y < singleData.Count; y++)
{
var dataSingleModel = singleData[y];
rawDataList[y].Percents[0] = (decimal)dataSingleModel.Value;
rawDataList[y].Amounts[0] = dataSingleModel.DataCount;
}
// calculate total
var lastRow = singleData.Count;
rawDataList[lastRow].Percents[0] = singleData
.Where(x => x.Value != null)
.Sum(x => (decimal)x.Value);
rawDataList[lastRow].Amounts[0] = singleData
.Sum(x => x.DataCount);
}
chartRawDataModel.RawDataValues = rawDataList;
data.RawDataItems.Add(chartRawDataModel);
result.Add(data);
return(result);
}
public static List <DashboardViewChartRawDataModel> ConvertMultiData(
IInsightDashboardLocalizationService localizationService,
List <DashboardViewChartDataMultiModel> multiData,
bool isLineData,
bool isMulti)
{
var result = new List <DashboardViewChartRawDataModel>();
var data = new DashboardViewChartRawDataModel();
if (multiData.Count == 0)
{
return(result);
}
var chartRawDataModel = new DashboardViewChartRawDataItemModel
{
RawValueName = string.Empty, // Empty location
};
// If it's data for line chart - it should be inverted
if (isLineData)
{
// Get element with max columns
var maxColumnsObject = multiData
.OrderByDescending(item => item.Series.Count)
.First();
// Headers
foreach (var dataSingleModel in maxColumnsObject.Series)
{
data.RawHeaders.Add(dataSingleModel.Name); // Year name
}
// Rows
var rawDataList = new List <DashboardViewChartRawDataValuesModel>();
// Get row names
foreach (var multiModel in multiData)
{
var rawDataValuesModel = new DashboardViewChartRawDataValuesModel
{
ValueName = multiModel.Name,
Percents = new decimal[maxColumnsObject.Series.Count],
Amounts = new decimal[maxColumnsObject.Series.Count],
};
rawDataList.Add(rawDataValuesModel);
}
// Add total row
var totalRow = new DashboardViewChartRawDataValuesModel
{
ValueName = localizationService.GetString("Total"),
Percents = new decimal[maxColumnsObject.Series.Count],
Amounts = new decimal[maxColumnsObject.Series.Count],
};
rawDataList.Add(totalRow);
// by Item
for (var i = 0; i < multiData.Count; i++)
{
var dataMultiModel = multiData[i];
// by week
for (var y = 0; y < dataMultiModel.Series.Count; y++)
{
var dataSingleModel = dataMultiModel.Series[y];
rawDataList[i].Amounts[y] = dataSingleModel.DataCount;
rawDataList[i].Percents[y] = (decimal)dataSingleModel.Value;
}
}
// calculate total
var lastRow = multiData.Count;
for (var i = 0; i < maxColumnsObject.Series.Count; i++)
{
decimal totalValue = 0;
decimal totalAmounts = 0;
foreach (var rowData in rawDataList)
{
totalValue += rowData.Percents[i];
totalAmounts += rowData.Amounts[i];
}
// find total
if (isMulti)
{
foreach (var dataMultiModel in multiData)
{
var seriesItem = dataMultiModel.Series[i];
if (seriesItem.AnswersDataCount > 0)
{
totalAmounts = seriesItem.AnswersDataCount;
break;
}
}
}
rawDataList[lastRow].Percents[i] = totalValue;
rawDataList[lastRow].Amounts[i] = totalAmounts;
}
chartRawDataModel.RawDataValues = rawDataList;
}
else
{
// Headers
foreach (var multiModel in multiData)
{
data.RawHeaders.Add(multiModel.Name); // Year name
}
// Rows
var rawDataList = new List <DashboardViewChartRawDataValuesModel>();
// Get element with max rows
var maxObject = multiData
.OrderByDescending(item => item.Series.Count)
.First();
// Get row names
foreach (var singleModel in maxObject.Series)
{
var rawDataValuesModel = new DashboardViewChartRawDataValuesModel
{
ValueName = singleModel.Name,
Percents = new decimal[multiData.Count],
Amounts = new decimal[multiData.Count],
};
rawDataList.Add(rawDataValuesModel);
}
// Add total row
var totalRow = new DashboardViewChartRawDataValuesModel
{
ValueName = localizationService.GetString("Total"),
Percents = new decimal[multiData.Count],
Amounts = new decimal[multiData.Count],
};
rawDataList.Add(totalRow);
// by week
for (var i = 0; i < multiData.Count; i++)
{
var dataMultiModel = multiData[i];
// by Item
for (var y = 0; y < maxObject.Series.Count; y++)
{
var maxObjectSingleModel = maxObject.Series[y];
// TODO: FIX
var singleModel = dataMultiModel.Series
.FirstOrDefault(x => x.Name == maxObjectSingleModel.Name);
if (singleModel == null)
{
rawDataList[y].Percents[i] = 0;
rawDataList[y].Amounts[i] = 0;
}
else
{
rawDataList[y].Percents[i] = (decimal)singleModel.Value;
rawDataList[y].Amounts[i] = singleModel.DataCount;
}
}
// calculate total
var lastRow = maxObject.Series.Count;
rawDataList[lastRow].Percents[i] = dataMultiModel.Series
.Where(x => x.Value != null)
.Sum(x => (decimal)x.Value);
if (isMulti)
{
rawDataList[lastRow].Amounts[i] = dataMultiModel.AnswersCount;
}
else
{
rawDataList[lastRow].Amounts[i] = dataMultiModel.Series
.Sum(x => x.DataCount);
}
}
chartRawDataModel.RawDataValues = rawDataList;
}
data.RawDataItems.Add(chartRawDataModel);
result.Add(data);
return(result);
}
public async Task <OperationDataResult <SurveyConfigsListModel> > Get(SurveyConfigsRequestModel requestModel)
{
try
{
var core = await _coreHelper.GetCore();
var result = new SurveyConfigsListModel();
await core.GetAllQuestionSets();
await core.GetAllSurveyConfigurations();
await core.GetAllAnswers();
//await AddTextAnswers();
await using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var surveysQueryable = sdkContext.SurveyConfigurations
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.AsNoTracking()
.AsQueryable();
if (!string.IsNullOrEmpty(requestModel.SearchString))
{
surveysQueryable = surveysQueryable
.Where(x => x.Name.Contains(
requestModel.SearchString,
StringComparison.CurrentCultureIgnoreCase));
}
if (!string.IsNullOrEmpty(requestModel.Sort))
{
if (requestModel.IsSortDsc)
{
switch (requestModel.Sort)
{
case nameof(SurveyConfigModel.SurveyName):
surveysQueryable = surveysQueryable
.OrderByDescending(x => x.QuestionSet.Name);
break;
default:
surveysQueryable = surveysQueryable
.CustomOrderByDescending(requestModel.Sort);
break;
}
}
else
{
switch (requestModel.Sort)
{
case nameof(SurveyConfigModel.SurveyName):
surveysQueryable = surveysQueryable
.OrderBy(x => x.QuestionSet.Name);
break;
default:
surveysQueryable = surveysQueryable
.CustomOrderBy(requestModel.Sort);
break;
}
}
}
else
{
surveysQueryable = surveysQueryable
.OrderBy(x => x.Id);
}
result.Total = await surveysQueryable
.Select(x => x.Id)
.CountAsync();
surveysQueryable = surveysQueryable
.Skip(requestModel.Offset)
.Take(requestModel.PageSize);
result.Entities = await surveysQueryable
.Select(x => new SurveyConfigModel()
{
Id = x.Id,
SurveyName = x.QuestionSet.Name,
SurveyId = x.QuestionSet.Id,
Locations = x.SiteSurveyConfigurations
.Where(l => l.WorkflowState != Constants.WorkflowStates.Removed)
.Where(l => l.Site.WorkflowState != Constants.WorkflowStates.Removed)
.Select(l => new CommonDictionaryModel
{
Id = l.Site.Id,
Name = l.Site.Name,
}).ToList()
}).ToListAsync();
}
return(new OperationDataResult <SurveyConfigsListModel>(true, result));
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <SurveyConfigsListModel>(false,
_localizationService.GetString("ErrorWhileObtainingSurveyConfigurations")));
}
}