public ActionResult Lifespan()
{
var data = _fileRepository.LoadFile <LifeExpectancyModel>("LifeExpectancy.csv");
var filteredData = data.OrderByDescending(x => x.GetYearsArray().Average())
.Take(5).ToList();
var chart = new ChartData <LineChartDataset>();
chart.Labels.Add("2010");
chart.Labels.Add("2011");
chart.Labels.Add("2012");
chart.Labels.Add("2013");
foreach (LifeExpectancyModel element in filteredData)
{
var dataset = new LineChartDataset();
dataset.Label = element.Country;
dataset.Data.Add(element.Year2010);
dataset.Data.Add(element.Year2011);
dataset.Data.Add(element.Year2012);
dataset.Data.Add(element.Year2013);
chart.Datasets.Add(dataset);
}
var model = new LifespanViewModel();
ChartHelpers.BreatheColors(chart);
model.ChartData = SerializationHelpers.ToJson(chart);
return(View(model));
}
private void ResetChart()
{
_drawings = new List <SelectedFigureBase>();
_zoomArea = null;
_selectedDrawing = null;
_tempDrawing = null;
_drawAdditionChartHelper = null;
_actions = DrawingActions.Default;
_chartHelpers = ChartHelpers.Default;
_isZoomed = true;
SetForChartMinMaxPoints(0);
}
private void ZoomUpChart(int x, int y)
{
if (_zoomArea == null)
{
_zoomArea = new RectangleFigure(_d2DRenderTarget);
}
var isSetted = _zoomArea.SetPosition(new ScreenPoint(x, y));
if (!isSetted)
{
return;
}
_chartHelpers = ChartHelpers.Default;
_isZoomed = false;
}
public Chart()
{
InitializeComponent();
#region Init
_resize = 0;
_isResized = true;
_isZoomed = true;
_mousePisition = new ScreenPoint();
_drawings = new List <SelectedFigureBase>();
_barType = BarType.OHLC;
_actions = DrawingActions.Default;
_chartHelpers = ChartHelpers.Default;
var windowSize = new Size(800, 800);
SetRenderSettings(windowSize);
_chart = new ChartDrawing(ClientSize.Width, ClientSize.Height, _d2DRenderTarget, TimingBy.Minute);
_chartRendering = new ChartRendering.ChartRendering(_d2DRenderTarget, _textFormat, _chart);
GenerateBars();
SetForChartMinMaxPoints(0);
_borders = new RectangleF(windowSize.Width * _chart.Paddings.PaddingLeftRatio,
windowSize.Height * _chart.Paddings.PaddingTopRatio, _chart.ChartWidth, _chart.ChartHeight);
#endregion
#region FormHandlers
KeyDown += OnKeyDown;
MouseDown += OnMouseDown;
MouseClick += OnMouseClick;
MouseWheel += OnMouseWheel;
MouseMove += OnMouseMove;
Resize += OnResizeEnd;
Closing += OnClosing;
#endregion
_callback += RenderChart;
RenderLoop.Run(this, _callback);
}
public static List <Profile> MergeProfiles([NotNull][ItemNotNull] List <Profile> profiles)
{
Dictionary <string, Profile> mergedProfiles = new Dictionary <string, Profile>();
foreach (var profile in profiles)
{
string newName = ChartHelpers.GetFriendlyProviderName(profile.Name);
if (!mergedProfiles.ContainsKey(newName))
{
profile.Name = newName;
mergedProfiles.Add(newName, profile);
}
else
{
mergedProfiles[newName] = mergedProfiles[newName].Add(profile, newName);
}
}
return(mergedProfiles.Values.ToList());
}
public ActionResult ExportChart(long IdModuloActual)
{
switch (IdModuloActual)
{
case 13010300:
ChartControlSettings settings = ChartHelpers.GetChartSettings();
using (MemoryStream stream = new MemoryStream())
{
settings.SaveToStream(stream);
stream.Seek(0, SeekOrigin.Begin);
WebChartControl chartControl = new WebChartControl();
chartControl.LoadFromStream(stream);
chartControl.Width = Convert.ToInt16(settings.Width.Value);
chartControl.Height = Convert.ToInt16(settings.Height.Value);
chartControl.DataSource = new DataView(ChartHelpers.GenerateDataIO(Metodos.GetDataGraficoImpactoOperacional()));
var pcl = new PrintableComponentLink(new PrintingSystem());
pcl.Component = ((IChartContainer)chartControl).Chart;
pcl.Landscape = true;
pcl.CreateDocument();
using (var exstream = new MemoryStream())
{
pcl.PrintingSystem.ExportToPdf(exstream);
byte[] buf = new byte[(int)exstream.Length];
exstream.Seek(0, SeekOrigin.Begin);
exstream.Read(buf, 0, buf.Length);
return(File(buf, "application/pdf", "chart" + Guid.NewGuid().ToString() + ".pdf"));
}
}
case 13010600:
//< div id = "multichart" >
// < div class="MTD">
// <div class="Titulo">
// @Html.Raw(Resources.ReporteResource.captionMDTHeader)
// </div>
// @Html.Partial("GraficoMTDPartialView", Model.DataMTD)
// </div>
// <div class="RPO">
// <div class="Titulo">
// @Html.Raw(Resources.ReporteResource.captionRPOHeader)
// </div>
// @Html.Partial("GraficoRPOPartialView", Model.DataRPO)
// </div>
// <div class="RTO">
// <div class="Titulo">
// @Html.Raw(Resources.ReporteResource.captionRTOHeader)
// </div>
// @Html.Partial("GraficoRTOPartialView", Model.DataRTO)
// </div>
// <div class="WRT">
// <div class="Titulo">
// @Html.Raw(Resources.ReporteResource.captionWRTHeader)
// </div>
// @Html.Partial("GraficoWRTPartialView", Model.DataWRT)
// </div>
//</div>
break;
case 13010900:
//chartControl.DataSource = new DataView(ChartHelpers.GenerateDataIO(Metodos.GetNroProcesosByImpactoOperacional()));
break;
}
return(null);
}
private void btnExport_Click(object sender, System.Windows.RoutedEventArgs e)
{
// sample 1
// ChartHelpers.SaveToPng(chartProductivity, "chart.png");
// https://tedgustaf.com/blog/2012/create-excel-20072010-spreadsheets-with-c-and-epplus/
// sample 2
var currentDate = DateTime.Now;
// Set the file name and get the output directory
var fileName = "Report-" + currentDate.ToString("yyyy-MM-dd--hh-mm-ss") + ".xlsx";
var baseDirectory = @"C:\" + Constants.ApplicationName + @"\reports\";
var filePath = Path.Combine(baseDirectory, fileName);
try
{
var mainWindow = (MainWindow)Application.Current.MainWindow;
if (!Directory.Exists(baseDirectory))
{
Directory.CreateDirectory(baseDirectory);
}
// Create the file using the FileInfo object
var file = new FileInfo(filePath);
// find all charts and grids
var grids = CommonHelpers.FindVisualChildren <DataGrid>(mainWindow).ToList();
var charts = CommonHelpers.FindVisualChildren <CartesianChart>(mainWindow).ToList();
// Create the package and make sure you wrap it in a using statement
using (var package = new ExcelPackage(file))
{
// add a new worksheet to the empty workbook
ExcelWorksheet worksheet = package.Workbook.Worksheets.Add("Productivity - " + currentDate.ToShortDateString());
// --------- Data and styling goes here -------------- //
var rowIndex = 1;
var pixelTop = 0d;
var pixelLeft = 0;
var chartHeight = 300;
var rowHeight = 39;
var calculatedChartHeight = CommonHelpers.GetHeight(chartHeight);
var calculatedRowHeight = CommonHelpers.GetHeight(rowHeight);
foreach (var chartVM in ChartViewModels)
{
var chart = charts.Where(x => x.Tag != null && x.Tag.ToString() == chartVM.ChartName).FirstOrDefault();
if (chart != null)
{
worksheet.Row(rowIndex).Height = calculatedChartHeight;
var imageChart = ChartHelpers.ChartToImage(chart, chart.ActualWidth, chart.ActualHeight);
var picture = worksheet.Drawings.AddPicture(chartVM.ChartName, imageChart);
int intPixelTop = (int)pixelTop;
picture.SetPosition(intPixelTop, pixelLeft);
//picture.SetSize(Height, Width);
pixelTop += calculatedChartHeight;
rowIndex++;
}
var grid = grids.Where(x => x.Tag != null && x.Tag.ToString() == chartVM.GridName).FirstOrDefault();
if (grid != null)
{
for (int i = 0; i < grid.Columns.Count; i++)
{
var header = grid.Columns[i].Header != null ? grid.Columns[i].Header.ToString() : string.Empty;
worksheet.Cells[rowIndex, i + 1].Value = header;
}
//worksheet.Row(rowIndex).Height = calculatedRowHeight;
pixelTop += rowHeight;
rowIndex++;
for (int i = 0; i < grid.Items.Count; i++)
{
for (int j = 0; j < grid.Columns.Count; j++)
{
//loop throught cell
DataGridCell cell = CommonHelpers.GetCell(grid, i, j);
if (cell != null)
{
if (cell.Content is TextBlock)
{
TextBlock tb = cell.Content as TextBlock;
worksheet.Cells[rowIndex, j + 1].Value = tb.Text;
}
}
}
//worksheet.Row(rowIndex).Height = calculatedRowHeight;
pixelTop += rowHeight;
rowIndex++;
}
}
}
// var img = System.Drawing.Image.FromFile(@"D:\pics\success.jpg"); // testing ok
// var pic = worksheet.Drawings.AddPicture("Sample", img);
// end
package.Save();
}
MessageBox.Show("Successfully exported report " + fileName, Constants.ApplicationName, MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex)
{
var msg = ex.GetAllExceptionInfo();
log.Error(msg, ex);
MessageBox.Show("Cannot export report", Constants.ApplicationName, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public async Task <OperationDataResult <List <CommonDictionaryModel> > > GetFilterAnswers(DashboardItemAnswerRequestModel requestModel)
{
try
{
var core = await _coreHelper.GetCore();
using (var sdkContext = core.DbContextHelper.GetDbContext())
{
var languages = await sdkContext.Languages.ToListAsync();
var answersResult = new List <CommonDictionaryModel>();
bool isSmileyQuestion = false;
foreach (var language in languages)
{
isSmileyQuestion = await sdkContext.Questions
.Where(x => x.Id == requestModel.FilterQuestionId)
.Select(x => x.IsSmiley())
.FirstOrDefaultAsync();
// TODO take by language
var answers = await sdkContext.Options
.AsNoTracking()
.Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
.Where(x => x.QuestionId == requestModel.FilterQuestionId)
.Select(x => new CommonDictionaryModel()
{
Id = x.Id,
Name = x.OptionTranslationses
.Where(qt => qt.WorkflowState != Constants.WorkflowStates.Removed)
.Where(qt => qt.Language.Id == language.Id)
.Select(qt => qt.Name)
.FirstOrDefault(),
}).ToListAsync();
if (answers.Any())
{
answersResult.AddRange(answers);
break;
}
}
if (isSmileyQuestion)
{
var result = new List <CommonDictionaryModel>();
foreach (var dictionaryModel in answersResult)
{
result.Add(new CommonDictionaryModel
{
Id = dictionaryModel.Id,
Name = ChartHelpers.GetSmileyLabel(dictionaryModel.Name),
Description = dictionaryModel.Description,
});
}
return(new OperationDataResult <List <CommonDictionaryModel> >(
true,
result));
}
return(new OperationDataResult <List <CommonDictionaryModel> >(
true,
answersResult));
}
}
catch (Exception e)
{
Trace.TraceError(e.Message);
_logger.LogError(e.Message);
return(new OperationDataResult <List <CommonDictionaryModel> >(false,
_localizationService.GetString("ErrorWhileObtainingAnswers")));
}
}
private void KeyKeyboardChecker(Keys key)
{
switch (key)
{
case Keys.Escape:
{
_renderForm.Close();
this.Hide();
this.Close();
break;
}
case Keys.D1:
{
if (_barType != BarType.Candle)
{
_barType = BarType.Candle;
SetForChartMinMaxPoints(_barRendering.Skip);
_barRendering = new BarCandle(_d2DRenderTarget, _barRendering.Bars, _chart, _barRendering.Skip);
break;
}
break;
}
case Keys.D2:
{
if (_barType != BarType.OHLC)
{
_barType = BarType.OHLC;
SetForChartMinMaxPoints(_barRendering.Skip);
_barRendering = new BarOHLC(_d2DRenderTarget, _barRendering.Bars, _chart, _barRendering.Skip);
break;
}
break;
}
case Keys.Q:
{
if (_chartHelpers != ChartHelpers.Net)
{
_chartHelpers = ChartHelpers.Net;
_drawAdditionChartHelper = DrawNet;
break;
}
_drawAdditionChartHelper -= DrawNet;
_chartHelpers = ChartHelpers.Default;
break;
}
case Keys.W:
{
if (_chartHelpers != ChartHelpers.Lines)
{
_chartHelpers = ChartHelpers.Lines;
_drawAdditionChartHelper = DrawLines;
break;
}
_drawAdditionChartHelper -= DrawLines;
_chartHelpers = ChartHelpers.Default;
break;
}
case Keys.E:
{
if (_actions != DrawingActions.LineDrawing)
{
_actions = DrawingActions.LineDrawing;
_tempDrawing = new LineFigure(_d2DRenderTarget);
break;
}
_tempDrawing = null;
_actions = DrawingActions.Default;
break;
}
case Keys.R:
{
if (_actions != DrawingActions.RectangleDrawing)
{
_tempDrawing = new RectangleFigure(_d2DRenderTarget);
_actions = DrawingActions.RectangleDrawing;
break;
}
_tempDrawing = null;
_actions = DrawingActions.Default;
break;
}
case Keys.T:
{
if (_actions != DrawingActions.EllipseDrawing)
{
_tempDrawing = new EllipseFigure(_d2DRenderTarget);
_actions = DrawingActions.EllipseDrawing;
break;
}
_tempDrawing = null;
_actions = DrawingActions.Default;
break;
}
case Keys.A:
{
if (_actions != DrawingActions.StraightLineXDrawing)
{
_actions = DrawingActions.StraightLineXDrawing;
break;
}
_actions = DrawingActions.Default;
break;
}
case Keys.S:
{
if (_actions != DrawingActions.StraightLineYDrawing)
{
_actions = DrawingActions.StraightLineYDrawing;
break;
}
_actions = DrawingActions.Default;
break;
}
case Keys.Z:
{
if (_chartHelpers != ChartHelpers.Zoom)
{
_zoomArea = null;
_chartHelpers = ChartHelpers.Zoom;
break;
}
_chartHelpers = ChartHelpers.Default;
break;
}
case Keys.Delete:
{
RemoveFigure();
break;
}
case Keys.C:
{
_chart.ChangeColor();
break;
}
case Keys.Enter:
{
ResetChart();
break;
}
}
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices,
[NotNull] AnalysisRepository analysisRepo)
{
Info("starting to make trafostation results");
MultiyearMultiVariableTrend myt = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
var dbArchive =
Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saHouses = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive,
SaveableEntryTableType.SummedLoadsForAnalysis,
Services.Logger);
var entries = saHouses.LoadAllOrMatching();
var providerentries1 = entries.Where(x => x.Key.SumType == SumType.ByProvider).ToList();
double electricitySum = 0;
foreach (var entry in providerentries1)
{
if (entry.GenerationOrLoad == GenerationOrLoad.Generation)
{
continue;
}
double energy = entry.Profile.EnergySum();
string providertype = (entry.Key.ProviderType ?? throw new FlaException("No provider set")) + " " + entry.GenerationOrLoad;
Info("Providertype: " + providertype);
electricitySum += energy;
}
HouseComponentRepository hcr = new HouseComponentRepository(analysisRepo, slice);
var houses = analysisRepo.GetSlice(slice).Fetch <House>();
Dictionary <string, double> loadPerEnergyType = new Dictionary <string, double>();
Dictionary <string, double> genPerEnergyType = new Dictionary <string, double>();
foreach (var house in houses)
{
var components = house.CollectHouseComponents(hcr);
foreach (var component in components)
{
if (component.HausAnschlussGuid == null)
{
continue;
}
string energyType = component.EnergyType.ToString();
if (component.GenerationOrLoad == GenerationOrLoad.Load)
{
if (!loadPerEnergyType.ContainsKey(energyType))
{
loadPerEnergyType.Add(energyType, 0);
}
loadPerEnergyType[energyType] += component.EffectiveEnergyDemand;
}
else if (component.GenerationOrLoad == GenerationOrLoad.Generation)
{
if (!genPerEnergyType.ContainsKey(energyType))
{
genPerEnergyType.Add(energyType, 0);
}
genPerEnergyType[energyType] += component.EffectiveEnergyDemand;
}
else
{
throw new FlaException("invalid type");
}
}
}
foreach (var pair in loadPerEnergyType)
{
if (pair.Key == "Strom")
{
myt[slice].AddValue("Jahresenergiebedarf [GWh]",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
electricitySum,
DisplayUnit.GWh);
}
else
{
myt[slice].AddValue("Jahresenergiebedarf [GWh]",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
pair.Value,
DisplayUnit.GWh);
}
}
foreach (var pair in genPerEnergyType)
{
if (pair.Key == "Strom")
{
myt[slice].AddValue("GenerationPerEnergyType",
ChartHelpers.GetFriendlyEnergTypeName(pair.Key),
electricitySum,
DisplayUnit.GWh);
}
else
{
myt[slice].AddValue("GenerationPerEnergyType", ChartHelpers.GetFriendlyEnergTypeName(pair.Key), pair.Value, DisplayUnit.GWh);
}
}
}
var filename3 = MakeAndRegisterFullFilename("EnergieProEnergieträger.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, myt);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "5");
}
protected override void RunActualProcess([NotNull][ItemNotNull] List <ScenarioSliceParameters> allSlices, [NotNull] AnalysisRepository analysisRepo)
{
List <ScenarioSliceParameters> missingSlices = new List <ScenarioSliceParameters>();
foreach (var slice in allSlices)
{
Info("Checking for slice " + slice);
var db = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice);
var fi = new FileInfo(db.DBFilename);
if (!fi.Exists)
{
missingSlices.Add(slice);
}
}
if (missingSlices.Count > 0)
{
var missingSliceNames = missingSlices.Select(x => x.ToString()).ToList();
string missingSlicesStr = string.Join("\n", missingSliceNames);
throw new FlaException("Missing Profile Slices: " + missingSlicesStr);
}
Info("starting to make trafostation results");
MultiyearMultiVariableTrend mytProviders = new MultiyearMultiVariableTrend();
MultiyearMultiVariableTrend mytComponents = new MultiyearMultiVariableTrend();
foreach (var slice in allSlices)
{
var dbArchive = Services.SqlConnectionPreparer.GetDatabaseConnection(Stage.ProfileGeneration, slice, DatabaseCode.SummedLoadForAnalysis);
var saHouses = SaveableEntry <ArchiveEntry> .GetSaveableEntry(dbArchive, SaveableEntryTableType.SummedLoadsForAnalysis, Services.Logger);
var entries = saHouses.LoadAllOrMatching();
var providerentries1 = entries.Where(x => x.Key.SumType == SumType.ByProvider).ToList();
providerentries1.Sort((x, y) => String.Compare(x.Key.ProviderType, y.Key.ProviderType, StringComparison.Ordinal));
Dictionary <Tuple <string, GenerationOrLoad>, double> energyByName = new Dictionary <Tuple <string, GenerationOrLoad>, double>();
foreach (var entry in providerentries1)
{
double energy = entry.Profile.EnergySum();
string providertype = (entry.Key.ProviderType ?? throw new FlaException("No provider set")) + " " + entry.GenerationOrLoad;
Info("Providertype: " + providertype);
var friendlyName = ChartHelpers.GetFriendlyProviderName(providertype);
var key = new Tuple <string, GenerationOrLoad>(friendlyName, entry.GenerationOrLoad);
if (!energyByName.ContainsKey(key))
{
energyByName.Add(key, 0);
}
energyByName[key] += energy;
}
foreach (var pair in energyByName)
{
if (pair.Key.Item2 == GenerationOrLoad.Load)
{
mytProviders[slice].AddValue("Stromlast [GWh]", pair.Key.Item1, pair.Value, DisplayUnit.GWh);
}
else
{
mytProviders[slice].AddValue("Erzeugung [GWh]", pair.Key.Item1, pair.Value, DisplayUnit.GWh);
}
}
var componentEntries = entries.Where(x => x.Key.SumType == SumType.ByHouseholdComponentType).ToList();
componentEntries.Sort((x, y) => String.Compare(x.Key.HouseComponentType, y.Key.HouseComponentType, StringComparison.Ordinal));
foreach (var entry in componentEntries)
{
double energy = entry.Profile.EnergySum();
string houseComponentType = entry.Key.HouseComponentType ?? throw new FlaException("No provider set");
Info("HouseComponentType: " + houseComponentType);
if (entry.Key.GenerationOrLoad == GenerationOrLoad.Load)
{
mytComponents[slice].AddValue("ComponentLoad", houseComponentType, energy, DisplayUnit.GWh);
}
else
{
mytComponents[slice].AddValue("ComponentGeneration", houseComponentType, energy, DisplayUnit.GWh);
}
}
}
var filename3 = MakeAndRegisterFullFilename("EnergieProVerbraucher.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename3);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename3, mytProviders);
SaveToPublicationDirectory(filename3, Constants.PresentSlice, "5");
var filename4 = MakeAndRegisterFullFilename("ComponentProfileEnergyCharts.xlsx", Constants.PresentSlice);
Info("Writing results to " + filename4);
XlsxDumper.DumpMultiyearMultiVariableTrendToExcel(filename4, mytComponents);
SaveToArchiveDirectory(filename4, RelativeDirectory.Report, Constants.PresentSlice);
}
