예제 #1
0
 private void AddReport(Menu menu)
 {
     try
     {
         menu.AddItem(new MenuItem(menu.Name + "Report", Global.Lang.Get("SFX_GenerateReport")).SetValue(false))
         .ValueChanged += delegate(object sender, OnValueChangeEventArgs args)
         {
             try
             {
                 if (!args.GetNewValue <bool>())
                 {
                     return;
                 }
                 Utility.DelayAction.Add(0, () => menu.Item(menu.Name + "Report").SetValue(false));
                 File.WriteAllText(
                     Path.Combine(Global.BaseDir, string.Format("{0}.report.txt", Global.Name.ToLower())),
                     GenerateReport.Generate());
                 Notifications.AddNotification(Global.Lang.Get("SFX_ReportGenerated"), 5000);
             }
             catch (Exception ex)
             {
                 Global.Logger.AddItem(new LogItem(ex));
             }
         };
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
예제 #2
0
 private void btnXRead_Click(object sender, EventArgs e)
 {
     if (GenerateReport.XRead(DateTime.Now))
     {
         FncFilter.Alert("X-Read Generation Success");
     }
 }
예제 #3
0
        public byte[] GenerateReport(GenerateReport generate)
        {
            var flaws  = _veracodeRepository.GetFlaws(generate.ScanId.ToString());
            var report = new Report
            {
                FlawsAndResponses = flaws.Select(_responseMapper.GetResponse).ToArray()
            };
            var xlsx = _outputWriter.Write(report);

            return(xlsx.ToArray());
        }
        public void GenerateReport_GivenValidReprotDetailsShouldReturnSuccess()
        {
            var request       = GetReportEventDto();
            var resultContent = new GenerateReport {
                FileName = request.FileName, Hash = "Hash"
            };

            ReportingBusiness.Setup(x => x.InsertAndTriggerGenerateReport(It.IsAny <ReportingEvent>())).Returns(Task.FromResult(resultContent));
            var generatedReport = EnrichedEventController.Generate(request).Result;

            AreEqual(((ObjectResult)generatedReport).StatusCode, 200);
        }
예제 #5
0
 private void btnZRead_Click(object sender, EventArgs e)
 {
     if (FncFilter.ConfirmYesNo(globalvariables.confirm_lock_pos))
     {
         GenerateReport.ZRead(DateTime.Now);
         globalvariables.LockedPOS = true;
         RefreshTransactionDetails();
     }
     else
     {
         return;
     }
 }
예제 #6
0
 private void btnZRead_Click(object sender, EventArgs e)
 {
     if (report.Date == DateTime.Now.Date && !globalvariables.LockedPOS)
     {
         if (FncFilter.ConfirmYesNo(globalvariables.confirm_lock_pos))
         {
             GenerateReport.ZRead(report.Date);
         }
     }
     else
     {
         report.Type = 3;
         HardwareHelper.PrintReport(null, null, null, report);
     }
     this.Close();
 }
예제 #7
0
        public HttpResponseMessage GetReportPdf(ReportFilterModel model)
        {
            try
            {
                var report = _reportService.GetReportById(model.ReportId);
                var data   = GetReportData(model);

                // report start


                var parameters = new List <ReportParameters>();


                parameters.Add(new ReportParameters()
                {
                    Key   = "CompanyName",
                    Value = ""
                });
                parameters.Add(new ReportParameters()
                {
                    Key   = "Title",
                    Value = report.Title
                });



                string fileName = GenerateReport.GetReportWithDs(report.PdfReportName, "Report", parameters, data);
                byte[] file     = System.IO.File.ReadAllBytes(HttpContext.Current.Server.MapPath("~/Report/") + fileName);
                var    response = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new ByteArrayContent(file)
                };
                response.Content.Headers.ContentType        = new MediaTypeHeaderValue("application/pdf");
                response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
                {
                    FileName = fileName
                };

                return(response);
            }
            catch (Exception ex)
            {
                var response = new HttpResponseMessage(HttpStatusCode.InternalServerError);
                return(response);
            }
        }
예제 #8
0
        static int Run(RunOptions options)
        {
            System.Console.WriteLine($"Starting report generation for app {options.AppId} and scan {options.ScanId}...");
            var reportGenerator = _serviceProvider.GetService <IReportGenerator>();
            var generateReport  = new GenerateReport
            {
                AppId  = options.AppId,
                ScanId = options.ScanId
            };
            var reportBytes = reportGenerator.GenerateZip(generateReport, options.Password);
            var reportName  = $"{options.Prefix}-{reportGenerator.ScanName(generateReport)}-{DateTime.Now.ToLongDateString()}";

            File.WriteAllBytes($"{options.FilePath}\\{reportName}.zip", reportBytes);
            System.Console.WriteLine($"The report is here: {options.FilePath}{reportName}.zip");
            System.Console.WriteLine($"Done!");
            return(1);
        }
예제 #9
0
        private string PrintData003()
        {
            var result = string.Empty;

            try
            {
                var report_condition = GetCondition();
                var oGenerateReport  = new GenerateReport <view_Budget_transfer_report>();
                var strFilename      = oGenerateReport.Retive_Rep_003(report_condition);
                result = strFilename;
            }
            catch (Exception ex)
            {
                lblError.Text = ex.Message;
            }
            return(result);
        }
예제 #10
0
        public byte[] GenerateFlawEmail(GenerateReport generate)
        {
            var flaws    = _veracodeRepository.GetFlaws(generate.ScanId.ToString());
            var app      = _veracodeRepository.GetAppDetail(generate.AppId);
            var build    = _veracodeRepository.GetBuildDetail(generate.AppId, generate.ScanId);
            var template = new FlawTemplate
            {
                app_name             = app.application[0].app_name,
                latest_scan_name     = build.build.version,
                latest_scan_date     = build.build.launch_date.ToLongDateString(),
                very_high_flaw_count = flaws.Count(x => x.severity.Equals("5") && x.remediation_status.ToLower().Equals("new")).ToString(),
                high_flaw_count      = flaws.Count(x => x.severity.Equals("4") && x.remediation_status.ToLower().Equals("new")).ToString(),
            };
            var emailTemplate    = _templateRepository.GetAll().Single(x => x.Title.Equals("email")).Text;
            var covertedTemplate = _templateWriter.Write(template, emailTemplate);

            return(Encoding.ASCII.GetBytes(covertedTemplate));
        }
예제 #11
0
        public static bool SendEmails(
            Config config,
            string htmlTemplateFileName,
            bool skipEmail,
            string outputHtmlFileName,
            IEnumerable <string> filteredAlertNames,
            GenerateReport generateReport)
        {
            AlertReport report = new AlertReport(
                config,
                htmlTemplateFileName,
                skipEmail,
                outputHtmlFileName,
                filteredAlertNames,
                generateReport);

            return(report.SendEmails());
        }
예제 #12
0
        public byte[] GenerateModulesEmail(GenerateReport generate)
        {
            var app               = _veracodeRepository.GetAppDetail(generate.AppId);
            var latestBuild       = _veracodeRepository.GetBuildDetail(generate.AppId, generate.ScanId);
            var latestEntryPoints = _veracodeRepository.GetEntryPoints(generate.ScanId);
            var latestModules     = _veracodeRepository
                                    .GetModules(generate.AppId, generate.ScanId)
                                    .Select(x => new
            {
                Name       = x.name,
                Checksum   = x.checksum,
                EntryPoint = latestEntryPoints.Any(y => y.name == x.name)
            });

            var previousBuilds = _veracodeRepository.GetAllBuildsForApp(generate.AppId)
                                 .OrderByDescending(x => x.build_id);
            var previousBuildId       = previousBuilds.Skip(1).Take(1).First().build_id;
            var previousEntryPoints   = _veracodeRepository.GetEntryPoints($"{previousBuildId}");
            var previousLatestModules = _veracodeRepository
                                        .GetModules(generate.AppId, $"{previousBuildId}")
                                        .Select(x => new
            {
                Name       = x.name,
                Checksum   = x.checksum,
                EntryPoint = latestEntryPoints.Any(y => y.name == x.name)
            });

            var missing = previousLatestModules.Where(x => !latestModules.Any(y => y.Name == x.Name));

            var template = new ModuleTemplate
            {
                app_name                      = app.application[0].app_name,
                latest_scan_name              = latestBuild.build.version,
                latest_scan_date              = latestBuild.build.launch_date.ToLongDateString(),
                latest_entry_points_count     = $"{latestModules.Where(x => x.EntryPoint).Count()}",
                list_all_latest_modules_count = $"{latestModules.Count()}",
                list_all_latest_modules       = string.Join("\n", latestModules.Select(x => $"{x.Name},EntryPoint={x.EntryPoint}").ToArray()),
                missing_from_previous_scan    = string.Join("\n", missing.Select(x => $"{x.Name},EntryPoint={x.EntryPoint}").ToArray()),
            };
            var emailTemplate    = _templateRepository.GetAll().Single(x => x.Title.Equals("modules")).Text;
            var covertedTemplate = _templateWriter.Write(template, emailTemplate);

            return(Encoding.ASCII.GetBytes(covertedTemplate));
        }
예제 #13
0
        public byte[] GenerateBinariesEmail(GenerateReport generate)
        {
            var app             = _veracodeRepository.GetAppDetail(generate.AppId);
            var latestbuild     = _veracodeRepository.GetBuildDetail(generate.AppId, generate.ScanId);
            var latestFiles     = _veracodeRepository.GetFilesForBuild(generate.AppId, generate.ScanId);
            var previousBuildId = _veracodeRepository.GetAllBuildsForApp(generate.AppId)
                                  .OrderByDescending(x => x.build_id)
                                  .Skip(1).Take(1);
            var previousFiles       = _veracodeRepository.GetFilesForBuild(generate.AppId, $"{previousBuildId}");
            var previous11BuildList = _veracodeRepository.GetAllBuildsForApp(generate.AppId)
                                      .OrderByDescending(x => x.build_id)
                                      .Skip(1).Take(11);
            List <FileListFileType> previousFilesLast12 = new List <FileListFileType>();

            var addedFromLastScan    = latestFiles.Where(x => !previousFiles.Any(y => y.file_name == x.file_name));
            var removedFromLastScan  = previousFiles.Where(x => !latestFiles.Any(y => y.file_name == x.file_name));
            var modifiedFromLastScan = previousFiles.Where(x => latestFiles.Any(y => y.file_name == x.file_name && x.file_md5 != y.file_md5));

            foreach (var build in previous11BuildList)
            {
                var buildFiles = _veracodeRepository.GetFilesForBuild(generate.AppId, $"{build.build_id}");
                previousFilesLast12.AddRange(buildFiles);
            }

            var missing = previousFilesLast12.Where(x => !latestFiles.Any(y => y.file_name == x.file_name));

            var template = new BinaryTemplate
            {
                app_name                  = app.application[0].app_name,
                latest_scan_name          = latestbuild.build.version,
                latest_scan_date          = latestbuild.build.launch_date.ToLongDateString(),
                list_latest_file_uploads  = string.Join("\n", latestFiles.Select(x => x.file_name).ToArray()),
                latest_file_uploads_count = $"{latestFiles.Count()}",
                previous_file_uploads_from_last_12_scans_missing = string.Join("\n", missing.Select(x => x.file_name).ToArray()),
                added_files_from_last_scan   = string.Join("\n", addedFromLastScan.Select(x => x.file_name).ToArray()),
                removed_files_from_last_scan = string.Join("\n", removedFromLastScan.Select(x => x.file_name).ToArray()),
                changed_files_from_last_scan = string.Join("\n", modifiedFromLastScan.Select(x => x.file_name).ToArray())
            };
            var emailTemplate    = _templateRepository.GetAll().Single(x => x.Title.Equals("binaries")).Text;
            var covertedTemplate = _templateWriter.Write(template, emailTemplate);

            return(Encoding.ASCII.GetBytes(covertedTemplate));
        }
예제 #14
0
        public byte[] GenerateSupportingEmail(GenerateReport generate)
        {
            var app      = _veracodeRepository.GetAppDetail(generate.AppId);
            var modules  = _veracodeRepository.GetModules(generate.AppId, generate.ScanId);
            var build    = _veracodeRepository.GetBuildDetail(generate.AppId, generate.ScanId);
            var errors   = modules.SelectMany(x => x.file_issue.Select(f => $"{f.filename}:{f.details}").ToArray());
            var errorStr = string.Join("\n", errors);

            var template = new SupportingTemplate
            {
                app_name         = app.application[0].app_name,
                latest_scan_name = build.build.version,
                latest_scan_date = build.build.launch_date.ToLongDateString(),
                list_missing_supporting_files  = errorStr,
                count_missing_supporting_files = $"{errors.Count()}"
            };
            var emailTemplate    = _templateRepository.GetAll().Single(x => x.Title.Equals("supporting_files")).Text;
            var covertedTemplate = _templateWriter.Write(template, emailTemplate);

            return(Encoding.ASCII.GetBytes(covertedTemplate));
        }
        public async Task <ActionResult <GenerateReport.Result> > Generate(string ipdomain, CancellationToken cancellationToken)//, [FromBody] List<string> sources = null)
        {
            // TODO: attach fluentvalidation to mediatr to automatically validate at command
            if (!GenerateReport.Validate(ipdomain, null))// sources))
            {
                return(this.BadRequest());
            }

            try
            {
                var command = new GenerateReport(ipdomain, null);// sources);
                var report  = await command.Execute(this.reportService);

                return(report);
            }
            catch (Exception ex)
            {
                // TODO: too generic! handle exception better
                this.logger.LogCritical(ex.Message);
                return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
            }
        }
예제 #16
0
        static void Main()
        {
            if (!mutex.WaitOne(TimeSpan.FromSeconds(1), false))
            {
                MessageBox.Show("Application is already running!", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Helpers.DataBaseHelper.CreateDatabase();

            Application.ThreadException += Application_ThreadException;

            if (!ConfigGetter.GetConfigDetails())
            {
                MessageBox.Show("[Config Getter] Unable to load configuration details.");
                return;
            }
            GenerateReport.GenerateUngeneratedReport();
            Application.Run(new MainForm());
            mutex.ReleaseMutex();
        }
예제 #17
0
        private AlertReport(
            Config config,
            string htmlTemplateFileName,
            bool skipEmail,
            string outputHtmlFileName,
            IEnumerable <string> filteredAlertNames,
            GenerateReport generateReport)
        {
            _config = config;

            _htmlTemplateFileName = htmlTemplateFileName;
            _skipEmail            = skipEmail;
            _outputHtmlFileName   = outputHtmlFileName;
            _filteredAlertNames   = filteredAlertNames;
            _generateReport       = generateReport;

            // Environment variable override of sending emails
            string sendEmailEnvironmentVariable = Environment.GetEnvironmentVariable("SEND_EMAIL");

            if (sendEmailEnvironmentVariable == "0")
            {
                _skipEmail = true;
            }
        }
예제 #18
0
        public static void AddToMenu(Menu menu, List <Wrappers.Spell> spells)
        {
            try
            {
                _menu = menu.AddSubMenu(new Menu("Debug", menu.Name + ".debug"));

                if (spells.All(s => s == null || s.Slot == SpellSlot.Unknown))
                {
                    return;
                }

                foreach (var spell in spells.Where(s => s != null && s.Slot != SpellSlot.Unknown))
                {
                    var lSpell   = spell;
                    var range    = spell.Range;
                    var width    = spell.Width;
                    var delay    = spell.Delay;
                    var speed    = spell.Speed;
                    var duration = spell.ChargeDuration;
                    var minRange = spell.ChargedMinRange;
                    var maxRange = spell.ChargedMaxRange;

                    DefaultSpells[spell] = new Spell(spell.Slot, spell.Range)
                    {
                        Range           = range,
                        Width           = width,
                        Delay           = delay,
                        Speed           = speed,
                        ChargeDuration  = duration,
                        ChargedMinRange = minRange,
                        ChargedMaxRange = maxRange
                    };

                    var spellMenu =
                        _menu.AddSubMenu(
                            new Menu(spell.Slot.ToString(), _menu.Name + ObjectManager.Player.ChampionName + spell.Slot));

                    if (Math.Abs(range - float.MaxValue) > 1 && range > 0)
                    {
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".range", "Range").SetValue(
                                new Slider(
                                    (int)range, (int)(range * MinMultiplicator), (int)(range * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.Range = args.GetNewValue <Slider>().Value;
                        };
                        spell.Range = _menu.Item(spellMenu.Name + ".range").GetValue <Slider>().Value;
                    }

                    if (Math.Abs(width - float.MaxValue) > 1 && width > 0)
                    {
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".width", "Width").SetValue(
                                new Slider(
                                    (int)width, (int)(width * MinMultiplicator), (int)(width * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.Width = args.GetNewValue <Slider>().Value;
                        };
                        spell.Width = _menu.Item(spellMenu.Name + ".width").GetValue <Slider>().Value;
                    }

                    if (Math.Abs(speed - float.MaxValue) > 1 && speed > 0)
                    {
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".speed", "Speed").SetValue(
                                new Slider(
                                    (int)speed, (int)(speed * MinMultiplicator), (int)(speed * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.Speed = args.GetNewValue <Slider>().Value;
                        };
                        spell.Speed = _menu.Item(spellMenu.Name + ".speed").GetValue <Slider>().Value;
                    }

                    spellMenu.AddItem(
                        new MenuItem(spellMenu.Name + ".delay", "Delay").SetValue(
                            new Slider(
                                (int)(delay * 1000), 0, (int)((delay > 1 ? delay * MaxMultiplicator : 1) * 1000)))
                        .DontSave()).ValueChanged +=
                        delegate(object sender, OnValueChangeEventArgs args)
                    {
                        lSpell.Delay = args.GetNewValue <Slider>().Value / 1000f;
                    };
                    spell.Delay = _menu.Item(spellMenu.Name + ".delay").GetValue <Slider>().Value / 1000f;

                    if (spell.IsChargedSpell)
                    {
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".duration", "Duration").SetValue(
                                new Slider(
                                    duration, (int)(duration * MinMultiplicator), (int)(duration * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.ChargeDuration = args.GetNewValue <Slider>().Value;
                        };
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".min-range", "Min. Range").SetValue(
                                new Slider(
                                    minRange, (int)(minRange * MinMultiplicator), (int)(minRange * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.ChargedMinRange = args.GetNewValue <Slider>().Value;
                        };
                        spellMenu.AddItem(
                            new MenuItem(spellMenu.Name + ".max-range", "Max. Range").SetValue(
                                new Slider(
                                    maxRange, (int)(maxRange * MinMultiplicator), (int)(maxRange * MaxMultiplicator)))
                            .DontSave()).ValueChanged +=
                            delegate(object sender, OnValueChangeEventArgs args)
                        {
                            lSpell.ChargedMaxRange = args.GetNewValue <Slider>().Value;
                        };

                        spell.ChargeDuration  = _menu.Item(spellMenu.Name + ".duration").GetValue <Slider>().Value;
                        spell.ChargedMinRange = _menu.Item(spellMenu.Name + ".min-range").GetValue <Slider>().Value;
                        spell.ChargedMaxRange = _menu.Item(spellMenu.Name + ".max-range").GetValue <Slider>().Value;
                    }
                }

                _menu.AddItem(new MenuItem(_menu.Name + ".tick", "Tick").SetValue(new Slider(50, 1, 300))).ValueChanged
                    +=
                        delegate(object sender, OnValueChangeEventArgs args)
                    {
                    Core.SetInterval(args.GetNewValue <Slider>().Value);
                    };
                Core.SetInterval(_menu.Item(_menu.Name + ".tick").GetValue <Slider>().Value);

                _menu.AddItem(new MenuItem(_menu.Name + ".reset", "Reset").SetValue(false).DontSave()).ValueChanged +=
                    delegate(object sender, OnValueChangeEventArgs args)
                {
                    try
                    {
                        if (args.GetNewValue <bool>())
                        {
                            Utility.DelayAction.Add(0, () => _menu.Item(_menu.Name + ".reset").SetValue(false));
                            foreach (var entry in DefaultSpells)
                            {
                                entry.Key.Range           = entry.Value.Range;
                                entry.Key.Width           = entry.Value.Width;
                                entry.Key.Delay           = entry.Value.Delay;
                                entry.Key.Speed           = entry.Value.Speed;
                                entry.Key.ChargeDuration  = entry.Value.ChargeDuration;
                                entry.Key.ChargedMinRange = entry.Value.ChargedMinRange;
                                entry.Key.ChargedMaxRange = entry.Value.ChargedMaxRange;

                                var name = _menu.Name + ObjectManager.Player.ChampionName + entry.Key.Slot;
                                if (Math.Abs(entry.Key.Range - float.MaxValue) > 1 && entry.Key.Range > 0)
                                {
                                    _menu.Item(name + ".range")
                                    .SetValue(
                                        new Slider(
                                            (int)entry.Key.Range, (int)(entry.Key.Range * MinMultiplicator),
                                            (int)(entry.Key.Range * MaxMultiplicator)));
                                }
                                if (Math.Abs(entry.Key.Speed - float.MaxValue) > 1 && entry.Key.Speed > 0)
                                {
                                    _menu.Item(name + ".speed")
                                    .SetValue(
                                        new Slider(
                                            (int)entry.Key.Speed, (int)(entry.Key.Speed * MinMultiplicator),
                                            (int)(entry.Key.Speed * MaxMultiplicator)));
                                }
                                if (Math.Abs(entry.Key.Width - float.MaxValue) > 1 && entry.Key.Width > 0)
                                {
                                    _menu.Item(name + ".width")
                                    .SetValue(
                                        new Slider(
                                            (int)entry.Key.Width, (int)(entry.Key.Width * MinMultiplicator),
                                            (int)(entry.Key.Width * MaxMultiplicator)));
                                }
                                _menu.Item(name + ".delay")
                                .SetValue(
                                    new Slider(
                                        (int)(entry.Key.Delay * 1000), 0,
                                        (int)
                                        ((entry.Key.Delay > 1 ? entry.Key.Delay * MaxMultiplicator : 1) *
                                         1000)));

                                if (entry.Key.IsChargedSpell)
                                {
                                    _menu.Item(name + ".duration")
                                    .SetValue(
                                        new Slider(
                                            entry.Key.ChargeDuration,
                                            (int)(entry.Key.ChargeDuration * MinMultiplicator),
                                            (int)(entry.Key.ChargeDuration * MaxMultiplicator)));
                                    _menu.Item(name + ".min-range")
                                    .SetValue(
                                        new Slider(
                                            entry.Key.ChargedMinRange,
                                            (int)(entry.Key.ChargedMinRange * MinMultiplicator),
                                            (int)(entry.Key.ChargedMinRange * MaxMultiplicator)));
                                    _menu.Item(name + ".max-range")
                                    .SetValue(
                                        new Slider(
                                            entry.Key.ChargedMaxRange,
                                            (int)(entry.Key.ChargedMaxRange * MinMultiplicator),
                                            (int)(entry.Key.ChargedMaxRange * MaxMultiplicator)));
                                }
                            }

                            _menu.Item(_menu.Name + ".tick").SetValue(new Slider(50, 1, 300));
                        }
                    }
                    catch (Exception ex)
                    {
                        Global.Logger.AddItem(new LogItem(ex));
                    }
                };

                _menu.AddItem(new MenuItem(_menu.Name + ".report", "Generate Report").SetValue(false)).ValueChanged +=
                    delegate(object sender, OnValueChangeEventArgs args)
                {
                    try
                    {
                        if (!args.GetNewValue <bool>())
                        {
                            return;
                        }
                        Utility.DelayAction.Add(0, () => _menu.Item(_menu.Name + ".report").SetValue(false));
                        File.WriteAllText(
                            Path.Combine(Global.BaseDir, string.Format("{0}.report.txt", Global.Name.ToLower())),
                            GenerateReport.Generate());
                        Notifications.AddNotification("Report Generated", 5000);
                    }
                    catch (Exception ex)
                    {
                        Global.Logger.AddItem(new LogItem(ex));
                    }
                };
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
예제 #19
0
 public HSBReportController()
 {
     objReport = new GenerateReport();
 }
예제 #20
0
        static void Main(string[] args)
        {
            //ExStart:ApplyingLicense

            /**
             *  Applying product license
             *  Please uncomment the statement if you do have license.
             */
            CommonUtilities.ApplyLicense();

            //ExEnd:ApplyingLicense

            #region Change Target File Format

            //Change target file format using the file extension
            //GenerateReport.ChangeTargetFileFormat();

            //Change target file format using explicit specifying
            //GenerateReport.ChangeTargetFileFormatUsingExplicitSpecifying();
            #endregion

            #region Generating Bubble Chart Report
            //Generate a bubble chart report in document processing format
            //GenerateReport.GenerateBubbleChart("document", false, false, false, true);

            //Generate a Bulleted List report in spreadsheet format
            //GenerateReport.GenerateBubbleChart("spreadsheet", false, false, false, true);

            //Generate a Bulleted List report in presentation format
            //GenerateReport.GenerateBubbleChart("presentation", false, false, false, true);

            //Generate a Bubble chart report in email format
            //GenerateReport.GenerateBubbleChart("email", false, false, false, false);

            #endregion

            #region Generating Bulleted List Report
            //Generate a Bulleted List report in document processing format
            //GenerateReport.GenerateBulletedList("document", false, false, true, false);

            //Generate a Bulleted List report in spreadsheet format
            //GenerateReport.GenerateBulletedList("spreadsheet", false, false, true, false);

            //Generate a Bulleted List report in presentation format
            //GenerateReport.GenerateBulletedList("presentation", false, false, true, false);

            //Generate a Bulleted List report in html format
            //GenerateReport.GenerateBulletedList("html", false, false, false, false);

            //Generate a Bulleted List report in text format
            //GenerateReport.GenerateBulletedList("text", false, false, false, false);

            //Generate a Bulleted List report in email format
            //GenerateReport.GenerateBulletedList("email", false, false, false, false);
            #endregion

            #region Generating Chart report with Filtering, Grouping, and Ordering
            //Generate a Chart report with Filtering, Grouping, and Ordering in document processing format
            //GenerateReport.GenerateChartWithFilteringGroupingAndOrdering("document", false, false, true, false);

            //Generate a Chart report with Filtering, Grouping, and Ordering in spreadsheet format
            //GenerateReport.GenerateChartWithFilteringGroupingAndOrdering("spreadsheet", false, false, false, true);

            //Generate a Chart report with Filtering, Grouping, and Ordering in presentation format
            //GenerateReport.GenerateChartWithFilteringGroupingAndOrdering("presentation", false, false, false, true);

            //Generate a Chart report with Filtering, Grouping, and Ordering in email format
            //GenerateReport.GenerateChartWithFilteringGroupingAndOrdering("email", false, false, false, false);
            #endregion

            #region Generating Common List Report
            //Generate a Common List Report in document processing format
            //GenerateReport.GenerateCommonList("document", false, false, true, false);

            //Generate a Common List Report in spreadsheet format
            //GenerateReport.GenerateCommonList("spreadsheet", false, false, true, false);

            //Generate a Common List Report in presentation format
            //GenerateReport.GenerateCommonList("presentation", false, false, true, false);

            //Generate a Common List Report in html format
            //GenerateReport.GenerateCommonList("html", false, false, false, false);

            //Generate a Common List Report in text format
            //GenerateReport.GenerateCommonList("text", false, false, false, false);

            //Generate a Common List Report in email format
            //GenerateReport.GenerateCommonList("email", false, false, false, false);
            #endregion

            #region Generating Common Master-Detail Report
            //Generate a Common Master-Detail Report in document processing format
            //GenerateReport.GenerateCommonMasterDetail("document", false, false, false, true);

            //Generate a Common Master-Detail Report in spreadsheet format
            //GenerateReport.GenerateCommonMasterDetail("spreadsheet", false, false, false, true);

            //Generate a Common Master-Detail Report in presentation format
            //GenerateReport.GenerateCommonMasterDetail("presentation", false, false, false, true);

            //Generate a Common Master-Detail Report in html format
            //GenerateReport.GenerateCommonMasterDetail("html", false, false, false, false);

            //Generate a Common Master-Detail Report in text format
            //GenerateReport.GenerateCommonMasterDetail("text", false, false, false, false);

            //Generate a Common Master-Detail Report in email format
            //GenerateReport.GenerateCommonMasterDetail("email", false, false, false, false);

            #endregion

            #region Generating In-Paragraph List Report
            //Generate an In-Paragraph List Report in document processing format
            //GenerateReport.GenerateInParagraphList("document", false, false, false, true);

            //Generate an In-Paragraph List Report in spreadsheet format
            //GenerateReport.GenerateInParagraphList("spreadsheet", false, false, false, true);

            //Generate an In-Paragraph List Report in presentation format
            //GenerateReport.GenerateInParagraphList("presentation", false, false, false, true);

            //Generate an In-Paragraph List Report in html format
            //GenerateReport.GenerateInParagraphList("html", false, false, false, false);

            //Generate an In-Paragraph List Report in text format
            //GenerateReport.GenerateInParagraphList("text", false, false, false, false);

            //Generate an In-Paragraph List Report in email format
            //GenerateReport.GenerateInParagraphList("email", false, false, false, false);
            #endregion

            #region Generating In-Table with Alternate Content Report
            //Generate an In-Table List with Alternate Content Report in document processing format
            //GenerateReport.GenerateInTableListWithAlternateContent("document", false, false, false, true);

            //Generate an In-Table List with Alternate Content Report in spreadsheet format
            //GenerateReport.GenerateInTableListWithAlternateContent("spreadsheet", false, false, false, true);

            //Generate an In-Table List with Alternate Content Report in presentation format
            //GenerateReport.GenerateInTableListWithAlternateContent("presentation", false, false, false, true);

            //Generate an In-Table List with Alternate Content Report in html format
            //GenerateReport.GenerateInTableListWithAlternateContent("html", false, false, false, false);

            //Generate an In-Table List with Alternate Content Report in email format
            //GenerateReport.GenerateInTableListWithAlternateContent("email", false, false, false, false);

            #endregion

            #region Generating In-Table with Filtering, Grouping and Ordering Report
            //Generate an In-Table List with Filtering, Grouping, and Ordering Report in document processing format
            //GenerateReport.GenerateInTableListWithFilteringGroupingAndOrdering("document", false, false, false, true);

            //Generate an In-Table List with Filtering, Grouping, and Ordering Report in spreadsheet format
            //GenerateReport.GenerateInTableListWithFilteringGroupingAndOrdering("spreadsheet", false, false, false, true);

            //Generate an In-Table List with Filtering, Grouping, and Ordering Report in presentation format
            //GenerateReport.GenerateInTableListWithFilteringGroupingAndOrdering("presentation", false, false, false, true);

            //Generate an In-Table List with Filtering, Grouping, and Ordering Report in html format
            //GenerateReport.GenerateInTableListWithFilteringGroupingAndOrdering("html", false, false, false, false);

            //Generate an In-Table List with Filtering, Grouping, and Ordering Report in email format
            //GenerateReport.GenerateInTableListWithFilteringGroupingAndOrdering("email", false, false, false, false);
            #endregion

            #region Generating In-Table List with Highlighted Rows Report
            //Generate an In-Table List with Highlighted Rows Report in document processing format
            //GenerateReport.GenerateInTableListWithHighlightedRows("document", false, false, false, true);

            //Generate an In-Table List with Highlighted Rows Report in spreadsheet format
            //GenerateReport.GenerateInTableListWithHighlightedRows("spreadsheet", false, false, false, true);

            //Generate an In-Table List with Highlighted Rows Report in presentation format
            //GenerateReport.GenerateInTableListWithHighlightedRows("presentation", false, false, false, true);

            //Generate an In-Table List with Highlighted Rows Report in html format
            //GenerateReport.GenerateInTableListWithHighlightedRows("html", false, false, false, false);

            //Generate an In-Table List with Highlighted Rows Report in email format
            //GenerateReport.GenerateInTableListWithHighlightedRows("email", false, false, false, false);


            #endregion

            #region Generating In-Table List Report
            //Generate an In-Table List Report in document processing format
            //GenerateReport.GenerateInTableList("document", false, false, false, true);

            //Generate an In-Table List Report in spreadsheet format
            //GenerateReport.GenerateInTableList("spreadsheet", false, false, false, true);

            //Generate an In-Table List Report in presentation format
            //GenerateReport.GenerateInTableList("presentation", false, false, false, true);

            //Generate an In-Table List Report in html format
            //GenerateReport.GenerateInTableList("html", false, false, false, false);

            //Generate an In-Table List Report in email format
            //GenerateReport.GenerateInTableList("email", false, false, false, false);
            #endregion

            #region Generating In-Table Master-Detail Report
            //Generate an In-Table Master-Detail Report in document processing format
            //GenerateReport.GenerateInTableMasterDetail("document", false, false, false, true);

            //Generate an In-Table Master-Detail Report in spreadsheet format
            //GenerateReport.GenerateInTableMasterDetail("spreadsheet", false, false, false, true);

            //Generate an In-Table Master-Detail Report in presentation format
            //GenerateReport.GenerateInTableMasterDetail("presentation", false, false, false, true);

            //Generate an In-Table Master-Detail Report in html format
            //GenerateReport.GenerateInTableMasterDetail("html", false, false, false, false);

            //Generate an In-Table Master-Detail Report in email format
            //GenerateReport.GenerateInTableMasterDetail("email", false, false, false, false);
            #endregion

            #region Generating In-Table with Running (Progressive) Total Report
            //Generate an In-Table List with Running (Progressive) Total Report in document processing format
            //GenerateReport.GenerateInTableListWithProgressiveTotal("document", false, false, false, false);

            //Generate an In-Table List with Running (Progressive) Total Report in spreadsheet format
            //GenerateReport.GenerateInTableListWithProgressiveTotal("spreadsheet", false, false, false, false);

            //Generate an In-Table List with Running (Progressive) Total Report in presentation format
            //GenerateReport.GenerateInTableListWithProgressiveTotal("presentation", false, false, false, false);

            //Generate an In-Table List with Running (Progressive) Total Report in html format
            //GenerateReport.GenerateInTableListWithProgressiveTotal("html", false, false, false, false);

            //Generate an In-Table List with Running (Progressive) Total Report in email format
            //GenerateReport.GenerateInTableListWithProgressiveTotal("email", false, false, false, false);
            #endregion

            #region Generating Multicolored Number List Report
            //Generate a Multicolored Numbered List Report in document processing format
            //GenerateReport.GenerateMulticoloredNumberedList("document", false, false, false, true);

            //Generate a Multicolored Numbered List Report in spreadsheet format
            //GenerateReport.GenerateMulticoloredNumberedList("spreadsheet", false, false, false, true);

            //Generate a Multicolored Numbered List Report in presentation format
            //GenerateReport.GenerateMulticoloredNumberedList("presentation", false, false, false, true);

            //Generate a Multicolored Numbered List Report in html format
            //GenerateReport.GenerateMulticoloredNumberedList("html", false, false, false, false);

            //Generate a Multicolored Numbered List Report in email format
            //GenerateReport.GenerateMulticoloredNumberedList("email", false, false, false, false);
            #endregion

            #region Generating Numbered List Report
            //Generate a Numbered List Report in document processing format
            //GenerateReport.GenerateNumberedList("document", false, false, false, true);

            //Generate a Numbered List Report in spreadsheet format
            //GenerateReport.GenerateNumberedList("spreadsheet", false, false, false, true);

            //Generate a Numbered List Report in presentation format
            //GenerateReport.GenerateNumberedList("presentation", false, false, false, true);

            //Generate a Numbered List Report in html format
            //GenerateReport.GenerateNumberedList("html", false, false, false, false);

            //Generate a Numbered List Report in text format
            //GenerateReport.GenerateNumberedList("text", false, false, false, false);

            //Generate a Numbered List Report in email format
            //GenerateReport.GenerateNumberedList("email", false, false, false, false);

            //Generate a Nested Numbered List Report with restartNum in Documents
            //GenerateReport.GenerateNumberedListRestartNum_Documents();

            //Generate a Nested Numbered List Report with restartNum in Emails
            //GenerateReport.GenerateNumberedListRestartNum_Email();

            #endregion

            #region Generating Pie Chart Report
            //Generate a Pie Chart Report in document processing format
            //GenerateReport.GeneratePieChart("document", false, false, false, true);

            //Generate a Pie Chart Report in spreadsheet format
            //GenerateReport.GeneratePieChart("spreadsheet", false, false, false, true);

            //Generate a Pie Chart Report in presentation format
            //GenerateReport.GeneratePieChart("presentation", false, false, true, false);

            //Generate a Pie Chart Report in email format
            //GenerateReport.GeneratePieChart("email", false, false, false, false);
            #endregion

            #region Generating Scatter Chart Report
            //Generate a Scatter Chart Report in document processing format
            //GenerateReport.GenerateScatterChart("document", false, false, false, true);

            //Generate a Scatter Chart Report in spreadsheet format
            //GenerateReport.GenerateScatterChart("spreadsheet", false, false, false, true);

            //Generate a Scatter Chart Report in presentation format
            //GenerateReport.GenerateScatterChart("presentation", false, false, false, true);

            //Generate a Scatter Chart Report in email format
            //GenerateReport.GenerateScatterChart("email", false, false, false, false);
            #endregion

            #region Generating Single Row Report
            //Generate a Single Row Report in document processing format
            //GenerateReport.GenerateSingleRow("document", false, false, false, false);

            //Generate a Single Row Report in spreadsheet format
            //GenerateReport.GenerateSingleRow("spreadsheet", false, false, false, true);

            //Generate a Single Row Report in presentation format
            //GenerateReport.GenerateSingleRow("presentation", false, false, false, true);

            //Generate a Single Row Report in html format
            //GenerateReport.GenerateSingleRow("html", false, false, false, false);

            //Generate a Single Row Report in text format
            //GenerateReport.GenerateSingleRow("text", false, false, false, false);

            //Generate a Single Row Report in email format
            //GenerateReport.GenerateSingleRow("email", false, false, false, false);
            #endregion

            #region Generating Report by Recursively and Lazily Accessing the Data
            //GenerateReport.GenerateReportLazilyAndRecursively();
            #endregion

            #region Generating Report using Multiple DataSources
            //Generate a report using multiple data sources in document processing format
            //GenerateReport.GenerateReportUsingMultipleDS("document");
            //Generate a report using multiple data sources in spreadsheet format
            //GenerateReport.GenerateReportUsingMultipleDS("spreadsheet");
            //Generate a report using multiple data sources in presentation format
            //GenerateReport.GenerateReportUsingMultipleDS("presentation");
            #endregion

            #region Template Syntax Formatting

            //Generate document processing formatted reports with desired string or numeric format
            //GenerateReport.TemplateSyntaxFormatting();

            #endregion

            #region Insert Outer Documents

            //Outer document insertion in a report
            //GenerateReport.OuterDocumentInsertion();

            //Insert nested external output documents in word
            //GenerateReport.InsertNestedExternalDocumentsInWord();

            //Insert nested external output documents in email
            //GenerateReport.InsertNestedExternalDocumentsInEmail();

            #endregion

            #region Barcode Insertion

            //add barcode in word processing documents
            //GenerateReport.AddBarCodes("document");
            //add barcode in spreadsheet documents
            //GenerateReport.AddBarCodes("spreadsheet");
            //add barcode in persentation documents
            //GenerateReport.AddBarCodes("presentation");

            #endregion

            #region Ability to remove selective chart series
            // GenerateReport.RemoveSelectiveChartSeries();
            #endregion

            #region Dynamic Chart Axis Title
            //Dynamic Chart Axis Title in Word Document
            //GenerateReport.DynamicChartAxisTitle();
            //Dynamic Chart Axis Title in Presentation Document
            //GenerateReport.DynamicChartAxisTitlePPt();
            //Dynamic Chart Axis Title in Spreadsheet Document
            //GenerateReport.DynamicChartAxisTitleSpreadSheet();
            //Dynamic Chart Axis Title in Presentation Document
            //GenerateReport.DynamicChartAxisTitleEmail();
            #endregion

            #region Dynamic Color
            //GenerateReport.DynamicColor();
            // Sets colors of chart series dynamically based upon expressions wordprocessing document
            //GenerateReport.DynamicChartSeriesColor();
            // Sets colors of chart series dynamically based upon expressions spreadsheet document
            //GenerateReport.DynamicChartSeriesColorSpreadsheet();
            // Sets colors of chart series dynamically based upon expressions presentation docuement
            //GenerateReport.DynamicChartSeriesColorPresentation();
            // Sets colors of chart series dynamically based upon expressions email docuement
            //GenerateReport.DynamicChartSeriesColorEmail();

            // Sets colors of chart series point color dynamically based upon expressions wordprocessing document
            //GenerateReport.DynamicChartSeriesPointColor();
            // Sets colors of chart series point color dynamically based upon expressions spreadsheet document
            //GenerateReport.DynamicChartSeriesPointColorSpreadsheet();
            // Sets colors of chart series point color dynamically based upon expressions prosentation document
            //GenerateReport.DynamicChartSeriesPointColorPresentation();
            // Sets colors of chart series point color dynamically based upon expressions email document
            //GenerateReport.DynamicChartSeriesPointColorEmail();
            #endregion

            #region Working With Table Row Data Bands
            // Working With Table Row DataBands in Word Processing Document
            //GenerateReport.WorkingWithTableRowDataBandsWord();
            // Working With Table Row DataBands in SpreadSheet Document
            //GenerateReport.WorkingWithTableRowDataBandsSpreadSheet();
            // Working With Table Row DataBands in Presentation Document
            //GenerateReport.WorkingWithTableRowDataBandsPresentation();
            // Working With Table Row DataBands in Email Format
            //GenerateReport.WorkingWithTableRowDataBandsEmail();
            #endregion

            #region Insert Hyperlinks Dynamically
            //Insert Hyperlink Dynamically in Word Document
            //GenerateReport.DynamicHyperlinkInsertionWord();
            //Insert Hyperlink Dynamically in Presentation Document
            //GenerateReport.DynamicHyperlinkInsertionPresentation();
            //Insert Hyperlink Dynamically in Spreadsheet Document
            //GenerateReport.DynamicHyperlinkInsertionSpreadsheet();
            //Insert Hyperlink Dynamically in Email Document
            //GenerateReport.DynamicHyperlinkInsertionEmail();

            #endregion

            #region Support removal of paragraphs becoming empty after template syntax tags are removed or replaced with empty values
            //Working with word processing document
            //GenerateReport.EmptyParagraphInWordProcessing();

            //Working with presentation document
            //GenerateReport.EmptyParagraphInPresentation();

            //Working with email documents
            //GenerateReport.EmptyParagraphInEmail();
            #endregion

            #region Merging table cells dynamically
            // Merging table cells dynamically in Word Processing
            //GenerateReport.TableCellsMergingInWordProcessing();

            // Merging table cells dynamically in Presentations
            //GenerateReport.TableCellsMergingInPresentations();

            // Merging table cells dynamically in Spreadsheets
            //GenerateReport.TableCellsMergingInSpreadsheets();

            // Merging table cells dynamically in Email
            // GenerateReport.TableCellsMergingInEmails();
            #endregion

            #region Using Markdown File Format
            //Saving an assembled Markdown document to a Word Processing format using file extension.
            //GenerateReport.SaveMdtoWord_UsingExtension("ReadMe.md");

            //Unordered lists demo for Markdown
            GenerateReport.SaveMdtoWord_UsingExtension("List_demo.md");


            //Saving an assembled Word Processing document or email to Markdown using file extension.
            //GenerateReport.SaveWordOrEmailtoMD_UsingExtension();

            //Saving an assembled Word Processing document or email to Markdown using file extension.
            //GenerateReport.SaveWordOrEmailtoMD_Explicit();
            #endregion

            //Update fields/formulas in word processing or spreadsheet documents
            //GenerateReport.UpdateWordDocFields("spreadsheet");

            //Use of Next keyword in template syntax
            //GenerateReport.NextIteration();

            //Generate report from excel data source
            //GenerateReport.UseSpreadsheetAsDataSource();

            //Generate report from presentation data source
            //GenerateReport.UsePresentationTableAsDataSource();

            //Importing word processing table into presentation
            //GenerateReport.ImportingWordProcessingTableIntoPresentation();

            //Importing spread table into html
            //GenerateReport.ImportingSpreadsheetIntoHtmlDocument();

            //Load document table set using default options
            //GenerateReport.LoadDocTableSet("Multiple Tables Data.docx");

            //Load document table set using custom options
            //GenerateReport.LoadDocTableSetWithCustomOptions("Multiple Tables Data.docx");

            //Using DocumentTableSet as Data Source
            //GenerateReport.UseDocumentTableSetAsDataSource("Multiple Tables Data.docx", "Using Document Table Set as Data Source.pptx");
            //GenerateReport.DefiningDocumentTableRelations("Related Tables Data.xlsx", "Using Document Table Relations.docx");
            //GenerateReport.ChangingDocumentTableColumnType("Presentation Templates/Changing Document Table Column Type.pptx");

            //GenerateReport.UsingStringAsTemplate();

            // Demonstrate how to enable in-line syntax errors in the template without throw any exception
            //GenerateReport.DemoInLineSyntaxError();

            //Loading of template documents from HTML(with relative path) with resources
            //GenerateReport.LoadDocFromHTMLWithResource();

            // Loading of template documents from HTML with resources from an explicitly specified folder
            //GenerateReport.LoadDocFromHTMLWithResource_ExplicitFolder();

            //Saving of external resource files at relative path
            //GenerateReport.SaveDocToHTMLWithResource();

            // Saving of external resource files in a specified folder at relative path while saving output to HTML
            //GenerateReport.SaveDocToHTMLWithResource_ExplicitFolder();

            //Working with JSON data sources
            //GenerateReport.SimpleJsonDS_Demo();

            //Working with XML data sources
            //GenerateReport.SimpleXMLDS_Demo();

            //Working with csv data sources
            //GenerateReport.SimpleCsvDS_Demo();

            //Insert Bookmarks Dynamically in Word Document
            //GenerateReport.DynamicBookmarkInsertionWord();

            //Insert Bookmarks Dynamically in Word Document
            // GenerateReport.DynamicBookmarkInsertionExcel();

            //Insert Image Dynamically in Word Document
            //GenerateReport.InsertImageDynamicallyInWord();

            // Set checkbox value dynamically in Word document
            //GenerateReport.SetCheckboxValueDynamicallyInWord(true);

            // Insert Document Dynamically in Word Document
            //GenerateReport.InsertDocumentDynamicallyInWord();


            Console.WriteLine("Done...");
            Console.ReadKey();
        }
예제 #21
0
        private void отчетToolStripMenuItem_Click(object sender, EventArgs e)
        {
            GenerateReport plForm = new GenerateReport();

            plForm.Show();
        }
 /// <summary>
 /// Fires when the user clicks generate report
 /// </summary>
 /// <param name="sender">The generate report button</param>
 /// <param name="e">the click event</param>
 private void GenerateComparisonReport_Click(object sender, EventArgs e)
 {
     // Ivokes the callback method if it is not null
     GenerateReport?.Invoke(sender, e);
 }
        /// <summary>
        /// this method is used to direct calls to generate report using data from database
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnGenerateReport_Click(object sender, EventArgs e)
        {
            GenerateReport report = new GenerateReport(tbsDbContext);

            report.GeneratePDFReport();
        }
예제 #24
0
        public string ScanName(GenerateReport generate)
        {
            var build = _veracodeRepository.GetBuildDetail(generate.AppId, generate.ScanId);

            return(build.build.version);
        }