public RunLogEventArgs(RunLogItem item)
 {
     _item = item;
 }
        private void OnRunComplete(Report report,RunLogItem logitem)
        {
            _shellService.PostStatusMessage(StatusCatgory.Info, "Complete");

            RunCodeInUiThread(() =>
            {
                _shellService.OpenChildView("ReportViewer", "Report Viewer", option: new ViewOptions { Height = 600, Width = 800, Payload = logitem });
            });
        }
        public void RunProject(Project project, Action<Report, RunLogItem> onComplete)
        {
            var log = new RunLogItem();

            log.Start = DateTime.Now;
            log.Project = project.Name;

            if (project == null)
            {
                throw new ArgumentException();
            }

            if (project.RuleSet == null)
            {
                throw new Exception("RuleSet is not specified. ");
            }

            var context = new ExamContext(project);

            foreach (var i in project.RuleSet)
            {
                try
                {
                    i.Exam(context);
                }
                catch (Exception e)
                {
                    context.WriteOutput(i.Name, new Output
                    {
                        Summary = e.Message,
                        Details = new List<string>
                        {
                            e.ToString(),
                        },
                    });
                    context.AddResult(new ExamResult()
                    {
                        RuleName = i.Name,
                        Status = ActionStatus.Failed,
                    });
                    context.AddViolation(new Violation
                    {
                        RuleName = i.Name,
                        Description = e.Message,
                    });
                    continue;
                }
            }

            var report = context.GenerateReport();

            var path = SaveReportToFile(report);

            log.End = DateTime.Now;
            log.Status = report.Status;
            log.Report = path;
            log.Rules = project.RuleSet.Count;

            list.Insert(0, log);

            SaveRunlog(log);

            if (onComplete != null)
            {
                onComplete.Invoke(report, log);
            }
        }
        private void SaveRunlog(RunLogItem log)
        {
            FireRunLogAdded(log);

            if (!Directory.Exists(_dirLogs))
            {
                Directory.CreateDirectory(_dirLogs);
            }

            var path = Path.Combine(_dirLogs, log.Project + ".xml");
            var xdoc = null as XDocument;

            if (File.Exists(path))
            {
                xdoc = XDocument.Load(path);
            }
            else
            {
                xdoc = new XDocument();
            }

            if (xdoc.Root == null)
            {
                xdoc.Add(new XElement("runlog"));
            }

            xdoc.Root.Add(new XElement(
                "run",
                new XAttribute("project", log.Project),
                new XAttribute("rules", log.Rules),
                new XAttribute("start", log.Start),
                new XAttribute("end", log.End),
                new XAttribute("status", log.Status),
                new XAttribute("summary", log.Summary),
                new XAttribute("report", log.Report)
                ));
            xdoc.Save(path);
        }
 void FireRunLogAdded(RunLogItem item)
 {
     if (RunLogAdded != null)
     {
         RunLogAdded.Invoke(this, new RunLogEventArgs(item));
     }
 }
        private List<RunLogItem> BuildLogs()
        {
            if (!Directory.Exists(_dirLogs))
            {
                return list;
            }

            list.Clear();

            foreach (var i in Directory.GetFiles(_dirLogs, "*.xml"))
            {
                var xdoc = XDocument.Load(i);

                if (!xdoc.Elements().Any())
                {
                    continue;
                }

                var root = xdoc.Elements().FirstOrDefault();

                foreach (var run in root.Elements())
                {
                    if (run.Name != "run")
                    {
                        continue;
                    }

                    var attrProject = run.Attribute("project");
                    var attrRules = run.Attribute("rules");
                    var attrStart = run.Attribute("start");
                    var attrEnd = run.Attribute("end");
                    var attrResult = run.Attribute("status");
                    var attrReport = run.Attribute("report");
                    var status = ActionStatus.None;

                    if (attrResult != null)
                    {
                        Enum.TryParse<ActionStatus>(attrResult.Value, out status);
                    }

                    var prj = new RunLogItem
                    {
                        Project = attrProject == null ? null : attrProject.Value,
                        Rules = attrRules == null ? null : (int?)int.Parse(attrRules.Value),
                        Start = attrStart == null ? null : (DateTime?)DateTime.Parse(attrStart.Value),
                        End = attrEnd == null ? null : (DateTime?)DateTime.Parse(attrEnd.Value),
                        Status = status,
                        Report = attrReport == null ? null : attrReport.Value,
                    };

                    list.Add(prj);
                }
            }

            var rv = list.OrderByDescending(x => x.Start).ToList();

            return rv;
        }