Exemplo n.º 1
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="arguments"></param>
        /// <param name="help"></param>
        /// <returns></returns>
        private static string GenerateReport(XmlCastReport arguments, out string help)
        {
            if (arguments.ReportType != null)
            {

                string reportPath = string.Empty;
                string tmpReportFile = string.Empty;

                try
                {
                    help = string.Empty;

                    //Get RG settings
                    var settings = SettingsBLL.GetSetting();
                    LogHelper.Instance.LogInfo("RG settings have been read successfully");

                    //Initialize temporary directory
                    string workDirectory = SettingsBLL.GetApplicationPath();
                    //tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath, arguments.Template.Name));
                    //tmpReportFile = PathUtil.CreateTempCopy(workDirectory, arguments.Template.Name);

                    //Initialize Web services

                    var connection = new WSConnection(arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name, string.Empty);
                    using (CommonBLL commonBLL = new CommonBLL(connection))
                    {

                        if (!commonBLL.CheckService())
                        {
                            help = string.Format("Webservice can't be access or is bad formatted. Url:{0} Username:{1} Password:{2}", arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name);
                            return string.Empty;
                        }
                    }
                    LogHelper.Instance.LogInfo("Web services Initialized successfully");

                    List<Application> Apps = new List<Application>();

                    try
                    {
                        using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
                        {
                            if (arguments.Tag == null)
                            {
                                Apps = castDomainBLL.GetCommonTaggedApplications(null);
                            }
                            else
                            {
                                Apps = castDomainBLL.GetCommonTaggedApplications(arguments.Tag.Name);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Instance.LogInfo("Error occured while trying get applications for the portfolio");
                    }

                    Application[] SelectedApps = Apps.ToArray<Application>();
                    LogHelper.Instance.LogInfo("Applications is the portfolio found successfully");
                    string[] AppsToIgnorePortfolioResult = PortfolioBLL.BuildPortfolioResult(connection, SelectedApps);
                    LogHelper.Instance.LogInfo("Build result for the portfolio");
                    string[] SnapsToIgnore = null;
                    List<Application> N_Apps = new List<Application>();
                    //Remove from Array the Ignored Apps
                    for (int i = 0; i < SelectedApps.Count(); i++)
                    {
                        int intAppYes = 0;
                        foreach (string s in AppsToIgnorePortfolioResult)
                        {
                            if (s == SelectedApps[i].Name)
                            {
                                intAppYes = 1;
                                break;
                            }
                            else
                            {
                                intAppYes = 0;
                            }
                        }

                        if (intAppYes == 0)
                        {
                            N_Apps.Add(SelectedApps[i]);
                        }
                    }
                    Application[] N_SelectedApps = N_Apps.ToArray();

                    List<Snapshot> Snapshots = new List<Snapshot>();

                    try
                    {
                        using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
                        {
                            Snapshots = castDomainBLL.GetAllSnapshots(N_SelectedApps);
                        }
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Instance.LogInfo("Error occured while trying get snapshots of applications for the portfolio");
                    }
                    LogHelper.Instance.LogInfo("Snapshots is the portfolio found successfully");
                    List<Snapshot> N_Snaps = new List<Snapshot>();
                    if (Snapshots != null)
                    {
                        Snapshot[] SelectedApps_Snapshots = Snapshots.ToArray<Snapshot>();
                        SnapsToIgnore = PortfolioSnapshotsBLL.BuildSnapshotResult(connection, SelectedApps_Snapshots, true);
                        LogHelper.Instance.LogInfo("Build result for snapshots in portfolio");

                        for (int i = 0; i < SelectedApps_Snapshots.Count(); i++)
                        {
                            int intRemoveYes = 0;
                            foreach (string s in SnapsToIgnore)
                            {
                                if (s == SelectedApps_Snapshots[i].Href)
                                {
                                    intRemoveYes = 1;
                                    break;
                                }
                                else
                                {
                                    intRemoveYes = 0;
                                }
                            }
                            if (intRemoveYes == 0)
                            {
                                N_Snaps.Add(SelectedApps_Snapshots[i]);
                            }
                        }

                        Snapshot[] N_SelectedApps_Snapshots = N_Snaps.ToArray();

                        //GenerateReportPortfolio(N_SelectedApps, N_SelectedApps_Snapshots);
                        //string tmpReportFile = String.Empty;
                        string tmpReportFileFlexi = String.Empty;

                        try
                        {

                            //Create temporary report
                            //string workDirectory = SettingsBLL.GetApplicationPath();
                            //tmpReportFile = PathUtil.CreateTempCopy(workDirectory + "\\Portfolio\\", arguments.Template.Name);
                            tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath + "\\Portfolio", arguments.Template.Name));
                            if (tmpReportFile.Contains(".xlsx"))
                            {
                                tmpReportFileFlexi = PathUtil.CreateTempCopyFlexi(workDirectory, arguments.Template.Name);
                            }
                            //Build report
                            ReportData reportData = new ReportData();
                            if (arguments.Category != null && arguments.Tag != null)
                            {
                                reportData = new ReportData()
                                {
                                    FileName = tmpReportFile,
                                    Application = null,
                                    CurrentSnapshot = null,
                                    PreviousSnapshot = null,
                                    RuleExplorer = new RuleBLL(connection),
                                    CurrencySymbol = "$",
                                    Applications = N_SelectedApps,
                                    Category = arguments.Category.Name,
                                    Tag = arguments.Tag.Name,
                                    snapshots = N_SelectedApps_Snapshots,
                                    IgnoresApplications = AppsToIgnorePortfolioResult,
                                    IgnoresSnapshots = SnapsToIgnore
                                };
                            }
                            else if (arguments.Category != null && arguments.Tag == null)
                            {
                                reportData = new ReportData()
                                {
                                    FileName = tmpReportFile,
                                    Application = null,
                                    CurrentSnapshot = null,
                                    PreviousSnapshot = null,
                                    RuleExplorer = new RuleBLL(connection),
                                    CurrencySymbol = "$",
                                    Applications = N_SelectedApps,
                                    Category = arguments.Category.Name,
                                    Tag = null,
                                    snapshots = N_SelectedApps_Snapshots,
                                    IgnoresApplications = AppsToIgnorePortfolioResult,
                                    IgnoresSnapshots = SnapsToIgnore
                                };
                            }
                            else if (arguments.Category == null && arguments.Tag != null)
                            {
                                reportData = new ReportData()
                                {
                                    FileName = tmpReportFile,
                                    Application = null,
                                    CurrentSnapshot = null,
                                    PreviousSnapshot = null,
                                    RuleExplorer = new RuleBLL(connection),
                                    CurrencySymbol = "$",
                                    Applications = N_SelectedApps,
                                    Category = null,
                                    Tag = arguments.Tag.Name,
                                    snapshots = N_SelectedApps_Snapshots,
                                    IgnoresApplications = AppsToIgnorePortfolioResult,
                                    IgnoresSnapshots = SnapsToIgnore
                                };
                            }
                            else
                            {
                                reportData = new ReportData()
                                {
                                    FileName = tmpReportFile,
                                    Application = null,
                                    CurrentSnapshot = null,
                                    PreviousSnapshot = null,
                                    RuleExplorer = new RuleBLL(connection),
                                    CurrencySymbol = "$",
                                    Applications = N_SelectedApps,
                                    Category = null,
                                    Tag = null,
                                    snapshots = N_SelectedApps_Snapshots,
                                    IgnoresApplications = AppsToIgnorePortfolioResult,
                                    IgnoresSnapshots = SnapsToIgnore
                                };
                            }

                            using (IDocumentBuilder docBuilder = BuilderFactory.CreateBuilder(reportData, tmpReportFile))
                            {
                                docBuilder.BuildDocument();
                            }
                            LogHelper.Instance.LogInfo("Report generated successfully");

                            //Set filte report
                            SetFileName(arguments);

                            if (string.IsNullOrEmpty(settings.ReportingParameter.GeneratedFilePath))
                                reportPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), arguments.File.Name);
                            else
                                reportPath = Path.Combine(settings.ReportingParameter.GeneratedFilePath, arguments.File.Name);

                            if (tmpReportFile.Contains(".xlsx"))
                            {
                                tmpReportFile = tmpReportFileFlexi;
                            }

                            //Copy report file to the selected destination
                            File.Copy(tmpReportFile, reportPath, true);
                        }
                        catch (Exception ex)
                        {
                            reportPath = String.Empty;

                            throw (ex);
                        }
                        finally
                        {
                            if (!String.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
                        }

                    }

                    return reportPath;
                }
                catch (Exception ex)
                {
                    help = string.Format("An exception occured : {0}", ex);
                    return string.Empty;
                }
                finally
                {
                    if (!string.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
                }
            }
            else
            {

                string tmpReportFile = string.Empty;

                try
                {
                    help = string.Empty;

                    //Get RG settings
                    var settings = SettingsBLL.GetSetting();
                    LogHelper.Instance.LogInfo("RG settings have been read successfully");

                    //Initialize temporary directory
                    string workDirectory = SettingsBLL.GetApplicationPath();
                    tmpReportFile = PathUtil.CreateTempCopy(workDirectory, Path.Combine(settings.ReportingParameter.TemplatePath, arguments.Template.Name));

                    //Initialize Web services

                    var connection = new WSConnection(arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name, string.Empty);
                    using (CommonBLL commonBLL = new CommonBLL(connection))
                    {
                        if (!commonBLL.CheckService())
                        {
                            help = string.Format("Webservice can't be access or is bad formatted. Url:{0} Username:{1} Password:{2}", arguments.Webservice.Name, arguments.Username.Name, arguments.Password.Name);
                            return string.Empty;
                        }
                    }
                    LogHelper.Instance.LogInfo("Web services Initialized successfully");

                    //Initialize Application
                    Application application = GetApplication(arguments.Application.Name, connection);
                    if (application == null)
                    {
                        help = string.Format("Application {0} can't be found.", arguments.Application.Name);
                        return string.Empty;
                    }
                    LogHelper.Instance.LogInfo(string.Format("Application {0} Initialized successfully", arguments.Application.Name));

                    //Initialize snapshots
                    SetSnapshots(connection, application);
                    if (application.Snapshots == null)
                    {
                        help = "There is no snapshots for this application.";
                        return string.Empty;
                    }
                    LogHelper.Instance.LogInfo(string.Format("List of Snapshots Initialized successfully", arguments.Application.Name));

                    //Build Application results
                    ApplicationBLL.BuildApplicationResult(connection, application);
                    LogHelper.Instance.LogInfo(string.Format("Application results built successfully", arguments.Application.Name));

                    //Set current snapshot
                    Snapshot currentSnapshot = GetSnapshotOrDefault(arguments.Snapshot.Current, application.Snapshots, 0);
                    if (currentSnapshot == null)
                    {
                        help = string.Format("Current snapshot {0} can't be found", arguments.Snapshot.Current.Name);
                        return string.Empty;
                    }
                    LogHelper.Instance.LogInfo(string.Format("Current snapshot {0} initialized successfully", currentSnapshot.Name));

                    //Build current snapshot results
                    SnapshotBLL.BuildSnapshotResult(connection, currentSnapshot, true);
                    LogHelper.Instance.LogInfo(string.Format("Result of current snapshot {0} built successfully", currentSnapshot.Name));

                    //Set previous snapshot
                    Snapshot prevSnapshot = GetSnapshotOrDefault(arguments.Snapshot.Previous, application.Snapshots, 1);
                    if (arguments.Snapshot.Previous != null && !string.IsNullOrEmpty(arguments.Snapshot.Previous.Name) && prevSnapshot == null)
                    {
                        help = string.Format("Previous snapshot {0} can't be found", arguments.Snapshot.Previous.Name);
                        return string.Empty;
                    }
                    if (prevSnapshot != null) LogHelper.Instance.LogInfo(string.Format("Previous snapshot {0} Initialized successfully", prevSnapshot.Name));

                    //Build previous snapshot results
                    if (prevSnapshot != null)
                    {
                        SnapshotBLL.BuildSnapshotResult(connection, prevSnapshot, false);
                        LogHelper.Instance.LogInfo(string.Format("Result of previous snapshot {0}  built successfully", prevSnapshot.Name));
                    }

                    //Build report
                    ReportData reportData = new ReportData()
                    {
                        FileName = tmpReportFile,
                        Application = application,
                        CurrentSnapshot = currentSnapshot,
                        PreviousSnapshot = prevSnapshot,
                        Parameter = settings.ReportingParameter,
                        RuleExplorer = new RuleBLL(connection),
                        SnapshotExplorer = new SnapshotBLL(connection, currentSnapshot),
                        CurrencySymbol = "$"
                    };

                    using (IDocumentBuilder docBuilder = BuilderFactory.CreateBuilder(reportData, ""))
                    {
                        docBuilder.BuildDocument();
                    }
                    LogHelper.Instance.LogInfo("Report generated successfully");

                    //Set filte report
                    SetFileName(arguments);

                    string reportPath;
                    if (string.IsNullOrEmpty(settings.ReportingParameter.GeneratedFilePath))
                        reportPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), arguments.File.Name);
                    else
                        reportPath = Path.Combine(settings.ReportingParameter.GeneratedFilePath, arguments.File.Name);

                    File.Copy(tmpReportFile, reportPath, true);
                    LogHelper.Instance.LogInfo("Report moved to generation directory successfully");

                    return reportPath;
                }
                catch (Exception ex)
                {
                    help = string.Format("An exception occured : {0}", ex);
                    return string.Empty;
                }
                finally
                {
                    if (!string.IsNullOrEmpty(tmpReportFile)) File.Delete(tmpReportFile);
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="application"></param>
        /// <param name="connection"></param>
        /// <returns></returns>
        private static Application GetApplication(string application, WSConnection connection)
        {
            List<Application> applications;

            using (CastDomainBLL castDomainBLL = new CastDomainBLL(connection))
            {
                applications = castDomainBLL.GetApplications();
            }

            return applications.Where(_ => _.Name == application).FirstOrDefault();
        }
Exemplo n.º 3
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            if (SelectedTab == 0)
            {
                double progressStep = 100 / 4;
                Stopwatch stopWatchStep = new Stopwatch();
                Stopwatch stopWatchGlobal = new Stopwatch();

                try
                {
                    stopWatchGlobal.Start();
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<bool>(base.MessageManager.SetBusyMode), true);

                    //Set culture for the new thread
                    if (!string.IsNullOrEmpty(Setting.ReportingParameter.CultureName))
                    {
                        var culture = new CultureInfo(Setting.ReportingParameter.CultureName);
                        Thread.CurrentThread.CurrentCulture = culture;
                        Thread.CurrentThread.CurrentUICulture = culture;
                    }

                    //Get result for the Application
                    stopWatchStep.Restart();
                    ApplicationBLL.BuildApplicationResult(ActiveConnection, SelectedApplication);
                    stopWatchStep.Stop();
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Build result for the application", stopWatchStep.Elapsed);

                    //Get result for the previous snapshot
                    stopWatchStep.Restart();
                    SnapshotBLL.BuildSnapshotResult(ActiveConnection, SelectedSnapshot, true);
                    stopWatchStep.Stop();
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Build result for the selected snapshot", stopWatchStep.Elapsed);

                    //Get result for the previuos snapshot
                    if (PreviousSnapshot != null)
                    {
                        stopWatchStep.Restart();
                        SnapshotBLL.BuildSnapshotResult(ActiveConnection, PreviousSnapshot, false);
                        stopWatchStep.Stop();

                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Build result for the previous snapshot", stopWatchStep.Elapsed);
                    }

                    //Launch generaion
                    stopWatchStep.Restart();
                    GenerateReport();
                    stopWatchStep.Stop();

                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Report generated", stopWatchStep.Elapsed);

                    //Show final message and unlock the screen
                    stopWatchGlobal.Stop();
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<string, TimeSpan>(base.MessageManager.OnReportGenerated), ReportFileName, stopWatchGlobal.Elapsed);
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<bool>(base.MessageManager.SetBusyMode), false);
                }
                catch (Exception ex)
                {
                    App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<Exception>(WorkerThreadException), ex);
                }
            }
            else
            {
                List<Application> Apps = new List<Application>();
                List<Snapshot> Snapshots = new List<Snapshot>();
                //if (SelectedTag != null)
                //{
                    //GetActive Connection
                    ActiveConnection = (Setting != null) ? Setting.GetActiveConnection() : null;

                    //Get list of domains
                    if (_ActiveConnection != null)
                    {
                        try
                        {
                            using (CastDomainBLL castDomainBLL = new CastDomainBLL(ActiveConnection))
                            {
                                Apps = castDomainBLL.GetCommonTaggedApplications(SelectedTag);
                            }
                        }
                        catch (Exception ex)
                        {
                            base.MessageManager.OnErrorOccured(ex);
                        }
                    }

                if (Apps != null)
                {
                    Application[] SelectedApps = Apps.ToArray<Application>();

                    double progressStep = 100 / 4;
                    Stopwatch stopWatchStep = new Stopwatch();
                    Stopwatch stopWatchGlobal = new Stopwatch();

                    try
                    {
                        stopWatchGlobal.Start();
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<bool>(base.MessageManager.SetBusyMode), true);

                        //Set culture for the new thread
                        if (!string.IsNullOrEmpty(Setting.ReportingParameter.CultureName))
                        {
                            var culture = new CultureInfo(Setting.ReportingParameter.CultureName);
                            Thread.CurrentThread.CurrentCulture = culture;
                            Thread.CurrentThread.CurrentUICulture = culture;
                        }
                        string[] SnapsToIgnore = null;
                        //Get result for the Portfolio
                        stopWatchStep.Restart();
                        string[] AppsToIgnorePortfolioResult = PortfolioBLL.BuildPortfolioResult(ActiveConnection, SelectedApps);
                        stopWatchStep.Stop();
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Build result for the portfolio", stopWatchStep.Elapsed);

                        List<Application> N_Apps = new List<Application>();
                        //Remove from Array the Ignored Apps
                        for (int i = 0; i < SelectedApps.Count(); i++)
                        {
                            int intAppYes = 0;
                            foreach (string s in AppsToIgnorePortfolioResult)
                            {
                                if (s == SelectedApps[i].Name)
                                {
                                    intAppYes = 1;
                                    break;
                                }
                                else
                                {
                                    intAppYes = 0;
                                }
                            }

                            if (intAppYes == 0)
                            {
                                N_Apps.Add(SelectedApps[i]);
                            }
                        }

                        Application[] N_SelectedApps = N_Apps.ToArray();

                            //GetActive Connection
                            ActiveConnection = (Setting != null) ? Setting.GetActiveConnection() : null;

                        //Get list of domains
                        if (_ActiveConnection != null)
                        {
                            try
                            {
                                using (CastDomainBLL castDomainBLL = new CastDomainBLL(ActiveConnection))
                                {
                                    Snapshots = castDomainBLL.GetAllSnapshots(N_SelectedApps);
                                }
                            }
                            catch (Exception ex)
                            {
                                base.MessageManager.OnErrorOccured(ex);
                            }
                        }
                        List<Snapshot> N_Snaps = new List<Snapshot>();
                        //Get result for each app's latest snapshot
                        if (Snapshots != null)
                        {
                            Snapshot[] SelectedApps_Snapshots = Snapshots.ToArray<Snapshot>();

                            //Get result for all snapshots in Portfolio
                            stopWatchStep.Restart();
                            SnapsToIgnore = PortfolioSnapshotsBLL.BuildSnapshotResult(ActiveConnection, SelectedApps_Snapshots, true);
                            stopWatchStep.Stop();
                            App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Build result for snapshots in portfolio", stopWatchStep.Elapsed);

                            for (int i = 0; i < SelectedApps_Snapshots.Count(); i++)
                            {
                                int intRemoveYes = 0;
                                foreach (string s in SnapsToIgnore)
                                {
                                    if (s == SelectedApps_Snapshots[i].Href)
                                    {
                                        intRemoveYes = 1;
                                        break;
                                    }
                                    else
                                    {
                                        intRemoveYes = 0;
                                    }
                                }
                                if (intRemoveYes == 0)
                                {
                                    N_Snaps.Add(SelectedApps_Snapshots[i]);
                                }
                            }

                            Snapshot[] N_SelectedApps_Snapshots = N_Snaps.ToArray();

                                //Launch generaion
                                stopWatchStep.Restart();
                                GenerateReportPortfolio(N_SelectedApps, N_SelectedApps_Snapshots, AppsToIgnorePortfolioResult, SnapsToIgnore);
                            stopWatchStep.Stop();
                        }

                        System.Text.StringBuilder sb = new System.Text.StringBuilder();

                        if ((AppsToIgnorePortfolioResult.Count() > 0 && AppsToIgnorePortfolioResult != null) || (SnapsToIgnore.Count() > 0 && SnapsToIgnore != null))
                        {
                            sb.Append("Some Applications or Snapshots were ignored during processing REST API.");

                            if (AppsToIgnorePortfolioResult.Count() > 0 && AppsToIgnorePortfolioResult != null)
                            {
                                AppsToIgnorePortfolioResult = AppsToIgnorePortfolioResult.Distinct().ToArray();
                                sb.Append("Ignored Applications are: ");
                                for (int i = 0; i < AppsToIgnorePortfolioResult.Count(); i++)
                                {
                                    if (i == 0)
                                    {
                                        sb.Append(AppsToIgnorePortfolioResult[i].ToString());
                                    }
                                    else
                                    {
                                        sb.Append("," + AppsToIgnorePortfolioResult[i].ToString());
                                    }
                                }
                            }

                            if (SnapsToIgnore.Count() > 0 && SnapsToIgnore != null)
                            {
                                SnapsToIgnore = SnapsToIgnore.Distinct().ToArray();
                                sb.Append(" Ignored Snapshots are: ");
                                for (int i = 0; i < SnapsToIgnore.Count(); i++)
                                {
                                    if (i == 0)
                                    {
                                        sb.Append(_ActiveConnection.Url + "/" + SnapsToIgnore[i].ToString());
                                    }
                                    else
                                    {
                                        sb.Append("," + _ActiveConnection.Url + "/" + SnapsToIgnore[i].ToString());
                                    }
                                }
                            }
                            App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, sb.ToString() + "", null);
                        }

                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Report generated", stopWatchStep.Elapsed);

                        //Show final message and unlock the screen
                        stopWatchGlobal.Stop();
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<string, TimeSpan>(base.MessageManager.OnReportGenerated), ReportFileName, stopWatchGlobal.Elapsed);
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<bool>(base.MessageManager.SetBusyMode), false);

                    }
                    catch (System.Net.WebException webEx)
                    {
                        LogHelper.Instance.LogErrorFormat
                               ("Request URL '{0}' - Error execution :  {1}"
                               , ""
                               , webEx.Message
                               );

                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<double, string, TimeSpan>(base.MessageManager.OnStepDone), progressStep, "Error Generating Report - " + webEx.Message + " - Typically happens when Report Generator does not find REST API (in schema)", stopWatchStep.Elapsed);
                        stopWatchGlobal.Stop();
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<bool>(base.MessageManager.SetBusyMode), false);

                    }
                    catch (Exception ex)
                    {
                        App.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action<Exception>(WorkerThreadException), ex);
                    }
                }
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Implement Command that Load the templates list
        /// </summary>
        void ExecuteLoadTagsCommand(object parameter)
        {
            if (SelectedCategory != null)
            {
                //GetActive Connection
                ActiveConnection = (Setting != null) ? Setting.GetActiveConnection() : null;

                //Get list of domains
                if (_ActiveConnection != null)
                {
                    try
                    {
                        using (CastDomainBLL castDomainBLL = new CastDomainBLL(ActiveConnection))
                        {
                            Tags = castDomainBLL.GetTags(SelectedCategory);
                        }
                    }
                    catch (Exception ex)
                    {
                        base.MessageManager.OnErrorOccured(ex);
                    }
                }
            }
            else

                Tags = null;
        }
Exemplo n.º 5
0
        /// <summary>
        /// 
        /// </summary>
        public void InitializeFromWS()
        {
            //GetActive Connection
            ActiveConnection = (Setting != null) ? Setting.GetActiveConnection() : null;

            //Get list of domains
            if (_ActiveConnection != null)
            {
                try
                {
                    using (CastDomainBLL castDomainBLL = new CastDomainBLL(ActiveConnection))
                    {
                        Applications = castDomainBLL.GetApplications();
                        Categories = castDomainBLL.GetCategories();
                        SelectedTab = 0;
                    }
                }
                catch(Exception ex)
                {
                    base.MessageManager.OnErrorOccured(ex);
                }
            }
        }