static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) => { Logger.Fatal(eventArgs.ExceptionObject as Exception); }; Config config = JsonConvert.DeserializeObject <Config>(File.ReadAllText(ConfigFilePath)); var date = DateTime.Now; var month = new DateTime(date.Year, date.Month, 1); //TODO first hide all tabs in the HR sheet report var rawUserDataReporter = new RawUserDataReporter(new RawUserDataSheet(config.RawUsersSheetSettings)); var freshestUserDataReporter = new FreshestUserDataReporter(rawUserDataReporter); var currentUsersReporter = new CurrentUsersReporter(freshestUserDataReporter); ReportWriter <List <UserData> > userDataWriter = new ReportWriter <List <UserData> >(currentUsersReporter, new CurrentUsersSheet(config.CurrentUsersSheetSettings)); userDataWriter.Write(); var publicHolidayReporter = new PublicHolidayReporter(config.PublicHolidayApiKey, Enumerable.Range(HolidayYearStart, month.Year - HolidayYearStart + 2).ToList()); CalculateMonthlyReports(freshestUserDataReporter, publicHolidayReporter, month, config); SendAlerts(freshestUserDataReporter, publicHolidayReporter, date, config); }
public void writeSummaryReport(string report) { string fileName = String.Format("SummaryReport_{0:MM-dd-yyyy}", DateTime.Now); string filePath = System.Web.HttpContext.Current.Server.MapPath("~/Reports/" + fileName); ReportWriter.CreateFile(report, filePath + ".html"); }
public void writeWeeklyStatment(Person person, String statment) { string fileName = String.Format("WeeklyStatment_{0}_{1:MM-dd-yyyy}", person.Name.Replace(" ", "-"), DateTime.Now); string filePath = System.Web.HttpContext.Current.Server.MapPath("~/Reports/" + fileName); ReportWriter.CreateFile(statment, filePath + ".html"); }
private void bcopy_Click(object sender, EventArgs e) { // Copy if (subreportedit.SelectedItems.Count == 0) { MessageBox.Show("No items selected"); return; } if (!(subreportedit.SelectedItems.Values[0] is PrintPosItem)) { MessageBox.Show("No items selected"); return; } List <PrintPosItem> nlist = new List <PrintPosItem>(); foreach (BandInfo nband in subreportedit.SelectedItemsBands.Values) { Section nsec = nband.Section; if (nsec != null) { foreach (PrintPosItem nitem in nsec.Components) { int index = subreportedit.SelectedItems.IndexOfKey(nitem.SelectionIndex); if (index >= 0) { nlist.Add(nitem); } } } } string nresult = ReportWriter.WriteComponents(nlist); Clipboard.SetText(nresult); }
private static async Task Handler(int iterations, int duration, int concurrency, int rampUp, string reportFile, string target) { var reportWriter = new ReportWriter(reportFile); var userStepTime = rampUp / concurrency; var testTasks = new List <Task>(); var startTime = DateTime.UtcNow; var testAssembly = System.Reflection.Assembly.LoadFrom(target); for (var i = 1; i <= concurrency; ++i) { var threadName = $"worker_{i}"; var eventListener = new XUnitTestEventListener(reportWriter, threadName); var runner = AssemblyRunner.WithoutAppDomain(target); runner.OnDiscoveryComplete = XUnitTestEventListener.OnDiscoveryComplete; runner.OnTestFailed = eventListener.OnTestFailed; runner.OnTestSkipped = eventListener.OnTestSkipped; runner.OnTestFinished = eventListener.OnTestFinished; testTasks.Add(Task.Run(() => StartWorker(runner, startTime, iterations, duration))); Thread.Sleep(userStepTime * 1000); } await Task.WhenAll(testTasks); await reportWriter.StopWritingAsync(); }
public void writeEFTData(Provider provider, string content) { string fileName = String.Format("EFT_{0}_{1:MM-dd-yyyy}", provider.Name.Replace(" ", "-"), DateTime.Now); string filePath = System.Web.HttpContext.Current.Server.MapPath("~/Reports/" + fileName); ReportWriter.CreateFile(content, filePath + ".txt"); }
public void GenerateReportFromLatestEmbeddings() { var embeddingsFile = new DirectoryInfo($@"{Directory.GetCurrentDirectory()}/{ResultsDirectory}").EnumerateFiles() .Where(f => Regex.IsMatch(f.Name, "^wordEmbeddings-.*$")) .OrderBy(f => f.CreationTime) .Last(); var reportFileLoc = $@"{Directory.GetCurrentDirectory()}/{ResultsDirectory}/report-{DateTime.Now.Ticks}.csv"; var wordEmbeddings = new List <WordEmbedding>(); using var fileStream = new FileStream(embeddingsFile.FullName, FileMode.OpenOrCreate, FileAccess.Read); using var reader = new StreamReader(fileStream, Encoding.UTF8); wordEmbeddings.PopulateWordEmbeddingsFromStream(reader); wordEmbeddings.NormaliseEmbeddings(); var articleEmbeddings = new List <ArticleEmbedding>(); foreach (var line in File.ReadLines(InputFileLoc)) { var splitLine = line.Split(','); articleEmbeddings.Add(new ArticleEmbedding(splitLine[0], string.Join(' ', splitLine.Skip(1)), maxContentsLength: 500)); } articleEmbeddings.AssignVectorsFromWeightedWordEmbeddings(wordEmbeddings); var kMeans = new KMeans(articleEmbeddings); kMeans.CalculateLabelClusterMap( numberOfClusters: 25 ); var reportHandler = new ReportWriter(reportFileLoc); reportHandler.WriteLabelsWithClusterIndex(kMeans.LabelClusterMap); }
public async void PrintPDF(Memo memo) { Reports = new Reports(memo); //var stream = new InMemoryRandomAccessStream(); //FileSavePicker fileSavePicker = new FileSavePicker(); WriterFormat format = WriterFormat.PDF; //fileSavePicker.SuggestedFileName = "ExportReport"; //var savedItem = await fileSavePicker.PickSaveFileAsync(); //if (savedItem != null) // Windows.Storage.StorageFolder storageFolder = Windows.Storage.ApplicationData.Current.LocalFolder; Windows.Storage.StorageFile savedItem = await storageFolder.CreateFileAsync("sample.pdf", Windows.Storage.CreationCollisionOption.ReplaceExisting); //var savedItem = await FileSavePicker.PickSaveFileAsync(); MemoryStream exportFileStream = new MemoryStream(); Assembly assembly = typeof(HomePage).GetTypeInfo().Assembly; // Ensure the report loaction and application name. Stream reportStream = assembly.GetManifestResourceStream("UwpApp.Report.Inv.rdlc"); BoldReports.UI.Xaml.ReportDataSourceCollection datas = new BoldReports.UI.Xaml.ReportDataSourceCollection(); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "PatientInfo", Value = Reports.LoadReport() }); datas.Add(new BoldReports.UI.Xaml.ReportDataSource { Name = "MemoDetails", Value = Reports.loadmemodetail() }); ReportWriter writer = new ReportWriter(reportStream, datas); writer.ExportMode = ExportMode.Local; await writer.SaveASync(exportFileStream, format); try { using (IRandomAccessStream stream = await savedItem.OpenAsync(FileAccessMode.ReadWrite)) { // Write compressed data from memory to file using (Stream outstream = stream.AsStreamForWrite()) { byte[] buffer = exportFileStream.ToArray(); outstream.Write(buffer, 0, buffer.Length); outstream.Flush(); } } exportFileStream.Dispose(); } catch { } }
public void ExecuteTest() { var mergeOptions = new MergeOptions { InputFiles = new[] { @"TestFiles\TestFile1.xml", @"TestFiles\TestFile2.xml" }, OutputFile = "merged.xml", LogLevel = LogLevel.Trace, DisableSanitize = false }; var fileLoader = new FileLoader(new NullLogger <FileLoader>()); var reportSanitizer = new ReportSanitizer(new NullLogger <ReportSanitizer>()); var reportMerger = new ReportMerger(new NullLogger <ReportMerger>()); var reportCalculator = new ReportCalculator(new NullLogger <ReportCalculator>()); var reportWriter = new ReportWriter(new NullLogger <ReportWriter>()); var logger = new MessageLogger <Runner>(); var runner = new Runner(logger, fileLoader, reportSanitizer, reportMerger, reportCalculator, reportWriter); Assert.True(runner.Execute(mergeOptions.InputFiles, mergeOptions.OutputFile, mergeOptions.DisableSanitize)); Assert.Empty(logger.Messages); }
protected override void Process() { if (Options.ReportFileName != null) { ReportWriter.Write(Options.ReportFileName, Options.OptimizerReport); } }
public void Msbuild_ReportWriter(string coverletMultiTargetFrameworksCurrentTFM, string coverletOutput, string reportFormat, string expectedFileName) { Mock <IFileSystem> fileSystem = new Mock <IFileSystem>(); fileSystem.Setup(f => f.WriteAllText(It.IsAny <string>(), It.IsAny <string>())) .Callback((string path, string contents) => { // Path.Combine depends on OS so we can change only win side to avoid duplication Assert.Equal(path.Replace('/', Path.DirectorySeparatorChar), expectedFileName.Replace('/', Path.DirectorySeparatorChar)); }); Mock <IConsole> console = new Mock <IConsole>(); ReportWriter reportWriter = new ReportWriter( coverletMultiTargetFrameworksCurrentTFM, // mimic code inside CoverageResultTask.cs Path.GetDirectoryName(coverletOutput), coverletOutput, new ReporterFactory(reportFormat).CreateReporter(), fileSystem.Object, console.Object, new CoverageResult() { Modules = new Modules() }); reportWriter.WriteReport(); }
private void btnImport_Click(object sender, EventArgs e) { if (int.TryParse(txtPeriod.Text, out pastelPeriod) && pastelPeriod >= 1 && pastelPeriod <= 12 && !String.IsNullOrEmpty(txtFileName.Text)) { ReportWriter rw = new ReportWriter(); String errors = ""; List <Dictionary <String, String> > contents = rw.ExtractData(txtFileName.Text, out errors); lines = contents.Count; if (errors != "") { txtProgress.Text += errors + Environment.NewLine; } txtProgress.Text = "Starting processing" + Environment.NewLine; Application.DoEvents(); txtProgress.Text += lines.ToString() + " in Excel file" + Environment.NewLine; MessageBox.Show("Extract Completed"); Application.DoEvents(); ProcessContents(contents); txtProgress.Text += processedLines.ToString() + " processed" + Environment.NewLine; Application.DoEvents(); txtProgress.Text += "Completed" + Environment.NewLine; Application.DoEvents(); } else if (!int.TryParse(txtPeriod.Text, out pastelPeriod) || pastelPeriod < 1 || pastelPeriod > 12) { MessageBox.Show("Please enter a valid period"); } else { MessageBox.Show("Please select an Excel file!", "Imports"); } }
public FxdacSyntaxRewriter(ReportWriter reportWriter, SemanticModel model, string assembly) { _model = model; _assembly = assembly; _reportWriter = reportWriter; _undesiredDependencies = s_AssemblyToTypeDependenciesToRemove.Where(dep => dep.From == _assembly).Select(dep => dep.To).ToList(); }
private void btnExcel_Click(object sender, EventArgs e) { ReportWriter reporter = new ReportWriter(); String msg = ""; using (SaveFileDialog sfd = new SaveFileDialog()) { sfd.Filter = "Excel Files | *.xls"; if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK) { if (sfd.FileName != "" && sfd.FileName.EndsWith(".xls")) { reporter.CreateSummaryReport(summaries, sfd.FileName, out msg); if (msg != "Excel Report Saved") { MessageBox.Show(msg, "Report Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } else { MessageBox.Show(msg, "Report", MessageBoxButtons.OK, MessageBoxIcon.Information); } } } } }
/// <summary> /// Метод непосредственного создания отчета. /// </summary> public void MakeReport() { try { byte[] result = null; BuildTimer.Elapsed += (object source, ElapsedEventArgs e) => { if (!Canceled) { StopWorker(() => ReportWriter.ReportTimeout(Id)); } }; BuildTimer.Start(); result = ReportBuilder.Build(); if (!Canceled) { StopWorker(() => ReportWriter.ReportSuccess(result, Id)); } } catch (Exception ex) when(ex.Message == "Report failed") { if (!Canceled) { StopWorker(() => ReportWriter.ReportError(Id)); } } }
private static bool RefactorAssemblies(ReportWriter reportWriter, out FxRedist redist) { // prepare the right folders PrepareOutputFolder(s_OutputSources); PrepareOutputFolder(s_OutputDlls); // load files describing the desired factoring. verify consistency of these files. redist = new FxRedist(); if (!ProcessSpecifications(redist, reportWriter)) { Console.WriteLine("\nPress ENTER to exit ..."); Console.ReadLine(); return(false); } // compile master file reportWriter.WriteListStart("REMOVED"); AddSourcesToRedist(reportWriter, redist, s_MasterAPIFile); AddSourcesToRedist(reportWriter, redist, s_CoreFxAPIFile); reportWriter.WriteListEnd(); // generate and compile factored assemblies GenerateSources(redist); var successfulBuild = CompileAssemblies(redist); // warn about types that are not in any of the factored assemblies if (redist.Leftover.CountOfTypes > 0) { WriteMessage(ConsoleColor.Yellow, "\n{0} type[s] not assigned to an assembly", redist.Leftover.CountOfTypes); } return(successfulBuild); }
void ReportReader.WriteReports(ReportWriter reporter) { using (var builder = new BigEndianDataBuilder()) { var res = _client.SendRequestWithResponse(new Request(FUNCTION_READER_WRITE_REPORTS, builder.Add(reporter.ObjectId).Build(), _objectId)); } }
public XmlSerializer() { Configuration = new XmlSerializerConfiguration(); var xmlAttributeInterpreter = new XmlAttributeInterpreter(); reportReader = new ReportReader(new ContentReaderCollection(xmlAttributeInterpreter, Configuration.OnDeserialize)); reportWriter = new ReportWriter(new ContentWriterCollection(xmlAttributeInterpreter)); }
public void WriteReports(ReportWriter reporter) { if (!(reporter is RemoteObject ro)) { throw new ArgumentException("Can only use with remote objects."); } _client.SendRequestWithResponse(new Request(FUNCTION_READER_WRITE_REPORTS, BigEndianBitConverter.GetBytes(ro.ObjectId), _objectId)); }
public void writeServiceDirectory(Provider provider, List <ServiceReportItem> services) { string fileName = String.Format("ServiceDirectory_{0}_{1:MM-dd-yyyy}", provider.Name.Replace(" ", "-"), DateTime.Now); string filePath = System.Web.HttpContext.Current.Server.MapPath("~/Reports/" + fileName); DataTable dt = DataConversion.ToDataTable(services); //you can activate next line to do CSV file // ReportWriter.CreateCSVFile(dt, filePath + ".txt"); ReportWriter.CreateHtmlFile(dt, filePath + ".html"); }
static void Main(string[] args) { //RemoveSerialization(); if (args.Length > 0) { s_ExistingContracts = args[0]; } //s_ExistingContracts = @"C:\Users\Krzysztof\Desktop\ExistingContracts"; if (!Directory.Exists(s_ExistingContracts)) { WriteMessage(ConsoleColor.Red, "Existing contract folder {0} does not exist", s_ExistingContracts); } else { FxRedist redist; using (var reportWriter = new ReportWriter(s_ReportPath)) { if (RefactorAssemblies(reportWriter, out redist)) { if (s_ExistingContracts != null) { LocationAnalysis.CompareFactorings(s_ExistingContracts, s_OutputDlls, reportWriter); } } // Orphaned types are types in the specifications that don't exist in master source. PrintOrphanedTypes(redist, reportWriter); if (redist.Leftover.Count > 0) { reportWriter.WriteListStart("TYPES_NOT_IN_ANY_ASSEMBLY", "total", redist.Leftover.CountOfTypes, "description", "types that are not in specification files"); foreach (var ns in redist.Leftover) { var nsName = ns.Key; foreach (var type in ns.Value) { reportWriter.WriteListItem(type.Symbol.GetDocumentationCommentId().Substring(2)); } } reportWriter.WriteListEnd(); } AnalyzeLayers(redist, reportWriter); } } if (args.Length == 0) { Console.WriteLine("\nPress ENTER to exit ..."); Console.ReadLine(); } }
public void PrintOrder(MainViewModel model) { var reportStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("HillStationPOS.Reports.Order.rdlc"); var writer = new ReportWriter { ReportProcessingMode = ProcessingMode.Local }; writer.DataSources.Clear(); writer.DataSources.Add(new ReportDataSource { Name = "OrderItems", Value = model.OrderItems }); writer.LoadReport(reportStream); var parameters = new List<ReportParameter>(); foreach (var parameter in writer.GetParameters()) { var param = new ReportParameter { Prompt = parameter.Prompt, Name = parameter.Name }; switch (param.Name) { case "OrderNumber": param.Values.Add(model.OrderNumber); break; case "Address": param.Values.Add(model.Address); break; default: throw new InvalidEnumArgumentException(@"Invalid parameter name: " + param.Name); } parameters.Add(param); } writer.SetParameters(parameters); var stream = new MemoryStream(); writer.Save(@"D:\Documents\xxx.pdf", WriterFormat.PDF); writer.Save(stream, WriterFormat.PDF); var pdf = new PdfDocument(stream); var size = pdf.Pages[0].Size; var paper = new PaperSize("Custom", (int)size.Width, (int)size.Height) { RawKind = (int)PaperKind.Custom }; pdf.PageScaling = PdfPrintPageScaling.ActualSize; var printDocument = pdf.PrintDocument; // printDocument.PrinterSettings.Copies = 2; printDocument.DefaultPageSettings.PaperSize = paper; // printDocument.Print(); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); CommandExecutor commandExecutor = new CommandExecutor(Program.getClientUrlResponse(), EMAIL_ADRESS, TOKEN); ArcStateReceiver arcStateReceiver = new ArcStateReceiver(Program.getClientUrlRequest()); ReportWriter reportWriter = new ReportWriter(EMAIL_ADRESS, TOKEN); Application.Run(new MainView(commandExecutor, arcStateReceiver, reportWriter)); }
/** **************************************************************************************** * Sets a new writer. The actual writer is implemented as a stack. It is important to * keep the right order when pushing and popping writers, as there lifetime is externally * managed. (In standard use-cases, only one, app-specific writer should be pushed anyhow). * To give a little assurance, method #PopWriter takes the same parameter as this method * does, to verify if if the one to be removed is really the topmost. * * @param newWriter The writer to use. ******************************************************************************************/ public void PushWriter(ReportWriter newWriter) { try { Lock.Acquire(); if (writers.Count > 0) { writers.Peek().NotifyActivation(Phase.End); } writers.Push(newWriter); newWriter.NotifyActivation(Phase.Begin); } finally { Lock.Release(); } }
public StrictXmlSerializer() { var xmlAttributeInterpreter = new XmlAttributeInterpreter(); var onDeserializeConfiguration = new OnDeserializeConfiguration(); onDeserializeConfiguration.OnUnexpectedElement += OnUnexpectedElement; onDeserializeConfiguration.OnUnexpectedAttribute += OnUnexpectedAttribute; reportReader = new ReportReader(new ContentReaderCollection(xmlAttributeInterpreter, onDeserializeConfiguration)); reportWriter = new ReportWriter(new ContentWriterCollection(xmlAttributeInterpreter)); }
public MainView(CommandExecutor commandExecutor, ArcStateReceiver arcStateReceiver, ReportWriter reporter) { InitializeComponent(); this.commandExecutor = commandExecutor; this.arcStateReceiver = arcStateReceiver; this.reporter = reporter; resetSimulation(); currentState = arcStateReceiver.GetState(); updateViewArcState(currentState); }
// Autogenerated method // public static org.xdef.XDOutput createXDOutput(org.xdef.sys.ReportWriter); /// <summary>Creates XDOutput from reporter.</summary> /// <param name="value">the reporter.</param> /// <returns>the XDOutput object.</returns> public XDOutput CreateXDOutput(ReportWriter value) { using (var builder = new BigEndianDataBuilder()) { builder.Add(value.ObjectId); var res = SendRequestWithResponse(new Request(FUNCTION_CREATEXDOUTPUT_1, builder.Build(), ObjectId)); using (var reader = res.Reader) { return(new XDOutput(reader.ReadInt32(), _client)); } } }
public GenealogyOMatic(ILogger <GenealogyOMatic> logger, IConfiguration configuration, GEDLoader gedLoader, ReportWriter reportWriter) { _logger = logger; _configuration = configuration; _gedLoader = gedLoader; _reportWriter = reportWriter; InputFilename = configuration["GenealogyHelper:InputFilename"]; IndividualsOutputFilename = configuration["GenealogyHelper:IndividualsOutputFilename"]; EventsOutputFilename = configuration["GenealogyHelper:EventsOutputFilename"]; KeyIndividual = configuration["GenealogyHelper:KeyIndividual"]; }
// --------------------------------------------------------------------------------------------------------------- public bool CheckEntity(ProcessingFlags pProcessingFlags, string pNamePrinted = null) { string report; bool checkOk = CheckEntity(pProcessingFlags, out report); if (checkOk && pProcessingFlags.HasFlag(ProcessingFlags.JustReportIssues)) { return(false); } ReportWriter.WriteReportLineFeed($"{Name} : {report}"); return(checkOk); }
// Autogenerated method // public static org.xdef.XDDocument xparse(java.lang.String, org.xdef.sys.ReportWriter) throws org.xdef.sys.SRuntimeException; /// <summary>Parse XML with X-definition declared in source.</summary> /// <param name="source">URL, pathname direct to XML or direct XML.</param> /// <param name="reporter">used for error messages or <tt>null</tt>.</param> /// <returns>created XDDocument object.</returns> /// <exception cref="RemoteCallException">if an error occurs.</exception> public XDDocument Xparse(string source, ReportWriter reporter) { using (var builder = new BigEndianDataBuilder()) { builder.Add(source); builder.Add(reporter.ObjectId); var res = SendRequestWithResponse(new Request(FUNCTION_XPARSE_2, builder.Build(), ObjectId)); using (var reader = res.Reader) { return(new XDDocument(reader.ReadInt32(), _client)); } } }
// Autogenerated method // public static org.xdef.XDBuilder getXDBuilder(org.xdef.sys.ReportWriter, java.util.Properties); /// <summary>Creates instance of XDBuilder with properties.</summary> /// <param name="reporter">the ReportWriter to be used for error reporting.</param> /// <param name="props"> /// Properties or <tt>null</tt> - /// see /// <see cref="XDConstants"/> /// . /// </param> /// <returns>created XDBuilder.</returns> public XDBuilder GetXDBuilder(ReportWriter reporter, Utils.Properties props) { using (var builder = new BigEndianDataBuilder()) { builder.Add(reporter.ObjectId); builder.Add(props); var res = SendRequestWithResponse(new Request(FUNCTION_GETXDBUILDER_2, builder.Build(), ObjectId)); using (var reader = res.Reader) { return(new XDBuilder(reader.ReadInt32(), _client)); } } }
private string toPDF2(string auth1,string reportPath, string month) { //string reportPath = templatetxt.Text; ; WriterFormat format; string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); string fileName = @path + "\\Telephone Bill"+" "+auth1+".pdf"; format = WriterFormat.PDF; ReportWriter wrp = new ReportWriter(reportPath); wrp.SetParameters(this.GetParameter(auth1, month)); wrp.Save(fileName, format); return fileName; }
private string CommentFor(MethodDefinition m, ReportWriter format, List<Regex> reviewedMethods) { if (!MethodPrivilegeDetector.IsMethodSignatureSafe(m)) return "#methodsignature_notsafe"; string unavailablereason = null; bool criticaltype = false; if (_criticalTypes.Contains(m.DeclaringType)) { criticaltype = true; unavailablereason = format.PropagationGraphStringFor(new[] { new PropagationReasonIsInCriticalType(m) }); } else if (_canBeSscManual.Contains(m)) { return "#available_manualSSC"; } else if (_resultingSecurityCriticalMethods.Contains(m)) { if (_methodRequiringPrivilegesThemselves.Contains(m)) unavailablereason= "method itself requires privileges"; else unavailablereason = format.PropagationGraphStringFor(PropagationStackFor(m)); } if (unavailablereason!=null) { string prefix = "#unavailable_notreviewed "; if (criticaltype || reviewedMethods.Any(r => r.Match(m.ToString()).Success)) prefix = "#unavailable_butreviewed "; return prefix + " (ML: " + Moonlight.GetSecurityStatusFor(m) + ") " + unavailablereason; } return "#available"; }
/** **************************************************************************************** * Restores the previous writer after setting a new one using #PushWriter. * It is important to keep the right order when pushing and popping writers, as there * lifetime is externally managed. * (In standard use-cases, only one, app-specific writer should be pushed anyhow). * To give a little assurance, this method #PopWriter takes the same parameter as * #PushWriter does, to verify if the one to be removed is really the topmost. * * @param checkWriter The previously pushed writer (for checking of call order). ******************************************************************************************/ public void PopWriter( ReportWriter checkWriter ) { try { Lock.Acquire(); if ( writers.Count == 0 ) { ALIB.ERROR( "No Writer to remove" ); return; } if ( writers.Peek() != checkWriter ) { ALIB.ERROR( "Report Writer is not actual" ); return; } writers.Peek().NotifyActivation( Phase.End ); writers.Pop(); if ( writers.Count > 0 ) writers.Peek().NotifyActivation( Phase.Begin ); } finally { Lock.Release(); } }
/** **************************************************************************************** * Sets a new writer. The actual writer is implemented as a stack. It is important to * keep the right order when pushing and popping writers, as there lifetime is externally * managed. (In standard use-cases, only one, app-specific writer should be pushed anyhow). * To give a little assurance, method #PopWriter takes the same parameter as this method * does, to verify if if the one to be removed is really the topmost. * * @param newWriter The writer to use. ******************************************************************************************/ public void PushWriter( ReportWriter newWriter ) { try { Lock.Acquire(); if ( writers.Count > 0 ) writers.Peek().NotifyActivation( Phase.End ); writers.Push( newWriter ); newWriter.NotifyActivation( Phase.Begin ); } finally { Lock.Release(); } }
public void Arrange() { _visitor = new Visitor("SomeSessionId"); _repository = new VisitorsByDateRepository(); _reporter = new ReportWriter(_repository); }
public string BuildPublicApisReport(IEnumerable<MethodDefinition> candidates, List<Regex> reviewedMethods, ReportWriter format) { var report = SelectVisibleEntryPoints(candidates) .Select(m => new { Method = m, Comment = CommentFor(m, format, reviewedMethods) }).GroupBy(row => row.Comment) .OrderByDescending(g => g.Key) .SelectMany(g => g.OrderBy(row => row.Method.DeclaringType.FullName + row.Method.Name)); var writer = new StringWriter(); format.BeginReport(writer); foreach (var row in report) format.PublicMethod(writer, row.Method, row.Comment); format.EndReport(writer); return writer.ToString(); }
private void createReportToolStripMenuItem_Click(object sender, EventArgs e) { ListView.SelectedIndexCollection indexes = this.listViewHeap.SelectedIndices; if (indexes.Count == 0) { return; } else { Image3D Result = new Image3D(((Image3D)(this.listViewHeap.Items[indexes[0]].Tag)).Width, ((Image3D)(this.listViewHeap.Items[indexes[0]].Tag)).Height, ((Image3D)(this.listViewHeap.Items[indexes[0]].Tag)).Depth, ((Image3D)(this.listViewHeap.Items[indexes[0]].Tag)).NumBands); ReportWriter rw = new ReportWriter(); rw.create("tellme.xml"); rw.setInfo("First Report", "Don't know name", "Description", 5, 100); int indexesCount = indexes.Count; for (int i = 0; i < indexesCount; i++) { Image3D TmpIm = ((Image3D)(this.listViewHeap.Items[indexes[i]].Tag)); rw.addThumbnailImage(TmpIm, "Test" + i, "", "essai"); //rw.addThumbnailImage(TmpIm, "Test"+i, TmpIm.Name, "essai"); } rw.close(); } }
private void createReportToolStripMenuItem_Click_1(object sender, EventArgs e) { ListView.SelectedIndexCollection indexes = this.listViewHeap.SelectedIndices; int indexesCount = indexes.Count; if (indexesCount == 0) return; request RQuest = new request(); Control[] ButtonControl = RQuest.Controls.Find("buttonCreateGrid", false); ButtonControl[0].Text = "Create Report"; Control[] ButtonControl1 = RQuest.Controls.Find("label1", false); ButtonControl1[0].Text = "Zoom (%)"; ButtonControl = RQuest.Controls.Find("numericUpDownGridSize", false); NumericUpDown TmpNum = (NumericUpDown)ButtonControl[0]; TmpNum.Maximum = 100; TmpNum.Value = 100; ButtonControl = RQuest.Controls.Find("numericUpDownImPerLine", false); TmpNum = (NumericUpDown)ButtonControl[0]; TmpNum.Visible = true; TmpNum.Maximum = TmpNum.Value = indexesCount; ButtonControl = RQuest.Controls.Find("label2", false); System.Windows.Forms.Label Tmplabel = (System.Windows.Forms.Label)ButtonControl[0]; Tmplabel.Visible = true; if (RQuest.ShowDialog() != DialogResult.OK) { return; } string sTime = DateTime.Now.ToString("yyyy-MM-dd mm-ss"); ReportWriter rw = new ReportWriter(sTime); rw.create("HeapReport" + sTime + ".xml"); rw.setInfo("Image Heap Report", "Report" + sTime, "", (int)TmpNum.Value, (int)RQuest.numericUpDownGridSizeValue); for (int i = 0; i < indexesCount; i++) { Image3D TmpIm = ((Image3D)(this.listViewHeap.Items[indexes[i]].Tag)); rw.addThumbnailImage(TmpIm, "Index" + i, "Image " + i, UpdateInfoPicture(TmpIm)); } rw.close(); rw.openReport(); }