3rdpartylibs/fastreports.wpf/FastReport.DesignExt/Design/CloudCommands.cs

using FastReport.Auth;
using FastReport.Cloud.FastReport;
using FastReport.Cloud.FastReport.ListViewCloud;
using FastReport.Cloud.FastReport.Models;
using FastReport.Cloud.FastReport.Models.DataSource;
using FastReport.Data;
using FastReport.Forms;
using FastReport.Utils;
using System;
using System.IO;
using System.Net;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace FastReport.Design
{
    internal static class CloudCommands
    {
        private static bool isAborted;
        private static AuthService.AppUser User => AuthService.Instance.User;

        private static void ShowWindowUntilAuthentificatedOrAborted()
        {
            while (!User.IsAuthentificatedAndActive && !isAborted)
            {
                ShowAuthWindow();
            }
        }

        private static void ShowAuthWindow()
        {
            using (AuthForm authPage = new AuthForm())
            {
                if (authPage.ShowDialog() == DialogResult.OK)
                {
                    if (!User.IsAuthentificatedAndActive)
                    {
                        var localizator = new MyRes("Forms,ListViewForm");
                        MessageBox.Show(localizator.Get("AuthError"),
                            localizator.Get("AuthErrorCaption"), MessageBoxButtons.OK);
                    }
                }
                else
                {
                    isAborted = true;
                }
            }
        }

        private static void CheckAndSetReportProvider()
        {
            if (ProviderManager.Provider == null || ProviderManager.Subscriptions == null ||
                ProviderManager.Subscription == null || ProviderManager.Provider != ProviderManager.Provider.Templates)
            {
                ProviderManager.SetProvider(new FRCloudProvider(AuthService.Instance), Modes.CloudFilesMode.Templates);
            }
        }

        private static CreateDataSourceVM CreateCloudConnection(DataConnectionBase data)
        {
            CreateDataSourceVM dsVM = new CreateDataSourceVM();
            if (data.ClassName.StartsWith("MsSql"))
                dsVM.ConnectionType = DataSourceConnectionType.MSSQL;

            else if (data.ClassName.StartsWith("Firebird"))
                dsVM.ConnectionType = DataSourceConnectionType.FirebirdDB;

            else if (data.ClassName.StartsWith("Mongo"))
                dsVM.ConnectionType = DataSourceConnectionType.MongoDB;

            else if (data.ClassName.StartsWith("Postgres"))
                dsVM.ConnectionType = DataSourceConnectionType.Postgres;

            else if (data.ClassName.StartsWith("Oracle"))
                dsVM.ConnectionType = DataSourceConnectionType.OracleDB;

            else if (data.ClassName.StartsWith("MySql"))
                dsVM.ConnectionType = DataSourceConnectionType.MySQL;

            else if (data.ClassName.StartsWith("Json"))
                dsVM.ConnectionType = DataSourceConnectionType.JSON;

            else if (data.ClassName.StartsWith("Xml"))
                dsVM.ConnectionType = DataSourceConnectionType.XML;

            else if (data.ClassName.ToLower().StartsWith("CSV"))
                dsVM.ConnectionType = DataSourceConnectionType.CSV;

            else
                throw new Exception("Error in creating connection");

            dsVM.ConnectionString = data.ConnectionString;
            dsVM.Name = data.Name;
            dsVM.SubscriptionId = ProviderManager.Subscription.Id;
            return dsVM;
        }

        private static FileVM SaveFile(Report report, Modes.CloudFilesMode cloudFilesMode)
        {
            if (!CheckAuthentication())
                return null;

            if (AuthService.Instance.CanRefresh)
            {
                AuthService.Instance.Refresh();
            }

            using (ListViewCloudForm form = new ListViewCloudForm())
            {
                form.Mode = Modes.FormOpenMode.SaveMode;
                FilesModeItem.FilesMode = cloudFilesMode;
                form.SetReportTextBox(report.GetReportName + FilesModeItem.ToString());
                form.ReportToSave = report;

                if (!form.OnLoad(new FRCloudProvider(AuthService.Instance)))
                {
                    return null;
                }
                form.ShowDialog();
                return form.CreatedFile;
            }
        }

        // loads file using dialog window. Can be used to load either template or a prepared report.
        private static OpeningInstance LoadFileDialog(Modes.CloudFilesMode cloudFilesMode)
        {
            if (!CheckAuthentication())
                return null;

            if (AuthService.Instance.CanRefresh)
                AuthService.Instance.Refresh();

            using (ListViewCloudForm form = new ListViewCloudForm())
            {
                form.Mode = Modes.FormOpenMode.OpenMode;
                FilesModeItem.FilesMode = cloudFilesMode;
                //form.FilesMode = CloudFilesMode; // error with creating report
                while (!form.OnLoad(new FRCloudProvider(AuthService.Instance)))
                {
                    ShowAuthWindow();
                    if (isAborted)
                        return null;
                }
                form.ShowDialog();
                return form.Instance;
            }
        }

        public static bool CheckAuthentication()
        {
            isAborted = false;
            ShowWindowUntilAuthentificatedOrAborted();
            return User.IsAuthentificatedAndActive && !isAborted;
        }

        public static FileVM SaveReportFile(Report report) => SaveFile(report, Modes.CloudFilesMode.Templates);

        public static FileVM SavePreviewFile(Report report) => SaveFile(report, Modes.CloudFilesMode.Reports);

        public static bool Resave(Report report)
        {
            CheckAndSetReportProvider();
            return FileManager.ResaveCommand(report);
        }

        public static Stream LoadPreviewFile()
        {
            var instance = LoadFileDialog(Modes.CloudFilesMode.Reports);
            return instance?.ReportStream;
        }

        // loads report template file using dialog.
        public static OpeningInstance LoadFile()
        {
            return LoadFileDialog(Modes.CloudFilesMode.Templates);
        }

        // loads specified report template file. Throws an exception if load failed. 
        // This method is used by recent file list. CheckAuthentication call is required beforehand
        public static async Task<OpeningInstance> LoadFile(string key, string id)
        {
            return await Task.Run(() =>
            {
                if (AuthService.Instance.CanRefresh)
                    AuthService.Instance.Refresh();
            }).ContinueWith(_ =>
            {
                CheckAndSetReportProvider();
                return new OpeningInstance((FileManager.DownloadFileCommand(id)).Stream,
                    key, id, null, FileManager.GetFileCommand(id).EditedTime);
            });
        }

        public static void PreviewReport(Report report)
        {
            XmlItem xi = Config.Root.FindItem("Auth").FindItem("ConnectionInfo");
            string serverFromConfig = xi.GetProp("Server");
            string host = string.IsNullOrEmpty(serverFromConfig) ? Res.Get("Forms,ServerWindow,DefaultServerHost") : serverFromConfig;
            string uri = host + @"/staticpreview/t/" + report.CloudFileInfo.FileId;
            ProcessHelper.StartProcess(uri);
        }

        public static DataConnectionBase GetDataConnection()
        {
            if (!CheckAuthentication())
                return null;

            if (AuthService.Instance.CanRefresh)
                AuthService.Instance.Refresh();

            using (CloudDataSourceForm form = new CloudDataSourceForm())
            {
                if (!form.SetProvider())
                    return null;
                form.OnLoad();
                form.ShowDialog();
                if (form.dataConnection != null)
                {
                    var connection = form.dataConnection;
                    connection.TablesStructure = form.tableStructure;
                    connection.CloudId = form.dataSourceId;
                    connection.CloudInfo.Name = form.dataConnection.Name;
                    connection.CloudInfo.ConnectionString = form.dataConnection.ConnectionString;
                    return connection;
                }
            }
            return null;
        }

        public static void UploadDataConnection(DataConnectionBase data)
        {
            if (!CheckAuthentication())
                return;

            CheckAndSetReportProvider();

            if (AuthService.Instance.CanRefresh)
                AuthService.Instance.Refresh();

            var dsVM = CreateCloudConnection(data);

            if (ProviderManager.DataSourcesProvider == null)
                ProviderManager.DataSourcesProvider = new FRCloudDataSourcesProvider(AuthService.Instance);
            try
            {
                if (string.IsNullOrEmpty(data.CloudId))
                    DataSourceManager.CreateDataSourceCommand(dsVM);
                else
                {
                    try
                    {
                        DataSourceManager.FetchDataCommand(data.CloudId);
                        DataSourceManager.UpdateDataSourceSubscriptionCommand(data.CloudId, new UpdateDataSourceSubcriptionVM()
                        {
                            SubscriptionId = ProviderManager.Subscription.Id
                        });

                        if (data.CloudInfo.Name != data.Name)
                            DataSourceManager.RenameDataSourceCommand(data.CloudId, new RenameDataSourceVM() { Name = data.Name });

                        if (data.CloudInfo.ConnectionString != data.ConnectionString)
                            DataSourceManager.UpdateConnectionStringCommand(data.CloudId, new UpdateDataSourceConnectionStringVM()
                            {
                                ConnectionString = data.ConnectionString
                            });
                    }
                    catch (WebException exception)
                    {
                        if (((HttpWebResponse)exception.Response).StatusCode == HttpStatusCode.BadRequest)
                        {
                            MessageBox.Show(Res.Get("Forms,DataWizard,MessageBox,ErrorInvalidID"),
                                Res.Get("Forms,DataWizard,MessageBox,ErrorCaption"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                        if (((HttpWebResponse)exception.Response).StatusCode == HttpStatusCode.NotFound)
                        {
                            MessageBox.Show(Res.Get("Forms,DataWizard,MessageBox,Error404"),
                                Res.Get("Forms,DataWizard,MessageBox,ErrorCaption"), MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }
                        return;
                    }

                }

                if (string.IsNullOrEmpty(data.CloudId))
                    MessageBox.Show(Res.Get("Forms,DataWizard,MessageBox,SuccessText"),
                        Res.Get("Forms,DataWizard,MessageBox,SuccessCaption"), MessageBoxButtons.OK);
                else
                    MessageBox.Show(Res.Get("Forms,DataWizard,MessageBox,SuccessUpdateText"),
                        Res.Get("Forms,DataWizard,MessageBox,SuccessUpdateCaption"), MessageBoxButtons.OK);
            }
            catch (Exception exception)
            {
                MessageBox.Show(Res.Get("Forms,DataWizard,MessageBox,ErrorText"),
                    Res.Get("Forms,DataWizard,MessageBox,ErrorCaption"), MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}