public static DashboardItem GetDashboardItemFromModel(DashboardItemViewModel viewModel)
{
var rnd = new Random();
var dashboardItem = new DashboardItem
{
Id = viewModel.Id,
UpdatedByUserId = rnd.Next(1, 255),
CreatedByUserId = rnd.Next(1, 255),
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow,
WorkflowState = Constants.WorkflowStates.Created,
Position = viewModel.Position,
CompareEnabled = viewModel.CompareEnabled,
CalculateAverage = viewModel.CalculateAverage,
DashboardId = viewModel.Id,
ChartType = viewModel.ChartType,
Period = viewModel.Period,
FilterAnswerId = viewModel.FilterAnswerId,
FilterQuestionId = viewModel.FilterQuestionId,
FirstQuestionId = viewModel.FirstQuestionId,
CompareLocationsTags = viewModel.CompareLocationsTags
.Select(x => new DashboardItemCompare()
{
LocationId = x.LocationId,
Position = x.Position,
TagId = x.TagId
})
.ToList(),
IgnoredAnswerValues = viewModel.IgnoredAnswerValues
.Select(x => new DashboardItemIgnoredAnswer()
{
AnswerId = x.AnswerId,
})
.ToList(),
};
return(dashboardItem);
}
public static DashboardItemViewModel CopyDashboardItem(DashboardItemViewModel viewModel)
{
var dashboardItem = new DashboardItemViewModel
{
Position = viewModel.Position,
CompareEnabled = viewModel.CompareEnabled,
CalculateAverage = viewModel.CalculateAverage,
ChartType = viewModel.ChartType,
Period = viewModel.Period,
FilterAnswerId = viewModel.FilterAnswerId,
FilterQuestionId = viewModel.FilterQuestionId,
FirstQuestionId = viewModel.FirstQuestionId,
FilterAnswerName = viewModel.FilterAnswerName,
FilterQuestionName = viewModel.FilterQuestionName,
Id = viewModel.Id,
FirstQuestionName = viewModel.FirstQuestionName,
CompareLocationsTags = viewModel.CompareLocationsTags,
IgnoredAnswerValues = viewModel.IgnoredAnswerValues,
FirstQuestionType = viewModel.FirstQuestionType,
};
return(dashboardItem);
}
// *sigh* yes....i'm doing this in the controller. Feel free to move it somewhere else. :)
private DashboardViewModel GetDashboardModel(bool executeControllers = true)
{
var dashboardsManager = UserDashboardsManager.GetManager();
// dashboard data is stored using the user id so, we need to get the user
var currentUser = PortalsHelpers.GetCurrentUser();
// get this dashboard's data for the current user
var dashboard = currentUser.GetDashboard(DashboardId);
// instantiate a new DashboardViewModel and set the property values that we know we need
var model = new DashboardViewModel();
model.DashboardId = DashboardId;
model.DashboardItems = new List <DashboardItemViewModel>();
// loop through the dashboard items and create view models for them
foreach (var dashboardItem in dashboard.DashboardItems)
{
// get the corresponding Sitefinity ToolboxItem for the given dashboard item type
ToolboxItem toolboxItem = null;
if (PortalsHelpers.GetToolboxItem(dashboardItem.ControllerType, out toolboxItem))
{
// MvcControllerProxy is the source of all this sorcery
var proxy = new MvcControllerProxy()
{
ControllerName = toolboxItem.ControllerType
};
// get the properties that users are able to change on the front end
// this will *not* include any user defined values...just properties that *can* be configured
var configurableProperties = PortalsHelpers.GetConfigurableProperties(toolboxItem.ControllerType);
// this will be the property list (with user values set) that we pass to the view
var propertyViewModels = new List <PortalsItemPropertyViewModel>();
foreach (var property in configurableProperties)
{
string value = string.Empty;
// if the user has actually set any configurable property value, transfer the value to the controller
if (dashboardItem.Properties.Any(p => p.Name == property.Name))
{
value = dashboardItem.Properties.Single(p => p.Name == property.Name).Value;
// type the value correctly
object propValue = PortalsHelpers.GetValueFromString(value, property.PropertyType);
// fairly confident that this isn't a good way to do this but...it works
var backingProperty = configurableProperties.Where(p => p.Name == property.Name).Single().DashboardConfigurableAttribute.BackingProperty ?? property.Name;
proxy.Controller.SetProperty(backingProperty, propValue);
}
// build the view model for the front end
var propertyViewModel = new PortalsItemPropertyViewModel();
propertyViewModel.Name = property.Name;
propertyViewModel.DisplayName = configurableProperties.Where(p => p.Name == property.Name).Single().DashboardConfigurableAttribute.DisplayName ?? property.Name;
propertyViewModel.Value = value;
propertyViewModels.Add(propertyViewModel);
}
// build a new DashboardItemViewModel with all the properties we need to render, configure, and save the item
var dashboardItemModel = new DashboardItemViewModel();
dashboardItemModel.Title = toolboxItem.Title;
dashboardItemModel.ControllerType = toolboxItem.ControllerType;
dashboardItemModel.Properties = propertyViewModels;
dashboardItemModel.Html = executeControllers ? ExecuteController(proxy) : string.Empty;
model.DashboardItems.Add(dashboardItemModel);
}
}
return(model);
}
public static void CheckData(
DashboardItemViewModel originalItem,
DashboardItemViewModel processedItem,
DashboardViewModel originalViewModel,
string templateName)
{
var originalItemString = JsonConvert.SerializeObject(originalItem);
var processedItemString = JsonConvert.SerializeObject(processedItem);
// Build info
var message = $"Check data for template: \"{templateName}\"\n" +
$"Dashboard id: {originalViewModel.Id}\n" +
$"Dashboard name: {originalViewModel.DashboardName}\n" +
"Dashboard item:\n" +
$"Id: {originalItem.Id}\n" +
$"Chart type: {originalItem.ChartType}\n" +
$"Calculate average: {originalItem.CalculateAverage}\n" +
$"Compare enabled: {originalItem.CompareEnabled}\n" +
$"Period: {originalItem.Period}\n" +
$"Position: {originalItem.Position}\n" +
$"First question: ({originalItem.FirstQuestionId}, {originalItem.FirstQuestionName})" +
"\n\n" +
$"Original item: \n{originalItemString}" +
"\n\n" +
$"Processed item: \n{processedItemString}" +
"\n\n" +
"Test error: \n";
Assert.AreEqual(
originalItem.Id,
processedItem.Id,
message);
Assert.AreEqual(
originalItem.CalculateAverage,
processedItem.CalculateAverage,
message);
Assert.AreEqual(
originalItem.ChartType,
processedItem.ChartType,
message);
Assert.AreEqual(
originalItem.CompareEnabled,
processedItem.CompareEnabled,
message);
Assert.AreEqual(
originalItem.Period,
processedItem.Period,
message);
Assert.AreEqual(
originalItem.Position,
processedItem.Position,
message);
Assert.AreEqual(
originalItem.Position,
processedItem.Position,
message);
Assert.AreEqual(
originalItem.ChartData.Single.Count,
processedItem.ChartData.Single.Count,
message);
Assert.AreEqual(
originalItem.ChartData.Multi.Count,
processedItem.ChartData.Multi.Count,
message);
Assert.AreEqual(
originalItem.ChartData.MultiStacked.Count,
processedItem.ChartData.MultiStacked.Count,
message);
// Single data
for (var index = 0; index < originalItem.ChartData.Single.Count; index++)
{
var dataOriginal = originalItem.ChartData.Single[index];
var dataProcessed = processedItem.ChartData.Single[index];
Assert.AreEqual(dataOriginal.Name, dataProcessed.Name, message);
Assert.AreEqual(dataOriginal.Value, dataProcessed.Value, message);
}
// Multi data
for (var index = 0; index < originalItem.ChartData.Multi.Count; index++)
{
var dataOriginal = originalItem.ChartData.Multi[index];
var dataProcessed = processedItem.ChartData.Multi[index];
Assert.AreEqual(dataOriginal.Name, dataProcessed.Name, message);
for (var i = 0; i < dataOriginal.Series.Count; i++)
{
var originalSeries = dataOriginal.Series[i];
var originalProcessed = dataProcessed.Series[i];
Assert.AreEqual(originalSeries.Name, originalProcessed.Name, message);
Assert.AreEqual(originalSeries.Value, originalProcessed.Value, message);
}
}
// Multi stacked data
for (var index = 0; index < originalItem.ChartData.MultiStacked.Count; index++)
{
var dataOriginal = originalItem.ChartData.MultiStacked[index];
var dataProcessed = processedItem.ChartData.MultiStacked[index];
Assert.AreEqual(dataOriginal.Id, dataProcessed.Id, message);
Assert.AreEqual(dataOriginal.Name, dataProcessed.Name, message);
for (var i = 0; i < dataOriginal.Series.Count; i++)
{
var originalSeries = dataOriginal.Series[i];
var processedSeries = dataProcessed.Series[i];
Assert.AreEqual(originalSeries.Name, processedSeries.Name, message);
for (var y = 0; y < originalSeries.Series.Count; y++)
{
var originalSeriesSeries = originalSeries.Series[y];
var processedSeriesSeries = processedSeries.Series[y];
Assert.AreEqual(originalSeriesSeries.Name, processedSeriesSeries.Name, message);
Assert.AreEqual(originalSeriesSeries.Value, processedSeriesSeries.Value, message);
}
}
}
// Raw chart data
for (var x = 0; x < originalItem.ChartData.RawData.Count; x++)
{
var rawDataItemOriginal = originalItem.ChartData.RawData[x];
var rawDataItemProcessed = processedItem.ChartData.RawData[x];
// Check table header
for (var i = 0; i < rawDataItemOriginal.RawHeaders.Count; i++)
{
Assert.AreEqual(rawDataItemOriginal.RawHeaders[i], rawDataItemProcessed.RawHeaders[i], message);
}
for (var index = 0; index < rawDataItemOriginal.RawDataItems.Count; index++)
{
var dataOriginal = rawDataItemOriginal.RawDataItems[index];
var dataProcessed = rawDataItemProcessed.RawDataItems[index];
Assert.AreEqual(dataOriginal.RawValueName, dataProcessed.RawValueName, message);
Assert.AreEqual(dataOriginal.RawDataValues.Count, dataProcessed.RawDataValues.Count, message);
// Check table data
for (var i = 0; i < dataOriginal.RawDataValues.Count; i++)
{
var originalSeries = dataOriginal.RawDataValues[i];
var processedSeries = dataProcessed.RawDataValues[i];
Assert.AreEqual(originalSeries.ValueName, processedSeries.ValueName, message);
// Values
for (var y = 0; y < originalSeries.Amounts.Length; y++)
{
var originalValue = originalSeries.Percents[y];
var processedValue = processedSeries.Percents[y];
Assert.AreEqual(originalValue, processedValue, message);
}
// Amounts
for (var y = 0; y < originalSeries.Amounts.Length; y++)
{
var originalAmount = originalSeries.Amounts[y];
var processedAmount = processedSeries.Amounts[y];
Assert.AreEqual(originalAmount, processedAmount, message);
}
}
}
}
}
