public void ProcessStackedExportables()
{
for (int i = 0; i < toExport.Count; i++)
{
if (toExport.TryPop(out Exportable exportable))
{
if (exportable.Enabled)
{
exportable.Export();
if (exportable.Disposeable)
{
exportable.Dispose();
}
}
else
{
Exportable[] exportables = new Exportable[toExport.Count];
toExport.TryPopRange(exportables);
toExport.Push(exportable);
Array.Reverse(exportables);
toExport.PushRange(exportables);
}
}
}
}
private void buttonExportAllToCsv_Click(object sender, EventArgs e)
{
var dlg = new SaveFileDialog();
dlg.Title = "Enter name of json file to save as";
var result = dlg.ShowDialog();
if (result == DialogResult.OK)
{
Thread backgroundThread = new Thread(
new ThreadStart(() =>
{
var context = new PersonalSpendingAnalysisRepo();
var exportable = new Exportable();
exportable.transactions = context.Transaction.ToList();
exportable.categories = context.Categories.ToList();
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore,
DateFormatHandling = DateFormatHandling.IsoDateFormat
};
string json = JsonConvert.SerializeObject(exportable, settings);
File.WriteAllText(dlg.FileName, json);
MessageBox.Show("Export completed!");
}
));
backgroundThread.Start();
}
}
ParametersViewModel GetParameters(Member member)
{
var parameters = member.GetParametersOrNull();
if (parameters == null)
{
return(null);
}
var invisibleParams = parameters.Where(e => e.Type.IsArray
? !Exportable.IsExportableAndVisible(e.Type.ElementType)
: !Exportable.IsExportableAndVisible(e.Type))
.ToList();
if (invisibleParams.Count > 0)
{
var names = new List <string>();
foreach (var p in invisibleParams)
{
var paramType = p.Type.IsArray ? p.Type.ElementType : p.Type;
names.Add($"{p.Name} ({paramType.FullName})");
}
throw new Exception($"Found {invisibleParams.Count} parameters for member {member.FullName} that have non-exportable types: {string.Join(", ", names)}");
}
var list = parameters.Select(param => GetParameterViewModelForParameter(param)).ToList();
return(new ParametersViewModel(list));
}
private async void FileLoadCommand_ExecuteRequested(XamlUICommand sender, ExecuteRequestedEventArgs args)
{
fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
fileOpenPicker.FileTypeFilter.Add(".jpg");
fileOpenPicker.FileTypeFilter.Add(".png");
fileOpenPicker.FileTypeFilter.Add(customFileExtension);
StorageFile inputFile = await fileOpenPicker.PickSingleFileAsync();
//User cancelled load
if (inputFile == null)
{
return;
}
ImageProperties imageProperties = await inputFile.Properties.GetImagePropertiesAsync();
if (inputFile.FileType == customFileExtension)
{
using (Stream stream = await inputFile.OpenStreamForReadAsync())
{
DataContractSerializer ser = new DataContractSerializer(typeof(Exportable));
object obj = ser.ReadObject(stream);
Exportable exp = (Exportable)obj;
SetDrawingArea((int)exp.width, (int)exp.height);
DrawArea.ImageDataLayer.BitmapDrawingData.PixelBuffer.AsStream().Write(exp.bytes, 0, exp.bytes.Length);
DrawArea.ImageDataLayer.BitmapDrawingData.Invalidate();
History.StartHistory(exp.bytes);
DrawingCanvas.canvas.ImageDataLayer.DrawBrush(new Stroke(), new DrawPoint(new Point(0, 0), new Point(0, 0)));
History.Undo();
}
return;
}
using (IRandomAccessStream fileStream = await inputFile.OpenAsync(Windows.Storage.FileAccessMode.Read)) {
/* BitmapDecoder decoder = await BitmapDecoder.CreateAsync(BitmapDecoder.JpegDecoderId, fileStream);
* //if (inputFile.FileType == ".png") decoder = await BitmapDecoder.CreateAsync(BitmapEncoder.PngEncoderId, fileStream);
* //if (inputFile.FileType == ".jpg") decoder = await BitmapDecoder.CreateAsync(BitmapEncoder.JpegEncoderId, fileStream);
* SoftwareBitmap bitmap = await decoder.GetSoftwareBitmapAsync();
* byte[] pixels = bitmap.BitmapPixelFormat
* drawArea.ImageDataLayer.BitmapDrawingData.SetPixel*/
newHeight = (int)imageProperties.Height;
newWidth = (int)imageProperties.Width;
SetDrawingArea(newWidth, newHeight);
//WriteableBitmap bi = new WriteableBitmap(newWidth, newHeight);
//await bi.SetSourceAsync(fileStream);
//byte[] pixels = bi.ToByteArray();
//DrawArea.ImageDataLayer.BitmapDrawingData.FromByteArray(pixels);
//^V does the same
await drawArea.ImageDataLayer.BitmapDrawingData.SetSourceAsync(fileStream); //Look at this
updateLoad();
}
}
public void Prepare()
{
Stack <int> indices = new Stack <int>();
int i = 0;
foreach (var exportable in toExport)
{
if (exportable is ExportableChunkPart)
{
ExportableChunkPart a = (ExportableChunkPart)exportable;
foreach (var incoming in toExportLast)
{
if (incoming is ExportableChunkPart)
{
ExportableChunkPart b = (ExportableChunkPart)incoming;
if (a.Is(b))
{
indices.Push(i);
break;
}
}
}
i++;
}
}
if (indices.Count == 0)
{
return;
}
var ind = indices.ToArray();
var items = new Exportable[toExport.Count];
toExport.TryPopRange(items);
for (i = 0; i < ind.Length; i++)
{
items[ind[i]].Dispose();
items[ind[i]] = null;
}
Array.Reverse(items);
foreach (var val in items)
{
if (val != null)
{
toExport.Push(val);
}
}
}
void AddAttachedMemberToTarget(string name, MemberType memberType, Method underlyingMethod, DataType returnType, DataType parentDataType, HashSet <DocumentViewModel> target)
{
var uxAttribute = underlyingMethod.Attributes.SingleOrDefault(e => e.ReturnType.QualifiedName == ExportConstants.UxAttachedPropertySetterAttributeName ||
e.ReturnType.QualifiedName == ExportConstants.UxAttachedEventAdderAttributeName);
if (uxAttribute == null)
{
throw new ArgumentException($"UX attached attribute not found on {underlyingMethod.UnoName}");
}
var uxAttributeName = uxAttribute.Arguments.Length == 0 ? null : uxAttribute.Arguments[0].ConstantString;
if (string.IsNullOrWhiteSpace(uxAttributeName))
{
throw new ArgumentException($"UX attached attribute did not contain any on {underlyingMethod.UnoName}");
}
uxAttributeName = uxAttributeName.ToLowerInvariant()
.Replace(".", "_");
var id = parentDataType.GetUri() + "/" + uxAttributeName + "_" + underlyingMethod.GetUriSignature();
var titles = new TitlesViewModel(Naming.GetPageTitle(underlyingMethod),
uxAttribute.Arguments[0].ConstantString,
uxAttribute.Arguments[0].ConstantString,
Naming.GetNavigationTitle(underlyingMethod),
Naming.GetFullIndexTitle(underlyingMethod));
var declaredIn = new DataTypeBuilder(Naming, Syntax, Exportable, AttachedMembers, _commentParser).BuildReference(underlyingMethod.DeclaringType);
var parameters = GetParameters(underlyingMethod);
var returns = GetReturns(underlyingMethod, returnType);
var values = BuildValues(returnType);
var source = new AttachedMemberSourceViewModel(underlyingMethod.DeclaringType.GetUri(), Naming.GetIndexTitle(underlyingMethod.DeclaringType));
var comment = _commentParser.Read(underlyingMethod);
if (!Exportable.IsExportableAndVisible(underlyingMethod.DeclaringType))
{
throw new Exception($"Found attached UX member {underlyingMethod.FullName} declared inside non-exportable class {underlyingMethod.DeclaringType.FullName}");
}
var viewModel = new AttachedMemberViewModel(new DocumentIdViewModel(id, parentDataType.GetUri(), "AttachedUx" + memberType.ToString("G"), new List <string>()),
new DocumentUriViewModel(id, underlyingMethod.GetUri(), true),
titles,
declaredIn,
parameters,
returns,
values,
source,
new CommentViewModel(comment),
underlyingMethod);
target.AddIfNotExists(viewModel);
}
ReturnsViewModel GetReturns(Member member, DataType returnDataType)
{
var dataType = returnDataType.IsArray ? returnDataType.ElementType : returnDataType;
var suffix = returnDataType.IsArray ? "[]" : "";
if (!Exportable.IsExportableAndVisible(dataType))
{
throw new Exception($"Found return type for member {member.FullName} that have non-exportable return type: {dataType.FullName}");
}
return(new ReturnsViewModel(GetDataTypeUri(dataType),
dataType.IsVirtualType(),
Naming.GetIndexTitle(dataType) + suffix,
Naming.GetFullIndexTitle(dataType) + suffix));
}
public void PushToBottom()
{
if (toExportLast.IsEmpty)
{
return;
}
bool toExportWasEmpty = toExport.IsEmpty;
Exportable[] toExportFallback = new Exportable[toExport.Count];
Exportable[] toExportLastFallback = new Exportable[toExportLast.Count];
if (!toExportWasEmpty)
{
toExport.CopyTo(toExportFallback, 0);
Array.Reverse(toExportFallback);
}
toExportLast.CopyTo(toExportLastFallback, 0);
Array.Reverse(toExportLastFallback);
Exportable[] range = new Exportable[toExport.Count];
if (toExportWasEmpty || toExport.TryPopRange(range) == range.Length)
{
Exportable[] newRange = new Exportable[toExportLast.Count];
if (toExportLast.TryPopRange(newRange) == newRange.Length)
{
toExport.PushRange(newRange);
}
else
{
toExportLast.Clear();
toExportLast.PushRange(toExportLastFallback);
};
if (!toExportWasEmpty)
{
Array.Reverse(range);
toExport.PushRange(range);
}
}
else if (!toExportWasEmpty)
{
toExport.Clear();
toExport.PushRange(toExportFallback);
}
}
AttributesViewModel BuildAttributes(Member member)
{
var models = new List <AttributeViewModel>();
foreach (var attr in member.Attributes ?? new NewObject[0])
{
if (!Exportable.IsExportableAndVisible(attr.ReturnType))
{
continue;
}
var parameters = attr.Arguments.Select(e => e.ConstantString).ToList();
var reference = new DataTypeBuilder(Naming, Syntax, Exportable, AttachedMembers, _commentParser).BuildReference(attr.ReturnType);
models.Add(new AttributeViewModel(reference.Id, reference.Uri, reference.Titles, parameters));
}
return(new AttributesViewModel(models));
}
private AttributesViewModel BuildAttributes(DataType dataType)
{
var models = new List <AttributeViewModel>();
foreach (var attr in dataType.Attributes ?? new NewObject[0])
{
if (!Exportable.IsExportableAndVisible(attr.ReturnType))
{
continue;
}
var parameters = attr.Arguments.Select(e => e.ConstantString).ToList();
var reference = BuildReference(attr.ReturnType);
models.Add(new AttributeViewModel(reference.Id, reference.Uri, reference.Titles, parameters));
}
return(new AttributesViewModel(models));
}
private ReturnsViewModel BuildReturns(DataType dataType)
{
var delegateType = dataType as DelegateType;
if (delegateType == null || delegateType.ReturnType.FullName == ExportConstants.VoidTypeName)
{
return(null);
}
if (!Exportable.IsExportableAndVisible(delegateType.ReturnType))
{
throw new Exception($"Found return type for delegate {delegateType.FullName} that have non-exportable return type: {delegateType.ReturnType.FullName}");
}
return(new ReturnsViewModel(delegateType.GetUri(),
delegateType.IsVirtualType(),
Naming.GetIndexTitle(delegateType.ReturnType),
Naming.GetFullIndexTitle(delegateType.ReturnType)));
}
private PieChart GetBasePieChart(String seriesName, Datum[] data)
{
return(new PieChart
{
chart = new Chart
{
plotBackgroundColor = null,
plotBorderWidth = null,
plotShadow = false,
type = "pie"
},
title = new QuickSoftwareMgmt.Models.Hicharts.PieChart.Title
{
text = ""
},
tooltip = new QuickSoftwareMgmt.Models.Hicharts.PieChart.Tooltip
{
pointFormat = "{series.name}: <b>{point.percentage:.1f}%</b>"
},
plotOptions = new Plotoptions
{
pie = new Pie
{
allowPointSelect = true,
cursor = "pointer",
dataLabels = new Datalabels
{
enabled = true,
format = "{point.percentage:.1f} %",
},
showInLegend = true
}
},
series = new QuickSoftwareMgmt.Models.Hicharts.PieChart.Series[] {
new QuickSoftwareMgmt.Models.Hicharts.PieChart.Series {
name = seriesName,
colorByPoint = true,
data = data
}
},
exporting = Exportable.GetDefault(seriesName),
});
}
public static void Clear <T>()
{
if (toExport.IsEmpty)
{
return;
}
Stack <int> indices = new Stack <int>();
int i = 0;
foreach (var val in toExport)
{
if (val is T)
{
indices.Push(i);
}
i++;
}
var ind = indices.ToArray();
var items = new Exportable[toExport.Count];
toExport.TryPopRange(items);
for (i = 0; i < ind.Length; i++)
{
items[ind[i]].Dispose();
items[ind[i]] = null;
}
Array.Reverse(items);
foreach (var val in items)
{
if (val != null)
{
toExport.Push(val);
}
}
}
private void ExportMembers(IEnumerable <Member> members, DataType dataType, HashSet <DocumentViewModel> target, HashSet <string> seenMembers)
{
var invisibleMembers = members.Where(e => Exportable.IsExportableAndVisible(e) && !Exportable.IsExportableAndVisible(e.DeclaringType)).ToList();
if (invisibleMembers.Count > 0)
{
throw new Exception($"Found members inside {dataType.FullName} declared on non-exportable parent type: {string.Join(", ", invisibleMembers.Select(e => e.FullName))}");
}
var exportableMembers = members.Where(e => Exportable.IsExportableAndVisible(e) && Exportable.IsExportableAndVisible(e.DeclaringType)).ToList();
exportableMembers.ForEach(member =>
{
var id = dataType.GetUri() + "/" + member.GetUriSignature();
if (!seenMembers.Contains(id))
{
GetMemberBuilder().Build(member, dataType, target);
seenMembers.Add(id);
}
});
}
private ImplementedInterfacesViewModel BuildImplementedInterfaces(DataType dataType)
{
var result = new List <ImplementedInterfaceViewModel>();
foreach (var iface in GetAllInterfaces(dataType))
{
if (!Exportable.IsExportableAndVisible(iface))
{
continue;
}
var comment = _commentParser.Read(iface);
var id = BuildDataTypeId(iface, comment);
var uri = BuildDataTypeUri(iface);
var titles = BuildDataTypeIndexTitles(iface);
var viewModel = new ImplementedInterfaceViewModel(id, uri, titles, new BasicCommentViewModel(comment));
result.Add(viewModel);
}
return(new ImplementedInterfacesViewModel(result));
}
private async void FileExportCommand_ExecuteRequested(XamlUICommand sender, ExecuteRequestedEventArgs args)
{
//serialization here
FileSavePicker picker = new FileSavePicker();
picker.FileTypeChoices.Add("Drawing Project file", new List <string>()
{
customFileExtension
});
picker.SuggestedFileName = "New Project";
StorageFile file = await picker.PickSaveFileAsync();
if (file != null)
{
using (Stream stream = await file.OpenStreamForWriteAsync()) {
DataContractSerializer ser = new DataContractSerializer(typeof(Exportable));
Exportable export = new Exportable(DrawArea.ImageDataLayer.BitmapDrawingData.PixelBuffer.ToArray(), DrawArea.ImageData.ActualWidth, DrawArea.ImageData.ActualHeight);
ser.WriteObject(stream, export);
}
}
}
private ParametersViewModel GetParameters(DataType dataType)
{
var parameters = dataType.GetParametersOrNull();
if (parameters == null)
{
return(null);
}
var invisibleParams = parameters.Where(e => e.Type.IsArray
? !Exportable.IsExportableAndVisible(e.Type.ElementType)
: !Exportable.IsExportableAndVisible(e.Type))
.ToList();
if (invisibleParams.Count > 0)
{
var names = new List <string>();
foreach (var p in invisibleParams)
{
var paramType = p.Type.IsArray ? p.Type.ElementType : p.Type;
names.Add($"{p.Name} ({paramType.FullName})");
}
throw new Exception($"Found {invisibleParams.Count} parameters for type {dataType.FullName} that have non-exportable types: {string.Join(", ", names)}");
}
var list = parameters.Select(param => param.Type.IsArray
? new ParameterViewModel(param.Name,
param.Type.ElementType.GetUri(),
param.Type.ElementType.IsVirtualType(),
Naming.GetIndexTitle(param.Type.ElementType),
Naming.GetFullIndexTitle(param.Type.ElementType))
: new ParameterViewModel(param.Name,
param.Type.GetUri(),
param.Type.IsVirtualType(),
Naming.GetIndexTitle(param.Type),
Naming.GetFullIndexTitle(param.Type)))
.ToList();
return(new ParametersViewModel(list));
}
/// <summary>
/// Exports the Data given
/// </summary>
/// <param name="type">Export Format</param>
/// <param name="data">A Data Object</param>
/// <param name="template">A Template to print the Data into</param>
/// <param name="basepath">The Basepath to create the file in</param>
/// <returns>The Path of the created Export</returns>
public static string DataExport(ExportType type, Exportable data, Template template, string basepath, ExportCount ec, string pathtohtmltopdf)
{
string path = basepath + "\\" + data.Filename(ec); //need to Add fileending
switch (type)
{
case ExportType.PDF:
path = exportPDF(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path, basepath, pathtohtmltopdf);
break;
case ExportType.Word:
path = exportWord(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.Excel:
path = exportExcel(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.TXT:
path = exportTXT(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.CSV:
path = exportCSV(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.HTML:
path = exportHTML(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path, basepath);
break;
case ExportType.XML:
path = exportXML(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
case ExportType.MarkDown:
path = exportMD(data.DataName(ec), data.ToContent(ec), data.ObjectID, data.Adress, data.WorkerName, data.DateCreated, data.DateSecond, template, path);
break;
default:
break;
}
return path;
}
public async Task <JsonResult> GetBurndownChart()
{
var sprintId = SelectedSprintId;
var sprint = await db.Sprints
.FindAsync(sprintId);
//var team = await db.Teams
// .Include(t => t.TeamMembers)
// .FirstOrDefaultAsync(t => !t.Erased && t.ProjectId == SelectedProjectId);
//var teamDailyCapacity = team.TeamMembers
// .Where(t => !t.Erased)
// .Sum(t => t.Capacity);
int totalWorkLoad = await db.Tasks
.Where(t => !t.Erased &&
t.SprintId == sprintId &&
!(t.BacklogItem is Test))
.SumAsync(t => t.EstimatedTime);
var workableDates = new List <DateTime>();
var sprintDuration = (int)(sprint.EndDate - sprint.StartDate).TotalDays;
for (int i = 0; i <= sprintDuration; i++)
{
var date = sprint.StartDate.AddDays(i);
if (!(date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday))
{
workableDates.Add(date);
}
}
var actualSprintDuration = 1;
if (workableDates.Count > 1)
{
actualSprintDuration = workableDates.Count - 1;
}
var sprintTaskUpdates = await db.TaskUpdates
.Where(u => !u.Erased &&
u.Task.SprintId == sprintId &&
!(u.Task.BacklogItem is Test) &&
u.EventDate >= sprint.StartDate &&
u.EventDate <= sprint.EndDate)
.ToListAsync();
float idealDailyBurn = 0;
if (workableDates.Count > 0)
{
//idealDailyBurn = (int)Math.Ceiling(totalWorkLoad / (actualSprintDuration * 1.0f));
idealDailyBurn = totalWorkLoad / (actualSprintDuration * 1.0f);
}
var idealBurn = new List <int>();
var actualBurn = new List <int>();
var burned = totalWorkLoad;
for (int i = 0; i < workableDates.Count; i++)
{
var date = workableDates[i];
//Ideal
if (totalWorkLoad - i * idealDailyBurn > 0)
{
idealBurn.Add((int)Math.Ceiling(totalWorkLoad - i * idealDailyBurn));
}
else
{
idealBurn.Add(0);
}
//Actual
burned -= sprintTaskUpdates
.Where(u => u.EventDate.Date == date)
.Sum(u => u.ElapsedTime);
if (burned < 0)
{
burned = 0;
}
actualBurn.Add(burned);
}
var series = new List <Series>();
series.Add(new Series
{
data = idealBurn.ToArray(),
name = "Ideal burn"
});
series.Add(new Series
{
data = actualBurn.ToArray(),
name = "Actual burn"
});
AreaChart areachart = null;
areachart = new AreaChart
{
chart = new Chart
{
type = "areaspline"
},
title = new Title
{
text = ""
},
//subtitle = new Subtitle
//{
// text = ""
//},
xAxis = new Xaxis
{
//allowDecimals = false,
title = new Title {
text = "Fecha"
},
labels = new Labels
{
format = "{value}"
},
categories = workableDates.Select(d => d.ToString("{dd/MM}")).ToArray()
},
yAxis = new Yaxis
{
title = new Title
{
text = "Horas"
},
labels = new Labels
{
format = "{value}"
}
},
tooltip = new Tooltip
{
pointFormat = "{point.y} horas"
},
plotOptions = new Plotoptions
{
area = new Area
{
pointStart = 0,
marker = new Marker
{
enabled = false,
symbol = "circle",
radius = 2,
states = new States
{
hover = new Hover
{
enabled = true
}
}
}
}
},
series = series.ToArray(),
exporting = Exportable.GetDefault("Burndown"),
};
return(Json(areachart, JsonRequestBehavior.AllowGet));
}
public async Task <JsonResult> GetChangesUrgencyByDateChart(String StartDate, String EndDate)
{
int maxDaysBack = -15;
var startDate = DateTime.Today.AddDays(maxDaysBack);//Take changes from the last 15 days
var endDate = DateTime.Today;
if (!String.IsNullOrWhiteSpace(StartDate) && !String.IsNullOrWhiteSpace(EndDate))
{
var initialDate = DateTime.ParseExact(StartDate, "dd/MM/yyyy", System.Globalization.CultureInfo.CurrentUICulture);
var finalDate = DateTime.ParseExact(EndDate, "dd/MM/yyyy", System.Globalization.CultureInfo.CurrentUICulture);
endDate = finalDate;
maxDaysBack = (int)(initialDate - finalDate).TotalDays;
startDate = finalDate.AddDays(maxDaysBack);//Take changes from the last 15 days
}
var priorities = await db.Priorities.ToListAsync();
var dates = new List <DateTime>();
for (int i = maxDaysBack; i <= 0; i++)
{
dates.Add(endDate.AddDays(i));
}
var series = new Models.Hicharts.LineChart.Series[priorities.Count];
for (int i = 0; i < priorities.Count; i++)
{
var priorityId = priorities[i].Id;
var changes = await db.ChangeRequests
.Where(c => !c.Erased &&
c.ProjectId == SelectedProjectId &&
c.PriorityId == priorityId &&
c.CreationDate > startDate)
.GroupBy(c => DbFunctions.CreateDateTime(c.CreationDate.Year, c.CreationDate.Month, c.CreationDate.Day, 0, 0, 0))
.Select(gc => new
{
TimeStamp = gc.Key.Value,
Count = gc.Count()
})
.ToArrayAsync();
series[i] = new Models.Hicharts.LineChart.Series
{
name = priorities[i].Name,
data = dates.Select(d =>
{
var change = changes.FirstOrDefault(c => c.TimeStamp == d);
int count = 0;
if (change != null)
{
count = change.Count;
}
return(count);
}).ToArray()
};
}
var lineChart = new LineChart
{
title = new QuickSoftwareMgmt.Models.Hicharts.LineChart.Title
{
text = ""
},
subtitle = new Subtitle
{
text = ""
},
xAxis = new Xaxis
{
title = new QuickSoftwareMgmt.Models.Hicharts.LineChart.Title {
text = "Fechas"
},
categories = dates.Select(d => d.ToString("{dd/MM}")).ToArray()
},
yAxis = new Yaxis
{
title = new Models.Hicharts.LineChart.Title
{
text = "Cantidad de cambios"
},
plotLines = new Plotline[] {
new Plotline {
value = 0,
width = 1,
color = "#808080"
}
}
},
tooltip = new Models.Hicharts.LineChart.Tooltip
{
valueSuffix = "Cambios"
},
legend = new Legend
{
layout = "vertical",
align = "right",
verticalAlign = "middle",
borderWidth = 0
},
series = series,
exporting = Exportable.GetDefault("Urgencia de cambios por fecha"),
};
return(Json(lineChart, JsonRequestBehavior.AllowGet));
}
public ExportViewModel(Exportable plant)
{
Plant = plant;
}
public ExportView(Exportable export)
{
InitializeComponent();
DataContext = new ExportViewModel(export);
}
