public override async Task SetUp(SetUpContext context, Action <string, string> reportError)
{
// Build schemas
using (var builder = _schemaBuilder)
{
// configure
Configure(builder);
// user schema
Users(builder);
// photo schema
UserPhoto(builder);
// banner schema
UserBanner(builder);
// meta data schema
UserData(builder);
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
// Configure default users
await ConfigureDefaultUsers(context, reportError);
// Configure administrator
await ConfigureSuperUser(context, reportError);
}
public override async Task SetUp(
SetUpContext context,
Action <string, string> reportError)
{
// --------------------------
// Add default settings to dictionary store
// --------------------------
try
{
var siteSettings = await _siteSettingsStore.GetAsync() ?? new SiteSettings();
siteSettings.SiteName = context.SiteName;
siteSettings.SuperUser = context.AdminUsername;
siteSettings.ApiKey = _keyGenerator.GenerateKey();
siteSettings.HomeRoute = new HomeRoute();
await _siteSettingsStore.SaveAsync(siteSettings);
}
catch (Exception ex)
{
reportError(ex.Message, ex.StackTrace);
}
// --------------------------
// Apply default permissions to default roles for new feature
// --------------------------
await _defaultRolesManager.UpdateDefaultRolesAsync(new Permissions());
}
public IOrType <IProject <TAssembly, TBacking>, IReadOnlyList <IError> > Parse <TAssembly, TBacking>(string text, IReadOnlyList <TAssembly> dependencies, string name)
where TAssembly : IAssembly <TBacking>
{
var tokenizer = new Tokenizer(StaticSymbolsRegistry.SymbolsRegistry.Symbols.Except(new[] { SymbolsRegistry.StaticSubtractSymbol }).ToArray());
var tokens = tokenizer.Tokenize(text);
var elementMatchingContest = new ElementMatchingContext();
var scopePopulator = elementMatchingContest.ParseFile(tokens);
var dependencyConverter = new DependencyConverter();
var problem = new Tpn.TypeProblem2(new WeakScopeConverter(), scopePopulator, prob => {
foreach (var dependency in dependencies)
{
var type = prob.builder.CreateTypeExternalType(prob.Dependency, new WeakTypeDefinitionConverter(), dependency.Scope);
foreach (var memberPair in dependency.Scope.Members)
{
var innerType = ConvertType(prob.builder, type, OrType.Make <IVerifiableType, IError>(memberPair.Type));
innerType.Switch(x =>
{
prob.builder.CreatePublicMember(type, type, memberPair.Key, OrType.Make <IKey, IError>(x));
}, y =>
{
prob.builder.CreatePublicMember(type, memberPair.Key, y);
});
}
prob.builder.CreatePrivateMember(prob.Dependency, dependency.Key, OrType.Make <Tpn.TypeProblem2.MethodType, Tpn.TypeProblem2.Type, Tpn.TypeProblem2.Object, Tpn.TypeProblem2.OrType, Tpn.TypeProblem2.InferredType, Tpn.TypeProblem2.GenericTypeParameter, IError>(type));
}
});
var populateScopeContex = new SetUpContext(problem.builder);
var referanceResolver = scopePopulator.Run(problem.ModuleRoot, populateScopeContex).Resolve;
var solution = problem.Solve();
var rootScope = referanceResolver.Run(solution, new List <Tpn.ITypeProblemNode>()
{
problem.Dependency,
problem.ModuleRoot
}).GetValue();
var errors = rootScope.Validate().ToArray();
if (errors.Any())
{
return(OrType.Make <IProject <TAssembly, TBacking>, IReadOnlyList <IError> >(errors));
}
var dependencyScope = problem.Dependency.Converter.Convert(solution, problem.Dependency, Array.Empty <Tpn.ITypeProblemNode>()).Is2OrThrow();
var context = TransformerExtensions.NewConversionContext();
return(OrType.Make <IProject <TAssembly, TBacking>, IReadOnlyList <IError> >(new Project <TAssembly, TBacking>(rootScope.Convert(context), dependencies, dependencyScope.Convert(context))));
}
async Task ConfigureDefaultUsers(SetUpContext context, Action <string, string> reportError)
{
try
{
// create super user
var result1 = await _userManager.CreateAsync(new User()
{
Email = context.AdminEmail,
UserName = context.AdminUsername,
PhotoColor = _userColorProvider.GetColor(),
EmailConfirmed = true,
IsVerified = true,
IsVerifiedUpdatedUserId = 1,
IsVerifiedUpdatedDate = DateTimeOffset.UtcNow
}, context.AdminPassword);
if (!result1.Succeeded)
{
foreach (var error in result1.Errors)
{
reportError(error.Code, error.Description);
}
}
// create default plato bot
var result2 = await _userManager.CreateAsync(new User()
{
Email = "*****@*****.**",
UserName = "******",
DisplayName = "Plato Bot",
Biography = "I'm not a real person. I'm a bot that keeps an eye on things.",
EmailConfirmed = true,
IsVerified = true,
IsVerifiedUpdatedUserId = 1,
IsVerifiedUpdatedDate = DateTimeOffset.UtcNow,
PhotoUrl = "/images/bot.png",
PhotoColor = _userColorProvider.GetColor(),
UserType = UserType.Bot
}, context.AdminPassword);
if (!result2.Succeeded)
{
foreach (var error in result2.Errors)
{
reportError(error.Code, error.Description);
}
}
}
catch (Exception ex)
{
reportError(ex.Message, ex.StackTrace);
}
}
public async Task <string> SetUpAsync(SetUpContext context)
{
var initialState = _shellSettings.State;
try
{
return(await SetUpInternalAsync(context));
}
catch (Exception ex)
{
context.Errors.Add(ex.Message, ex.Message);
_shellSettings.State = initialState;
throw;
}
}
internal static WeakRootScope ConvertToWeak(FileToken fileToken)
{
var elementMatchingContest = new ElementMatchingContext();
var scopePopulators = elementMatchingContest.ParseFile(fileToken);
var problem = new Tpn.TypeProblem2(new WeakScopeConverter(), scopePopulators, _ => { });
var populateScopeContex = new SetUpContext(problem.builder);
var referanceResolver = scopePopulators.Run(problem.ModuleRoot, populateScopeContex).Resolve;
var solution = problem.Solve();
var res = referanceResolver.Run(solution, new List <Tpn.ITypeProblemNode>());
return(res.GetValue());
}
public override async Task SetUp(SetUpContext context, Action <string, string> reportError)
{
using (var builder = _schemaBuilder)
{
// configure
Configure(builder);
// User reputations
UserReputations(builder);
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
}
public override async Task SetUp(SetUpContext context, Action <string, string> reportError)
{
//var schemaBuilder = context.ServiceProvider.GetRequiredService<ISchemaBuilder>();
using (var builder = _schemaBuilder)
{
// configure
Configure(builder);
// Emails schema
Emails(builder);
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
}
async Task ConfigureSuperUser(SetUpContext context, Action <string, string> reportError)
{
// Get newly installed administrator role
var role = await _roleManager.FindByNameAsync(DefaultRoles.Administrator);
// Get newly created administrator user
var user = await _userManager.FindByNameAsync(context.AdminUsername);
// Add our administrator user to the administrator role
var dirty = false;
if (role != null && user != null)
{
if (!await _userManager.IsInRoleAsync(user, role.Name))
{
var result = await _userManager.AddToRoleAsync(user, role.Name);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
reportError(error.Code, error.Description);
}
}
dirty = true;
}
}
if (dirty)
{
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
reportError(error.Code, error.Description);
}
}
}
}
public override async Task SetUp(SetUpContext context, Action <string, string> reportError)
{
using (var builder = _schemaBuilder)
{
// configure
Configure(builder);
// roles
Roles(builder);
// user roles
UserRoles(builder);
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
// Install default roles & permissions on first set-up
await _defaultRolesManager.InstallDefaultRolesAsync();
}
public override async Task SetUp(SetUpContext context, Action <string, string> reportError)
{
// --------------------------
// Build core schemas
// --------------------------
using (var builder = _schemaBuilder)
{
// configure
Configure(builder);
// features schema
Features(builder);
// Did any errors occur?
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
}
public override Task SetUp(
SetUpContext context,
Action <string, string> reportError)
{
return(Task.CompletedTask);
}
public override async Task SetUp(
SetUpContext context,
Action <string, string> reportError)
{
// --------------------------
// Build core schemas
// --------------------------
var dictionaryTable = new SchemaTable()
{
Name = "DictionaryEntries",
Columns = new List <SchemaColumn>()
{
new SchemaColumn()
{
PrimaryKey = true,
Name = "Id",
DbType = DbType.Int32
},
new SchemaColumn()
{
Name = "[Key]",
Length = "255",
DbType = DbType.String
},
new SchemaColumn()
{
Name = "[Value]",
Length = "max",
DbType = DbType.String
},
new SchemaColumn()
{
Name = "CreatedUserId",
DbType = DbType.Int32
},
new SchemaColumn()
{
Name = "CreatedDate",
DbType = DbType.DateTimeOffset
},
new SchemaColumn()
{
Name = "ModifiedUserId",
DbType = DbType.Int32
},
new SchemaColumn()
{
Name = "ModifiedDate",
DbType = DbType.DateTimeOffset,
Nullable = true
}
}
};
var documentTable = new SchemaTable()
{
Name = "DocumentEntries",
Columns = new List <SchemaColumn>()
{
new SchemaColumn()
{
PrimaryKey = true,
Name = "Id",
DbType = DbType.Int32
},
new SchemaColumn()
{
Name = "[Type]",
Length = "500",
DbType = DbType.String
},
new SchemaColumn()
{
Name = "[Value]",
Length = "max",
DbType = DbType.String
},
new SchemaColumn()
{
Name = "CreatedDate",
DbType = DbType.DateTimeOffset
},
new SchemaColumn()
{
Name = "CreatedUserId",
DbType = DbType.Int32
},
new SchemaColumn()
{
Name = "ModifiedDate",
DbType = DbType.DateTimeOffset
},
new SchemaColumn()
{
Name = "ModifiedUserId",
DbType = DbType.Int32,
Nullable = true
}
}
};
using (var builder = _schemaBuilder)
{
// Build dictionary store
// --------------------------
builder
.Configure(options =>
{
options.ModuleName = "Plato.Core";
options.Version = "1.0.0";
});
builder.TableBuilder.CreateTable(dictionaryTable);
builder.ProcedureBuilder.CreateDefaultProcedures(dictionaryTable)
.CreateProcedure(
new SchemaProcedure("SelectDictionaryEntryByKey", StoredProcedureType.SelectByKey)
.ForTable(dictionaryTable).WithParameter(new SchemaColumn()
{
Name = "[Key]",
Length = "255",
DbType = DbType.String
}));
builder.ProcedureBuilder.CreateDefaultProcedures(dictionaryTable)
.CreateProcedure(
new SchemaProcedure("DeleteDictionaryEntryByKey", StoredProcedureType.DeleteByKey)
.ForTable(dictionaryTable).WithParameter(new SchemaColumn()
{
Name = "[Key]",
Length = "255",
DbType = DbType.String
}));
// Build document store
// --------------------------
builder
.Configure(options =>
{
options.ModuleName = "Plato.Core";
options.Version = "1.0.0";
});
builder.TableBuilder.CreateTable(documentTable);
builder.ProcedureBuilder
.CreateDefaultProcedures(documentTable)
.CreateProcedure(
new SchemaProcedure("SelectDocumentEntryByType", StoredProcedureType.SelectByKey)
.ForTable(documentTable)
.WithParameter(new SchemaColumn()
{
Name = "[Type]",
Length = "500",
DbType = DbType.String
}));
// Did any errors occur?
var errors = await _schemaManager.ExecuteAsync(builder.Statements);
foreach (var error in errors)
{
reportError(error, $"SetUp within {this.GetType().FullName} - {error}");
}
}
}
public async Task <IActionResult> Index(SetUpViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
if (!string.IsNullOrEmpty(_shellSettings.ConnectionString))
{
model.ConnectionStringPreset = true;
model.ConnectionString = _shellSettings.ConnectionString;
}
if (!string.IsNullOrEmpty(_shellSettings.TablePrefix))
{
model.TablePrefixPreset = true;
model.TablePrefix = _shellSettings.TablePrefix;
}
var setupContext = new SetUpContext()
{
SiteName = model.SiteName,
DatabaseProvider = "SqlClient",
DatabaseConnectionString = model.ConnectionString,
AdminUsername = model.UserName,
AdminEmail = model.Email,
AdminPassword = model.Password,
Errors = new Dictionary <string, string>()
};
if (!model.TablePrefixPreset)
{
setupContext.DatabaseTablePrefix = model.TablePrefix;
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"Beginning call to SetUpAsync");
}
var executionId = await _setUpService.SetUpAsync(setupContext);
// Check if a component in the Setup failed
if (setupContext.Errors.Count > 0)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"Set-up of tenant '{setupContext.SiteName}' failed with the following errors...");
}
foreach (var error in setupContext.Errors)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation(error.Key + " " + error.Value);
}
ModelState.AddModelError(error.Key, error.Value);
}
return(View(model));
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"Tenant with site name '{setupContext.SiteName}' created successfully");
}
return(Redirect("~/"));
}
async Task <string> SetUpInternalAsync(SetUpContext context)
{
// Set shell state to "Initializing" so that subsequent HTTP requests are responded to with "Service Unavailable" while Orchard is setting up.
_shellSettings.State = TenantState.Initializing;
var executionId = Guid.NewGuid().ToString("n");
var shellSettings = new ShellSettings(_shellSettings.Configuration);
shellSettings.Name = context.SiteName;
shellSettings.Location = context.SiteName.ToSafeFileName();
if (string.IsNullOrEmpty(shellSettings.DatabaseProvider))
{
var tablePrefix = context.DatabaseTablePrefix;
if (!tablePrefix.EndsWith(TablePrefixSeparator))
{
tablePrefix += TablePrefixSeparator;
}
shellSettings.DatabaseProvider = context.DatabaseProvider;
shellSettings.ConnectionString = context.DatabaseConnectionString;
shellSettings.TablePrefix = tablePrefix;
}
using (var shellContext = _shellContextFactory.CreateMinimalShellContext(shellSettings))
{
using (var scope = shellContext.ServiceProvider.CreateScope())
{
using (var dbContext = scope.ServiceProvider.GetRequiredService <IDbContext>())
{
// update dbContext confirmation
dbContext.Configure(options =>
{
options.ConnectionString = shellSettings.ConnectionString;
options.DatabaseProvider = shellSettings.DatabaseProvider;
options.TablePrefix = shellSettings.TablePrefix;
});
var hasErrors = false;
void ReportError(string key, string message)
{
hasErrors = true;
context.Errors[key] = message;
}
// Invoke modules to react to the setup event
var setupEventHandlers = scope.ServiceProvider.GetServices <ISetUpEventHandler>();
var logger = scope.ServiceProvider.GetRequiredService <ILogger <SetUpService> >();
await setupEventHandlers.InvokeAsync(x => x.SetUp(context, ReportError), logger);
if (hasErrors)
{
return(executionId);
}
}
}
}
if (context.Errors.Count > 0)
{
return(executionId);
}
shellSettings.State = TenantState.Running;
_platoHost.UpdateShellSettings(shellSettings);
return(executionId);
}