public async Task <IActionResult> Index(InstallViewModel model)
{
if (Installed)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
//await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
await _signInManager.SignInAsync(user, isPersistent : false);
//_logger.LogInformation("User created a new account with password.");
return(RedirectToAction("InstallFinished"));
}
}
return(View(model));
}
protected override void Run()
{
Dispatcher = Dispatcher.CurrentDispatcher;
var model = new BootstrapperApplicationModel(this);
var command = model.BootstrapperApplication.Command;
if (command.Action == LaunchAction.Uninstall && (command.Display == Display.None || command.Display == Display.Embedded))
{
model.LogMessage("Starting silent uninstaller.");
var viewModel = new SilentUninstallViewModel(model, Engine);
Engine.Detect();
}
else
{
model.LogMessage("Starting installer.");
var viewModel = new InstallViewModel(model);
var view = new InstallView(viewModel);
view.Closed += (sender, e) => Dispatcher.InvokeShutdown();
model.SetWindowHandle(view);
Engine.Detect();
view.Show();
}
Dispatcher.Run();
Engine.Quit(model.FinalResult);
}
public ActionResult TestSendEmail(InstallViewModel model)
{
var smtpSettings = model?.Smtp;
string errorMessage = "Email server settings invalid";
if (smtpSettings != null)
{
if (Email.TryPingHost(smtpSettings.Host, smtpSettings.Port, out errorMessage))
{
var settings = new SmtpSettings(smtpSettings.Host, smtpSettings.Port, smtpSettings.EnableSsl,
smtpSettings.UserName, smtpSettings.Password, smtpSettings.Domain);
var testEmail = new Email(settings, model.Smtp.TestEmailFromAddress, new List <string> {
model.Smtp.TestEmailToAddress
}, $"{WebAppInfo.Name} test email", "This is a test e-mail");
if (testEmail.TrySend(out errorMessage))
{
return(Content(""));
}
throw new EmailException(errorMessage, ErrorMessages.EmailCannotbeSent);
}
else
{
throw new EmailException(errorMessage, ErrorMessages.EmailServerCannotBeConnected);
}
}
throw new EmailException(errorMessage, ErrorMessages.EmailServerCannotBeConnected);
}
public InstallView(InstallViewModel viewModel)
{
this.InitializeComponent();
this.DataContext = viewModel;
this.Closed += (sender, e) =>
viewModel.CancelCommand.Execute(this);
}
public string BuildCacheConnectionString(InstallViewModel model)
{
string connectionString = "";
var cacheProvider = CacheProviders.Memory; // default
if (!string.IsNullOrEmpty(model.SelectedCacheProvider))
{
Enum.TryParse(model.SelectedCacheProvider, out cacheProvider);
}
switch (cacheProvider)
{
case CacheProviders.Redis:
if (model.CacheConfigs != null)
{
connectionString = CacheProvider.BuildConnectionString(ExtractCacheInfo(model, false));
}
break;
case CacheProviders.Memory:
connectionString = "";
break;
default:
throw new DatabaseException($"{cacheProvider} cache provider not supported",
ErrorMessages.CacheProviderNotSupported.Fmt(cacheProvider));
}
return(connectionString);
}
public string BuildDbConnectionString(InstallViewModel model)
{
string connectionString = "";
var dbProvider = DbProviders.SqlServer; // default
if (!string.IsNullOrEmpty(model.SelectedDatabaseProvider))
{
Enum.TryParse(model.SelectedDatabaseProvider, out dbProvider);
}
switch (dbProvider)
{
case DbProviders.SqlServer:
if (model.SqlServer != null)
{
connectionString = _dbProviderFactory.Create(DbProviders.SqlServer).BuildConnectionString(ExtractDatabaseInfo(model, false));
}
break;
case DbProviders.SQLite:
if (model.Sqlite != null)
{
connectionString = _dbProviderFactory.Create(DbProviders.SQLite).BuildConnectionString(ExtractDatabaseInfo(model, false));
}
break;
default:
throw new DatabaseException($"{dbProvider} database provider not supported",
ErrorMessages.DataProviderNotSupported.Fmt(dbProvider));
}
return(connectionString);
}
public async Task <ActionResult> Register([FromBody] InstallViewModel installation)
{
if (!ModelState.IsValid)
{
return(BadRequest(installation));
}
var user = new ApplicationUser {
FirstName = installation.FirstName, LastName = installation.LastName, UserName = installation.Email, Email = installation.Email
};
var result = await userManager.CreateAsync(user, installation.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
try
{
await roleManager.CreateAsync(new IdentityRole("Administrator"));
await userManager.AddToRoleAsync(user, "Administrator");
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(NoContent());
}
public ActionResult Install(InstallViewModel model)
{
Configuration config = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration(System.Web.HttpContext.Current.Request.ApplicationPath);
ConnectionStringsSection con = (ConnectionStringsSection)config.GetSection("connectionStrings");
con.ConnectionStrings["con"].ConnectionString = $"server={model.ServerHost};database={model.DbName};uid={model.ServerName};pwd={model.ServerPwd}";
config.Save();
SqlConnection con1 = new SqlConnection($"server={model.ServerHost};database=master;uid={model.ServerName};pwd={model.ServerPwd}");
con1.Open();
var cmd = con1.CreateCommand();
cmd.CommandText = $"create database {model.DbName}";
cmd.ExecuteNonQuery();
cmd.CommandText = $"use {model.DbName}";
cmd.ExecuteNonQuery();
var sql = System.IO.File.ReadAllText(Request.MapPath("~/Tools/install.txt"), Encoding.Default);
var setSql = sql.Split(new[] { "go" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in setSql)
{
cmd.CommandText = s;
cmd.ExecuteNonQuery();
}
con1.Close();
return(Content("ok"));
}
public ActionResult Index()
{
bool easyInstall = System.Configuration.ConfigurationManager.AppSettings["EasyInstall"].ToLowerInvariant() == "true";
if (!easyInstall)
{
return(this.Failed("Access is denied. In order to use this feature, please enter a key named EasyInstall with value true on Web.config/AppSettings.", System.Net.HttpStatusCode.Conflict));
}
if (!Directory.Exists(HostingEnvironment.MapPath("~/Resources/_Configs")))
{
return(this.Failed("Cannot continue. The configuration template directory: /Resources/_Configs was not found.", System.Net.HttpStatusCode.Conflict));
}
var model = EasyInstallConfigFile.Get();
if (model == null)
{
model = new InstallViewModel
{
DomainName = this.Request.Url.Host,
DatabaseName = ByConvention.ConvertToTenantName(this.Request.Url.Host),
SqlServer = new SqlServerConfig(),
PostgreSQL = new PostgreSQLConfig()
};
}
return(this.View("~/Views/EasyInstall.cshtml", model));
}
public InstallView(InstallViewModel installViewModel)
{
this.InitializeComponent();
this.DataContext = installViewModel;
//fired when the close button is clicked
this.Closed += (sender, e) => installViewModel.CancelCommand.Execute(this);
}
public InstallView(InstallViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
Closed += (cS, cE) =>
{
viewModel.CancelCommand.Execute(viewModel);
};
}
public IActionResult Index()
{
var vm = new InstallViewModel
{
AuthorizeUrl =
$"{_slackWebApiConfig.AuthorizeUrl}?client_id={_testAppConfig.ClientId}&scope={_testAppConfig.Scope}"
};
return(View(vm));
}
public AttendedViewModel(IInstallationService installationService, InstallViewModel installViewModel, ModifyViewModel modifyViewModel, UninstallViewModel uninstallViewModel)
{
_installationService = installationService;
_installViewModel = installViewModel;
_modifyViewModel = modifyViewModel;
_uninstallViewModel = uninstallViewModel;
_installViewModel.Closed += ChildOnClosed;
_uninstallViewModel.Closed += ChildOnClosed;
}
public ActionResult Index(InstallViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_userService.Create(model.ToUser(_encryption));
return(Redirect("/"));
}
private DatabaseInfo ExtractDatabaseInfo(InstallViewModel model, bool fromConnectionString)
{
DbProviders selectedDbProvider = DbProviders.None;
Enum.TryParse(model.SelectedDatabaseProvider, out selectedDbProvider);
var providerFactory = _dbProviderFactory.Create(selectedDbProvider);
DatabaseInfo dbInfo = null;
switch (selectedDbProvider)
{
case DbProviders.SqlServer:
if (fromConnectionString)
{
dbInfo = new DatabaseInfo(DbProviders.SqlServer, model.SqlServer.ConnectionString);
model.SqlServer.DatabaseServer = dbInfo.DataSource;
model.SqlServer.DatabaseName = dbInfo.InitialCatalog;
if (!string.IsNullOrWhiteSpace(dbInfo.UserName) && !string.IsNullOrWhiteSpace(dbInfo.Password))
{
model.SqlServer.IntegratedSecurity = true;
model.SqlServer.Username = dbInfo.UserName;
model.SqlServer.Password = dbInfo.Password;
}
}
else
{
dbInfo = new DatabaseInfo(DbProviders.SqlServer,
model.SqlServer.DatabaseServer,
model.SqlServer.DatabaseName,
model.SqlServer.IntegratedSecurity ? null : model.SqlServer.Username,
model.SqlServer.IntegratedSecurity ? null : model.SqlServer.Password,
false);
}
break;
case DbProviders.SQLite:
if (model.Advanced)
{
dbInfo = new DatabaseInfo(DbProviders.SQLite, model.Sqlite.ConnectionString);
model.Sqlite.DataSource = dbInfo.DataSource;
model.Sqlite.Password = dbInfo.Password;
}
else
{
dbInfo = new DatabaseInfo(DbProviders.SQLite, model.Sqlite.DataSource, model.Sqlite.DataSource, null, model.Sqlite.Password, true);
}
break;
default:
throw new DatabaseException($"{model.SelectedDatabaseProvider} database provider not supported",
ErrorMessages.DataProviderNotSupported.Fmt(model.SelectedDatabaseProvider));
}
return(dbInfo);
}
void InstallView_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (InstallViewModel.GetViewModel().State == InstallState.Applying)
{
e.Cancel = true;
return;
}
else
{
CustomBootstrapperApplication.Dispatcher.InvokeShutdown();
}
}
public ActionResult VerifyInstallationKey(InstallViewModel model)
{
if (model != null && model.InstallationKey == _rohamConfigs.InstallationPassword)
{
SetKeyVerified(model.Uid, true);
}
else
{
SetKeyVerified(model.Uid, false);
}
return(RedirectToAction("", new { uid = model.Uid }));
}
public PartialViewResult GetDatabaseProviderPartialView(InstallViewModel model)
{
var dbProvider = DbProviders.SqlServer; // default
if (!string.IsNullOrEmpty(model.SelectedDatabaseProvider))
{
Enum.TryParse(model.SelectedDatabaseProvider, out dbProvider);
}
switch (dbProvider)
{
case DbProviders.SqlServer:
if (model.SqlServer == null)
{
var dbInfo = new DatabaseInfo(DbProviders.SqlServer, "localhost", "RohamDb", "", "", true);
model.SqlServer = new SqlServerViewModel
{
ConnectionString = _dbProviderFactory.Create(DbProviders.SqlServer).BuildConnectionString(dbInfo),
DatabaseServer = dbInfo.DataSource,
DatabaseName = dbInfo.InitialCatalog,
Username = dbInfo.UserName,
Password = dbInfo.Password,
};
}
else
{
model.SqlServer.ConnectionString = _dbProviderFactory.Create(DbProviders.SqlServer).BuildConnectionString(ExtractDatabaseInfo(model, model.Advanced));
}
return(PartialView("~/Areas/Admin/Views/Install/_SqlServer.cshtml", model));
case DbProviders.SQLite:
if (model.Sqlite == null)
{
var dbInfo = new DatabaseInfo(DbProviders.SqlServer, "Roham", "RohamDb", "", "", true);
model.Sqlite = new SqliteViewModel
{
ConnectionString = _dbProviderFactory.Create(DbProviders.SQLite).BuildConnectionString(dbInfo),
DataSource = dbInfo.DataSource,
Password = dbInfo.Password,
};
}
else
{
model.Sqlite.ConnectionString = _dbProviderFactory.Create(DbProviders.SQLite).BuildConnectionString(ExtractDatabaseInfo(model, model.Advanced));
}
return(PartialView("~/Areas/Admin/Views/Install/_Sqlite.cshtml", model));
default:
throw new DatabaseException($"{dbProvider} database provider not supported",
ErrorMessages.DataProviderNotSupported.Fmt(dbProvider));
}
}
protected override void Run()
{
Dispatcher = Dispatcher.CurrentDispatcher;
var model = new BootstrapperApplicationModel(this);
var viewModel = new InstallViewModel(model);
view = new InstallView(viewModel);
restreq = new restart();
model.SetWindowHandle(view);
this.Engine.Detect();
view.Show();
Dispatcher.Run();
this.Engine.Quit(model.FinalResult);
}
public ActionResult TestSmtpConnect(InstallViewModel model)
{
var smtpSettings = model?.Smtp;
string errorMessage = "Email server settings invalid";
if (smtpSettings != null)
{
if (Email.TryPingHost(smtpSettings.Host, smtpSettings.Port, out errorMessage))
{
return(Content(""));
}
}
throw new EmailException(errorMessage, ErrorMessages.EmailServerCannotBeConnected);
}
internal static string WriteConfig(InstallViewModel model)
{
string pathToConfigTemplateDirectory = HostingEnvironment.MapPath("~/Resources/_Configs");
string pathToConfigDirectory = HostingEnvironment.MapPath("~/Resources/Configs");
if (!Directory.Exists(pathToConfigDirectory))
{
FileSystem.CopyDirectory(pathToConfigTemplateDirectory, pathToConfigDirectory);
}
WriteFile(model.SqlServer, "~/Resources/Configs/SQLServer.json");
WriteFile(model.PostgreSQL, "~/Resources/Configs/PostgreSQL.json");
WriteFile(new[]
{
new
{
model.DbProvider,
model.DomainName,
model.DatabaseName,
EnforceSsl = false,
CdnDomain = "",
Synonyms = new string[] { },
BackupDirectory = "",
BackupDirectoryIsFixedPath = false,
AdminEmail = model.ApplicationUser,
BcryptedAdminPassword = PasswordManager.GetHashedPassword(model.ApplicationUser, model.ApplicationUserPassword)
}
}, "~/Resources/Configs/DomainsApproved.json");
WriteFile(new
{
Cultures = "en",
ApplicationLogDirectory = @"C:\frapid-logs",
MinimumLogLevel = "Information",
BackupScheduleUTC = "0, 15",
EodScheduleUTC = "0, 5",
model.DefaultCacheType,
IsDevelopment = true
}, "~/Resources/Configs/Parameters.json");
WriteFile(new
{
ConfigString = model.RedisConnectionString
}, "~/Resources/Configs/RedisConfig.json");
return("OK");
}
public InstallViewModel UpdateModel()
{
List <DatabaseListItem> allDatabases = new List <DatabaseListItem>()
{
new DatabaseListItem()
{
Id = 1, Name = "MSSQL"
}, new DatabaseListItem()
{
Id = 2, Name = "MySQL"
}
};
try
{
// Every request will be granted the most up-to-date data
Configuration.GlobalWebsiteConfig.RefreshData();
// View model
InstallViewModel model = new InstallViewModel();
// HTML Select
model.AllDatabases = allDatabases;
// If the installation was completed, the user is shown actual connection string and database in use
if (Configuration.GlobalWebsiteConfig.InstallationCompleted)
{
int idOfDb = 1;
switch (Configuration.GlobalWebsiteConfig.TypeOfDatabase)
{
case "mssql": idOfDb = 1; break;
case "mysql": idOfDb = 2; break;
}
model.SelectedDatabase = idOfDb;
model.ConnectionString = Configuration.GlobalWebsiteConfig.ConnectionString;
model.RecreateDatabase = false; // by default unchecked
}
return(model);
}
catch
{
InstallViewModel model = new InstallViewModel();
model.AllDatabases = allDatabases;
model.ConnectionString = string.Empty;
model.SelectedDatabase = default(int);
return(model);
}
}
public async Task <ActionResult> Index(InstallViewModel model)
{
// Self registration is active as long as the administrator was not created yet
var roleExists = await _rolesRepository.RoleExists(RoleConstants.SuperAdminRole);
if (roleExists)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
var user = _usersRepository.Get().SingleOrDefault(x => x.Email == model.Email);
if (user == null)
{
user = new ApplicationUser
{
Email = model.Email,
UserName = model.Email,
};
var userResult = await UserManager.CreateAsync(user, model.Password);
if (userResult.Succeeded)
{
await SendAdminEmailConfirmation(user.Id, "Confirm your account");
ViewBag.Message = ViewResource.RegisterConfirmationMessage;
return(View("Info"));
}
else
{
AddErrors(userResult);
}
}
else
{
await SendAdminEmailConfirmation(user.Id, "Confirm your account");
ViewBag.Message = ViewResource.RegisterConfirmationMessage;
return(View("Info"));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult Index()
{
var appSettings = _installAppService.GetAppSettingsJson();
if (DatabaseCheckHelper.Exist(appSettings.ConnectionString))
{
return(RedirectToAction("Index", "Home"));
}
var model = new InstallViewModel
{
Languages = DefaultLanguagesCreator.InitialLanguages,
AppSettingsJson = appSettings
};
return(View(model));
}
public ActionResult Index()
{
var appSettings = _installAppService.GetAppSettingsJson();
var connectionString = _appConfiguration[$"ConnectionStrings:{PortalConsts.ConnectionStringName}"];
if (_databaseCheckHelper.Exist(connectionString))
{
return(RedirectToAction("Index", "Home"));
}
var model = new InstallViewModel
{
Languages = DefaultLanguagesCreator.InitialLanguages,
AppSettingsJson = appSettings
};
return(View(model));
}
//This is our UI's primary entry point. This method will be called by the Burn engine.
protected override void Run()
{
//Dispatcher object provides a means for sending messages between the UI thread and any backend threads.
Dispatcher = Dispatcher.CurrentDispatcher;
//MVVM pattern
var model = new BootstrapperApplicationModel(this);
var viewModel = new InstallViewModel(model);
var view = new InstallView(viewModel);
// Sets the handle for a Windows Presentation Foundation (WPF) window.
// This handle is used by the Burn engine when performing the install or uninstall.
model.SetWindowHandle(view);
//This will start the Burn engine. engine will go-ahead to check if our bundle is already installed.
this.Engine.Detect();
//This code is to wait for a second before closing our flash screen. Otherwise the WPF window will load very fast.
var timer = new DispatcherTimer {
Interval = TimeSpan.FromSeconds(1)
};
timer.Start();
timer.Tick += (sender, args) =>
{
model.LogMessage("Time elapsed.Loading the window");
timer.Stop();
view.Show();
};
//This event is fired when the window is loaded. Here we are closing the flash screen.
view.Loaded += (sender, e) =>
{
model.LogMessage("FrameworkElement loaded event fired.");
model.CustomBootstrapperApplication.Engine.CloseSplashScreen();
};
//halts execution of this method at that line until the Dispatcher is shut down.
Dispatcher.Run();
//shut down the Burn engine
this.Engine.Quit(model.FinalResult);
}
public PartialViewResult GetCacheProviderPartialView(InstallViewModel model)
{
var cacheProvider = CacheProviders.Memory; // default
if (!string.IsNullOrEmpty(model.SelectedCacheProvider))
{
Enum.TryParse(model.SelectedCacheProvider, out cacheProvider);
}
switch (cacheProvider)
{
case CacheProviders.Redis:
if (model.CacheConfigs == null)
{
string hostName = "localhost";
int port = 6379;
model.CacheConfigs = new CacheConfigsViewModel
{
Provider = CacheProviders.Redis,
Host = hostName,
Port = port,
ConnectionString = CacheProvider.BuildConnectionString(new CacheInfo(CacheProviders.Redis, hostName, port))
};
}
else
{
model.CacheConfigs.Provider = CacheProviders.Redis;
model.CacheConfigs.ConnectionString = CacheProvider.BuildConnectionString(ExtractCacheInfo(model, model.AdvancedCache));
}
return(PartialView("~/Areas/Admin/Views/Install/_Cache.cshtml", model));
case CacheProviders.Memory:
model.CacheConfigs = new CacheConfigsViewModel
{
Provider = CacheProviders.Memory,
};
model.CacheConfigs.ConnectionString = "";
return(PartialView("~/Areas/Admin/Views/Install/_Cache.cshtml", model));
default:
throw new DatabaseException($"{cacheProvider} cache provider not supported",
ErrorMessages.CacheProviderNotSupported.Fmt(cacheProvider));
}
}
private CacheInfo ExtractCacheInfo(InstallViewModel model, bool fromConnectionString)
{
var selectedCacheProvider = CacheProviders.Memory;
Enum.TryParse(model.SelectedCacheProvider, out selectedCacheProvider);
var cacheConfigs = model?.CacheConfigs;
if (cacheConfigs == null)
{
cacheConfigs = new CacheConfigsViewModel();
}
cacheConfigs.Provider = selectedCacheProvider;
CacheInfo cacheInfo = null;
switch (selectedCacheProvider)
{
case CacheProviders.Memory:
cacheInfo = new CacheInfo(CacheProviders.Memory);
break;
case CacheProviders.Redis:
if (fromConnectionString)
{
cacheInfo = CacheProvider.CreateInfo(CacheProviders.Redis, model.CacheConfigs.ConnectionString);
model.CacheConfigs.Host = cacheInfo.Host;
model.CacheConfigs.Port = cacheInfo.Port;
model.CacheConfigs.Ssl = cacheInfo.Ssl;
}
else
{
cacheInfo = new CacheInfo(CacheProviders.Redis, cacheConfigs.Host, cacheConfigs.Port, cacheConfigs.Ssl, cacheConfigs.Password);
}
break;
default:
throw new CacheExeption($"{model.SelectedCacheProvider} cache provider not supported",
ErrorMessages.CacheProviderNotSupported.Fmt(model.SelectedCacheProvider));
}
return(cacheInfo);
}
public async Task <IActionResult> Index(InstallViewModel model)
{
if (installed)
{
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
await registerRoles();
if (await registerUserAsync(model.Email, model.Password, Role.ROLE_ADMIN))
{
return(RedirectToAction("Installed"));
}
else
{
return(View(model));
}
}
return(View(model));
}
public ActionResult Index(string uid = null)
{
if (!_rohamConfigs.IsInstalled)
{
var dbInfo = new DatabaseInfo(DbProviders.SqlServer, "localhost", WebAppInfo.Name, "", "", true);
var vm = new InstallViewModel
{
SelectedDatabaseProvider = dbInfo.DbProvider.ToString(),
IsInstalled = false,
SqlServer = new SqlServerViewModel
{
ConnectionString = _dbProviderFactory.Create(dbInfo.DbProvider).BuildConnectionString(dbInfo),
DatabaseServer = dbInfo.DataSource,
DatabaseName = dbInfo.InitialCatalog,
Username = dbInfo.UserName,
Password = dbInfo.Password,
},
SelectedCacheProvider = CacheProviders.Memory.ToString(),
SelectedEmailProvider = "smtp",
CacheConfigs = null,
InstallationKey = "",
};
if (IsKeyVerified(uid))
{
ViewBag.KeyVerified = true;
}
else if (uid != null)
{
ModelState.AddModelError(nameof(ErrorMessages.InstallationKeyInvalid), ErrorMessages.InstallationKeyInvalid);
}
return(View("Install", vm));
}
else
{
return(RedirectToAction("upgrade"));
}
}
