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); }