public void WaveLengthTest(double waveLength)
{
var initialData = new InitialData();
initialData.WaveLength = waveLength;
}
private static byte[] GetBuffer(InitialData data, string providerData, string propertyTypeName)
{
return(data.GetBlobBytes(providerData, propertyTypeName));
}
protected static InitialData GetInitialData()
{
return(_initialData ?? (_initialData = InitialData.Load(InMemoryTestData.Instance)));
}
public Monster(InitialData init, SyncData sync) : base(init, sync)
{
CreatePrefab();
}
public static void AddTower(InitialData init, SyncData sync)
{
towers.Add(sync.objID, new Tower(init, sync));
}
private static async Task EnsureData(
ISiteQueries siteQueries,
ISiteCommands siteCommands,
IUserQueries userQueries,
IUserCommands userCommands,
IGeoQueries geoQueries,
IGeoCommands geoCommands,
IBasicQueries <SiteRole> roleQueries,
IBasicQueries <SiteUser> userBasic,
IProjectResolver projectResolver
)
{
int count = await geoQueries.GetCountryCount();
if (count == 0)
{
foreach (GeoCountry c in InitialData.BuildCountryList())
{
await geoCommands.Add(c);
}
foreach (GeoZone c in InitialData.BuildStateList())
{
await geoCommands.Add(c);
}
}
count = await geoQueries.GetLanguageCount();
if (count == 0)
{
foreach (Language c in InitialData.BuildLanguageList())
{
await geoCommands.Add(c);
}
}
var all = await geoQueries.GetAllCurrencies();
count = all.Count;
if (count == 0)
{
foreach (Currency c in InitialData.BuildCurrencyList())
{
await geoCommands.Add(c);
}
}
count = await siteQueries.GetCount();
SiteSettings newSite = null;
if (count == 0)
{
// create first site
newSite = InitialData.BuildInitialSite();
await siteCommands.Create(newSite);
}
// ensure roles
var projectId = await projectResolver.ResolveProjectId();
count = await roleQueries.GetCountAsync(projectId);
if (count == 0)
{
var adminRole = InitialData.BuildAdminRole();
adminRole.SiteId = newSite.Id;
await userCommands.CreateRole(adminRole);
var roleAdminRole = InitialData.BuildRoleAdminRole();
roleAdminRole.SiteId = newSite.Id;
await userCommands.CreateRole(roleAdminRole);
var contentAdminRole = InitialData.BuildContentAdminsRole();
contentAdminRole.SiteId = newSite.Id;
await userCommands.CreateRole(contentAdminRole);
var authenticatedUserRole = InitialData.BuildAuthenticatedRole();
authenticatedUserRole.SiteId = newSite.Id;
await userCommands.CreateRole(authenticatedUserRole);
}
// ensure admin user
count = await userBasic.GetCountAsync(projectId);
if (count == 0)
{
var role = await userQueries.FetchRole(newSite.Id, "Administrators");
if (role != null)
{
var adminUser = InitialData.BuildInitialAdmin();
adminUser.SiteId = newSite.Id;
await userCommands.Create(adminUser);
await userCommands.AddUserToRole(role.Id, adminUser.Id);
role = await userQueries.FetchRole(newSite.Id, "Authenticated Users");
if (role != null)
{
await userCommands.AddUserToRole(role.Id, adminUser.Id);
}
}
}
}
/// <summary>
/// Sets the <see cref="InitialData"/> that will be installed to the database in the repository start sequence.
/// </summary>
/// <param name="repositoryBuilder"></param>
/// <param name="initialData">Data file instance.</param>
/// <returns></returns>
public static IRepositoryBuilder UseInitialData(this IRepositoryBuilder repositoryBuilder, InitialData initialData)
{
if (!(repositoryBuilder is RepositoryBuilder repoBuilder))
{
throw new ApplicationException(
$"The repositoryBuilder is not an instance of {typeof(RepositoryBuilder).FullName}.");
}
repoBuilder.InitialData = initialData;
return(repositoryBuilder);
}
public async Task DoSetupStep(
Func <string, bool, Task> output,
Func <string, bool> appNeedsUpgrade,
Func <string, Version> schemaVersionLookup,
Func <string, Version> codeVersionLookup
)
{
bool needsUpgrade = appNeedsUpgrade("cloudscribe-core");
if (needsUpgrade)
{
await output("cloudscribe-core needs schema upgrade", false);
return;
}
Version codeVersion = codeVersionLookup("cloudscribe-core");
Version schemaVersion = schemaVersionLookup("cloudscribe-core");
if (codeVersion == null)
{
await output("cloudscribe-core code version not found", false);
}
if (schemaVersion == null)
{
await output("cloudscribe-core schema version not found", false);
}
if ((codeVersion != null) && (schemaVersion != null))
{
if (codeVersion == schemaVersion)
{
var message = string.Format(
"cloudscribe-core schema is up to date at version: {0}",
codeVersion
);
await output(message, false);
}
else
{
var message = string.Format(
"cloudscribe-core code version: {0} is out of sync with schema version: {1}",
codeVersion,
schemaVersion
);
await output(message, false);
}
}
int countryCount = await geoDataManager.GetCountryCount();
if (countryCount == 0)
{
await output("creating initial country data", true);
List <GeoCountry> countries = InitialData.BuildCountryList();
foreach (GeoCountry c in countries)
{
await geoDataManager.Add(c);
}
await output("creating initial state/region data", true);
List <GeoZone> states = InitialData.BuildStateList();
foreach (GeoZone s in states)
{
await geoDataManager.Add(s);
}
}
List <ICurrency> dbCurrencies = await geoDataManager.GetAllCurrencies();
if (dbCurrencies.Count == 0)
{
await output("creating initial currency data", true);
List <Currency> currencies = InitialData.BuildCurrencyList();
foreach (Currency c in currencies)
{
await geoDataManager.Add(c);
}
}
//int languageCount = await geoDataManager.GetLanguageCount();
//if(languageCount == 0)
//{
// await output("creating initial language data", true);
// List<Language> langs = InitialData.BuildLanguageList();
// foreach(Language l in langs)
// {
// await geoDataManager.Add(l);
// }
//}
int existingSiteCount = await siteManager.ExistingSiteCount();
await output(
string.Format(
"ExistingSiteCount {0}", //SetupResources.ExistingSiteCountMessage,
existingSiteCount.ToString()),
false);
if (existingSiteCount == 0)
{
await output("CreatingSite", true);
SiteSettings newSite = await siteManager.CreateNewSite(true);
await output("CreatingRolesAndAdminUser", true);
await siteManager.CreateRequiredRolesAndAdminUser(newSite);
existingSiteCount = await siteManager.ExistingSiteCount();
if (existingSiteCount > 0)
{
await output(BuildHomeLink(), false);
}
}
else
{
// check here if count of users is 0
// if something went wrong with creating admin user
// setup page should try to correct it on subsequent runs
// ie create an admin user if no users exist
if (contextAccessor.HttpContext.Request.Host.HasValue)
{
var site = await siteManager.Fetch(contextAccessor.HttpContext.Request.Host.Value);
if (site != null)
{
int roleCount = await siteManager.GetRoleCount(site.Id);
if (roleCount == 0)
{
await output("CreatingRoles", true);
await siteManager.EnsureRequiredRoles(site);
}
int userCount = await siteManager.GetUserCount(site.Id);
if (userCount == 0)
{
await output("CreatingAdminUser", true);
await siteManager.CreateAdminUser(site);
}
}
}
await output(BuildHomeLink(), false);
}
}
public FormInput(InitialData objInitialData)
: base(objInitialData)
{
this._objInitialData = objInitialData;
}
/// <summary>
/// Clears the security storage copies ids of the full content tree structure from the repository
/// to the security component. Security component must be available.
/// WARNING! Use only in install scenarios.
/// </summary>
public void InstallDefaultSecurityStructure(InitialData data = null)
{
using (var op = SnTrace.System.StartOperation("Installing default security structure."))
{
using (new SystemAccount())
{
CreateEntities();
var ed = _securityHandler.CreateAclEditor();
ed.Allow(Identifiers.PortalRootId, Identifiers.AdministratorsGroupId, false,
// ReSharper disable once CoVariantArrayConversion
PermissionType.BuiltInPermissionTypes);
var schema = _storageSchema;
var memberPropertyType = schema.PropertyTypes["Members"];
var userNodeType = schema.NodeTypes["User"];
var groupNodeType = schema.NodeTypes["Group"];
if (data?.DynamicProperties != null)
{
foreach (var versionData in data.DynamicProperties)
{
if (versionData.DynamicProperties == null)
{
continue;
}
var properties = versionData.ReferenceProperties;
List <int> references = null;
foreach (var property in properties)
{
if (property.Key.Name == "Members")
{
references = (List <int>)property.Value;
break;
}
}
if (references == null)
{
continue;
}
var versionId = versionData.VersionId;
var nodeId = data.Versions.First(x => x.VersionId == versionId).NodeId;
var heads = NodeHead.Get(references);
var userMembers = new List <int>();
var groupMembers = new List <int>();
foreach (var head in heads)
{
var nodeType = head.GetNodeType();
if (nodeType.IsInstaceOfOrDerivedFrom(userNodeType))
{
userMembers.Add(head.Id);
}
if (nodeType.IsInstaceOfOrDerivedFrom(groupNodeType))
{
groupMembers.Add(head.Id);
}
}
_securityHandler.AddMembers(nodeId, userMembers, groupMembers);
}
}
if (data == null)
{
ed.Apply();
}
else
{
ed.Apply(ParseInitialPermissions(ed.Context, data.Permissions));
}
}
op.Successful = true;
}
}
void Start()
{
initData = GameObject.Find("SystemData").GetComponent <InitialData>();
text = GetComponent <Text>();
gold = initData.gold;
}
public void StepsTestTest(int steps)
{
var initialData = new InitialData();
initialData.Steps = steps;
}
public void RangeMaxTest(double rangeMax)
{
var initialData = new InitialData();
initialData.RangeMax = rangeMax;
}
public void RangeMinTest(double rangeMin)
{
var initialData = new InitialData();
initialData.RangeMin = rangeMin;
}
public double plotPointKernelPCA(double x, double y)
{
var point = new double[1, 2];
point[0, 0] = x;
point[0, 1] = y;
int nr = initialData.Rows();
double[] distance = new double[nr];
for (int i = 0; i < initialData.Rows(); i++)
{
distance[i] = (Math.Pow(x - (InitialData.GetRow(i)[0]), 2)) + (Math.Pow(y - (InitialData.GetRow(i)[1]), 2));
}
double[] k = new double[nr];
double[] normalize = new double[nr];
for (int i = 0; i < nr; i++)
{
//double aux = (-Gamma * Math.Pow(distance[i], 2));
double aux = (-Gamma * distance[i]);
k[i] = Math.Pow(Math.E, aux);
normalize[i] = KernelVectors[i] / KernelValues;
}
return(k.Dot(normalize));
}
public void SetUp()
{
_initialData = new InitialData(_name, _value, _confidenceFactor);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, InitialData seedDbContext)
{
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseSpaStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller}/{action=Index}/{id?}");
});
app.UseSpa(spa =>
{
// To learn more about options for serving an Angular SPA from ASP.NET Core,
// see https://go.microsoft.com/fwlink/?linkid=864501
spa.Options.SourcePath = "ClientApp";
if (env.IsDevelopment())
{
spa.UseAngularCliServer(npmScript: "start");
}
});
seedDbContext.SeedData();
}
public static void Init()
{
InitialData.Init();
}
public static IRepositoryBuilder BuildInMemoryRepository(this IRepositoryBuilder repositoryBuilder)
{
return(BuildInMemoryRepository(repositoryBuilder,
InitialData.Load(SenseNetServicesData.Instance, null),
GetInitialIndex()));
}
public HomeController(ILogger <HomeController> logger, InitialData initial)
{
_logger = logger;
_initial = initial;
}
public Fireground(InitialData init, SyncData sync) : base(init, sync)
{
CreatePrefab();
}
public void init()
{
initData = GameObject.Find("SystemData").GetComponent <InitialData>();
getTowerData(level, towerType);
}
public static void AddCore(InitialData init, SyncData sync)
{
cores.Add(sync.objID, new Core(init, sync));
}
public Unitychan(InitialData init, SyncData sync, bool isPlayer) : base(init, sync, isPlayer)
{
CreatePrefab();
}
/* ==================================================================================================== Fill Data */
private static void CreateData(DataSet dataSet, InitialData data, MsSqlDataProvider dataProvider)
{
var now = DateTime.UtcNow;
var propertyTypes = dataSet.Tables[TableName.PropertyTypes];
foreach (var propertyType in data.Schema.PropertyTypes)
{
var row = propertyTypes.NewRow();
SetPropertyTypeRow(row, propertyType, dataProvider);
propertyTypes.Rows.Add(row);
}
var nodeTypes = dataSet.Tables[TableName.NodeTypes];
foreach (var nodeType in data.Schema.NodeTypes)
{
var row = nodeTypes.NewRow();
SetNodeTypeRow(row, nodeType, data.Schema.NodeTypes, dataProvider);
nodeTypes.Rows.Add(row);
}
var nodes = dataSet.Tables[TableName.Nodes];
foreach (var node in data.Nodes)
{
var row = nodes.NewRow();
node.CreationDate = now;
node.ModificationDate = now;
SetNodeRow(row, node, dataProvider);
nodes.Rows.Add(row);
}
var versions = dataSet.Tables[TableName.Versions];
var longTexts = dataSet.Tables[TableName.LongTextProperties];
var refProps = dataSet.Tables[TableName.ReferenceProperties];
var binaryProperties = dataSet.Tables[TableName.BinaryProperties];
var files = dataSet.Tables[TableName.Files];
var longTextId = 0;
var refPropId = 0;
foreach (var version in data.Versions)
{
var props = data.DynamicProperties.FirstOrDefault(x => x.VersionId == version.VersionId);
if (props?.LongTextProperties != null)
{
foreach (var longTextData in props.LongTextProperties)
{
var longTextRow = longTexts.NewRow();
var propertyTypeId =
data.Schema.PropertyTypes.FirstOrDefault(x => x.Name == longTextData.Key.Name)?.Id ?? 0;
SetLongTextPropertyRow(longTextRow, ++longTextId, version.VersionId, propertyTypeId, longTextData.Value);
longTexts.Rows.Add(longTextRow);
}
}
if (props?.ReferenceProperties != null)
{
foreach (var referenceData in props.ReferenceProperties)
{
var propertyTypeId =
data.Schema.PropertyTypes.FirstOrDefault(x => x.Name == referenceData.Key.Name)?.Id ?? 0;
foreach (var value in referenceData.Value)
{
var refPropRow = refProps.NewRow();
SetReferencePropertyRow(refPropRow, ++refPropId, version.VersionId, propertyTypeId, value);
refProps.Rows.Add(refPropRow);
}
}
}
if (props?.BinaryProperties != null)
{
foreach (var binaryPropertyData in props.BinaryProperties)
{
var binaryPropertyRow = binaryProperties.NewRow();
var propertyTypeId =
data.Schema.PropertyTypes.FirstOrDefault(x => x.Name == binaryPropertyData.Key.Name)?.Id ?? 0;
SetBinaryPropertyRow(binaryPropertyRow, version.VersionId, propertyTypeId, binaryPropertyData.Value);
binaryProperties.Rows.Add(binaryPropertyRow);
var fileRow = files.NewRow();
SetFileRow(fileRow, binaryPropertyData.Value, data, binaryPropertyData.Key.Name);
files.Rows.Add(fileRow);
}
}
var versionRow = versions.NewRow();
version.CreationDate = now;
version.ModificationDate = now;
SetVersionRow(versionRow, version, props?.DynamicProperties, dataProvider);
versions.Rows.Add(versionRow);
}
}
private static async Task EnsureData(
ISiteQueries siteQueries,
ISiteCommands siteCommands,
IUserQueries userQueries,
IUserCommands userCommands,
IGeoQueries geoQueries,
IGeoCommands geoCommands,
IBasicQueries <SiteRole> roleQueries,
IBasicQueries <SiteUser> userBasic
)
{
int count = await geoQueries.GetCountryCount();
if (count == 0)
{
foreach (GeoCountry c in InitialData.BuildCountryList())
{
await geoCommands.Add(c);
}
foreach (GeoZone c in InitialData.BuildStateList())
{
await geoCommands.Add(c);
}
}
count = await siteQueries.GetCount();
SiteSettings newSite = null;
Guid siteId = Guid.Empty;
if (count == 0)
{
// create first site
newSite = InitialData.BuildInitialSite();
await siteCommands.Create(newSite);
siteId = newSite.Id;
}
else if (count == 1)
{
var allSites = await siteQueries.GetList().ConfigureAwait(false);
var site = allSites[0];
if (site != null)
{
siteId = site.Id;
}
}
else
{
return;
}
// ensure roles
//var projectId = await projectResolver.ResolveProjectId();
var projectId = siteId.ToString();;
count = await roleQueries.GetCountAsync(projectId);
if (count == 0)
{
var adminRole = InitialData.BuildAdminRole();
adminRole.SiteId = siteId;
await userCommands.CreateRole(adminRole);
var roleAdminRole = InitialData.BuildRoleAdminRole();
roleAdminRole.SiteId = siteId;
await userCommands.CreateRole(roleAdminRole);
var contentAdminRole = InitialData.BuildContentAdminsRole();
contentAdminRole.SiteId = siteId;
await userCommands.CreateRole(contentAdminRole);
var authenticatedUserRole = InitialData.BuildAuthenticatedRole();
authenticatedUserRole.SiteId = siteId;
await userCommands.CreateRole(authenticatedUserRole);
}
// ensure admin user
count = await userBasic.GetCountAsync(projectId);
if (count == 0)
{
var role = await userQueries.FetchRole(newSite.Id, "Administrators");
if (role != null)
{
var adminUser = InitialData.BuildInitialAdmin();
adminUser.SiteId = siteId;
await userCommands.Create(adminUser);
await userCommands.AddUserToRole(siteId, role.Id, adminUser.Id);
role = await userQueries.FetchRole(siteId, "Authenticated Users");
if (role != null)
{
await userCommands.AddUserToRole(siteId, role.Id, adminUser.Id);
}
}
}
}
private static async Task EnsureData(
ICoreDbContext db
)
{
int rowsAffected = 0;
int count = await db.Countries.CountAsync <GeoCountry>();
if (count == 0)
{
foreach (GeoCountry c in InitialData.BuildCountryList())
{
db.Countries.Add(c);
}
rowsAffected = await db.SaveChangesAsync();
}
count = await db.States.CountAsync <GeoZone>();
if (count == 0)
{
foreach (GeoZone c in InitialData.BuildStateList())
{
db.States.Add(c);
}
rowsAffected = await db.SaveChangesAsync();
}
count = await db.Sites.CountAsync <SiteSettings>();
SiteSettings newSite = null;
if (count == 0)
{
// create first site
newSite = InitialData.BuildInitialSite();
db.Sites.Add(newSite);
rowsAffected = await db.SaveChangesAsync();
}
// ensure roles
count = await db.Roles.CountAsync <SiteRole>();
if (count == 0)
{
var site = newSite;
if (site == null)
{
site = await db.Sites.SingleOrDefaultAsync <SiteSettings>(
s => s.Id != Guid.Empty && s.IsServerAdminSite == true);
}
if (site != null)
{
var adminRole = InitialData.BuildAdminRole();
adminRole.SiteId = site.Id;
db.Roles.Add(adminRole);
var roleAdminRole = InitialData.BuildRoleAdminRole();
roleAdminRole.SiteId = site.Id;
db.Roles.Add(roleAdminRole);
var contentAdminRole = InitialData.BuildContentAdminsRole();
contentAdminRole.SiteId = site.Id;
db.Roles.Add(contentAdminRole);
var authenticatedUserRole = InitialData.BuildAuthenticatedRole();
authenticatedUserRole.SiteId = site.Id;
db.Roles.Add(authenticatedUserRole);
rowsAffected = await db.SaveChangesAsync();
}
}
// ensure admin user
count = await db.Users.CountAsync <SiteUser>();
if (count == 0)
{
SiteSettings site = await db.Sites.FirstOrDefaultAsync <SiteSettings>(
s => s.Id != Guid.Empty && s.IsServerAdminSite == true);
if (site != null)
{
var role = await db.Roles.FirstOrDefaultAsync(
x => x.SiteId == site.Id && x.NormalizedRoleName == "ADMINISTRATORS");
if (role != null)
{
var adminUser = InitialData.BuildInitialAdmin();
adminUser.SiteId = site.Id;
adminUser.Id = Guid.NewGuid();
adminUser.CanAutoLockout = false;
db.Users.Add(adminUser);
rowsAffected = await db.SaveChangesAsync();
if (rowsAffected > 0 && adminUser.Id != Guid.Empty)
{
var ur = new UserRole();
ur.RoleId = role.Id;
ur.UserId = adminUser.Id;
db.UserRoles.Add(ur);
await db.SaveChangesAsync();
role = await db.Roles.SingleOrDefaultAsync(
x => x.SiteId == site.Id && x.NormalizedRoleName == "Authenticated Users".ToUpperInvariant());
if (role != null)
{
ur = new UserRole();
ur.RoleId = role.Id;
ur.UserId = adminUser.Id;
db.UserRoles.Add(ur);
await db.SaveChangesAsync();
}
}
}
}
}
}
/* =============================================================================================== Installation */
public Task InstallInitialDataAsync(InitialData data, CancellationToken cancellationToken)
{
_logger.LogTrace($"Installing initial data.");
return(DataProvider.InstallInitialDataAsync(data, cancellationToken));
}
protected static InitialData GetInitialData()
{
return(_initialData ?? (_initialData = InitialData.Load(DefaultDatabase.Instance)));
}
public HomeController(InitialData list)
{
_list = list;
}
