/// <summary>
/// Updates configuration only in database. For reloading config must call Reload() after it
/// </summary>
/// <param name="dbManager"></param>
/// <param name="domainID"></param>
/// <param name="domainModule"></param>
/// <param name="domainModuleFeature"></param>
/// <param name="domainModuleFeatureConfig"></param>
protected override void UpdateConfig(DBManager dbManager, long domainID, Dictionary<ModuleID, ModuleRec> domainModule, Dictionary<ModuleID, Dictionary<ModuleFeatureID, ModuleFeatureRec>> domainModuleFeature, Dictionary<ModuleID, Dictionary<ModuleFeatureID, Dictionary<string, string>>> domainModuleFeatureConfig)
{
using (IDBProvider dbInstance = SP.DB.GetInstance(dbManager))
{
//start tx
dbInstance.BeginTransaction();
DomainRec domRec = dbInstance._<DomainAccessor>().Domain(domainID);
//translock
//var dummy = Entity<DomainRec>.SelectForUpdate(dbInstance.Get, domRec.ID);
SP.SessionContext.ExecuteInSystemSessionContext(domainID, () =>
{
//clear module list
dbInstance._<ModuleAccessor>().ClearModuleList(domainID);
//go through provided
foreach (ModuleRec module in domainModule.Values)
{
Util.Check.Ensure(module.DomainID == domainID, "DomainID mismatch");
bool isModuleEnabled = false;
//clear feature list
dbInstance._<ModuleAccessor>().ClearModuleFeatureList(domainID, module.ModuleID);
//go through provided
List<ModuleFeatureRec> fList = new List<ModuleFeatureRec>();
fList.AddRange(from t in domainModuleFeature[module.ModuleID].Values
where t.ModuleFeatureID != ModuleFeatureID.Basic
orderby t.Name
select t);
fList.Add((from t in domainModuleFeature[module.ModuleID].Values
where t.ModuleFeatureID == ModuleFeatureID.Basic
select t).First());
foreach (var feature in fList)
{
Util.Check.Ensure(feature.DomainID == domainID, "DomainID mismatch");
//clear config list
dbInstance._<ModuleAccessor>().ClearFeatureConfigList(domainID, module.ModuleID, feature.ModuleFeatureID);
//go through provided
foreach (var configEntry in
domainModuleFeatureConfig[module.ModuleID][feature.ModuleFeatureID])
{
var evConfigValue = new EncryptedValue(configEntry.Value);
//build config record
ModuleFeatureConfigRec cfg =
new ModuleFeatureConfigRec()
{
ModuleID = module.ModuleID,
ModuleFeatureID = feature.ModuleFeatureID,
ParamName = configEntry.Key,
ParamValue = evConfigValue.Encrypted,
ParamValueHash = evConfigValue.Hashed,
ParamValueIV = evConfigValue.IV
};
//save config
Entity<ModuleFeatureConfigRec>.Insert(dbInstance.Get, cfg);
}
//feature set enabled
if (domainID == SP.Const.SystemDomainID ||
(
module.ModuleID == ModuleID.Core && feature.ModuleFeatureID == ModuleFeatureID.Basic
))
{
feature.IsEnabled = true;
}
else
{
feature.IsEnabled = feature.IsEnabled;
}
if (!isModuleEnabled)
{
isModuleEnabled = feature.IsEnabled;
}
if (feature.ModuleFeatureID == ModuleFeatureID.Basic && isModuleEnabled)
{
feature.IsEnabled = true;
}
//save feature
Entity<ModuleFeatureRec>.Insert(dbInstance.Get, feature);
}
//module set enabled
module.IsEnabled = isModuleEnabled;
//save module
Entity<ModuleRec>.Insert(dbInstance.Get, module);
}
});
//commit tx
dbInstance.CommitTransaction();
}
}
protected override void InitConfig(DBManager dbManager)
{
Dictionary<ModuleID, ModuleRec> defaultModuleSetup;
Dictionary<ModuleID, Dictionary<ModuleFeatureID, ModuleFeatureRec>> defaultFeatureSetup;
Dictionary<ModuleID, Dictionary<ModuleFeatureID, Dictionary<string, string>>> defaultConfigSetup;
_mci.InitDefaultModuleSetup(out defaultModuleSetup, out defaultFeatureSetup, out defaultConfigSetup);
using (IDBProvider dbInstance = SP.DB.GetInstance(dbManager))
{
//read domain list
List<DomainRec> tmpDomainList = dbInstance._<DomainAccessor>().DomainList();
//by Shema: rebuild list so that system domain would be the first in the list
//, need for job module IsDomainSpecific check
List<DomainRec> domainList = new List<DomainRec>();
domainList.Add((from d in tmpDomainList
where d.DomainID == SP.Const.SystemDomainID
select d).First());
domainList.AddRange(from d in tmpDomainList
where d.DomainID != SP.Const.SystemDomainID
select d);
//init vars
var tmpDomainMap = new Dictionary<long, DomainRec>();
var tmpDomainModule = new Dictionary<long, Dictionary<ModuleID, ModuleRec>>();
var tmpDomainModuleFeature = new Dictionary<long, Dictionary<ModuleID, Dictionary<ModuleFeatureID, ModuleFeatureRec>>>();
var tmpDomainModuleFeatureConfig = new Dictionary<long, Dictionary<ModuleID, Dictionary<ModuleFeatureID, Dictionary<string, string>>>>();
//fill domain map
tmpDomainList.ForEach(item => tmpDomainMap[item.DomainID] = item);
//go through domain list
foreach (var domain in domainList)
{
//start tx
dbInstance.BeginTransaction();
//translock
//var dummy = Entity<DomainRec>.SelectForUpdate(dbInstance.Get, domain.ID);
long domainID = domain.DomainID;
SP.SessionContext.ExecuteInSystemSessionContext(domainID, () =>
{
//init default domain setup
tmpDomainModule.Add(domainID, new Dictionary<ModuleID, ModuleRec>());
tmpDomainModuleFeature.Add(domainID, new Dictionary<ModuleID, Dictionary<ModuleFeatureID, ModuleFeatureRec>>());
tmpDomainModuleFeatureConfig.Add(domainID, new Dictionary<ModuleID, Dictionary<ModuleFeatureID, Dictionary<string, string>>>());
//read domain's module list
List<ModuleRec> moduleList = dbInstance._<ModuleAccessor>().ModuleList(domainID);
//clear domain's module list
dbInstance._<ModuleAccessor>().ClearModuleList(domainID);
//go through default module list
foreach (ModuleRec defaultModule in defaultModuleSetup.Values)
{
var selectedModule = from item in moduleList
where item.ModuleID == defaultModule.ModuleID
select item;
// ----------------- MODULE --------------------- //
//record
ModuleRec module = selectedModule.Count() > 0
? selectedModule.First()
: new ModuleRec()
{
ModuleID = defaultModule.ModuleID,
Name = defaultModule.Name,
Description = defaultModule.Description,
IsEnabled = defaultModule.IsEnabled
};
if (domainID == SP.Const.SystemDomainID ||
module.ModuleID == ModuleID.Core)
{
module.IsEnabled = true;
}
//save
Entity<ModuleRec>.Insert(dbInstance.Get, module);
tmpDomainModule[domainID].Add(module.ModuleID, module);
// ----------------- MODULE FEATURES ------------ //
tmpDomainModuleFeature[domainID].Add(module.ModuleID, new Dictionary<ModuleFeatureID, ModuleFeatureRec>());
tmpDomainModuleFeatureConfig[domainID].Add(module.ModuleID, new Dictionary<ModuleFeatureID, Dictionary<string, string>>());
//read module's feature list
List<ModuleFeatureRec> moduleFeatureList = dbInstance._<ModuleAccessor>().ModuleFeatureList(domainID, module.ModuleID);
//clear module's feature list
dbInstance._<ModuleAccessor>().ClearModuleFeatureList(domainID, module.ModuleID);
//got through default feature list
List<ModuleFeatureRec> fList = new List<ModuleFeatureRec>();
fList.AddRange(from t in defaultFeatureSetup[module.ModuleID].Values
where t.ModuleFeatureID != ModuleFeatureID.Basic
orderby t.Name
select t);
fList.Add((from t in defaultFeatureSetup[module.ModuleID].Values
where t.ModuleFeatureID == ModuleFeatureID.Basic
select t).First());
foreach (var defaultFeature in fList)
{
var selectedFeature = from item in moduleFeatureList
where item.ModuleFeatureID == defaultFeature.ModuleFeatureID
select item;
// ----------------- FEATURE ---------------- //
//record
ModuleFeatureRec feature = selectedFeature.Count() > 0
? selectedFeature.First()
: new ModuleFeatureRec()
{
ModuleID = defaultFeature.ModuleID,
ModuleFeatureID = defaultFeature.ModuleFeatureID,
Name = defaultFeature.Name,
IsEnabled = defaultFeature.IsEnabled
};
if (domainID == SP.Const.SystemDomainID ||
(
module.ModuleID == ModuleID.Core && feature.ModuleFeatureID == ModuleFeatureID.Basic
))
{
feature.IsEnabled = true;
}
else
{
feature.IsEnabled = module.IsEnabled && feature.IsEnabled;
}
if (feature.ModuleFeatureID == ModuleFeatureID.Basic && module.IsEnabled)
{
feature.IsEnabled = true;
}
//job module special logic - skip not domain specific job
if (module.ModuleID == ModuleID.Job &&
domainID != SP.Const.SystemDomainID &&
feature.ModuleFeatureID != ModuleFeatureID.Basic &&
tmpDomainModuleFeatureConfig[SP.Const.SystemDomainID]
[feature.ModuleID][feature.ModuleFeatureID][SP.Const.MOD_JOB_IsDomainSpecific] != SP.Const.MOD_Yes
)
{
continue;
}
//save
Entity<ModuleFeatureRec>.Insert(dbInstance.Get, feature);
tmpDomainModuleFeature[domainID][module.ModuleID].Add(feature.ModuleFeatureID, feature);
// ------------- FEATURE CONFIG ------------- //
tmpDomainModuleFeatureConfig[domainID][module.ModuleID].Add(feature.ModuleFeatureID, new Dictionary<string, string>());
//read feature's config list
List<ModuleFeatureConfigRec> featureConfigList = dbInstance._<ModuleAccessor>()
.FeatureConfigList(domainID, module.ModuleID, feature.ModuleFeatureID);
//clear feature's config list
dbInstance._<ModuleAccessor>().ClearFeatureConfigList(domainID, module.ModuleID, feature.ModuleFeatureID);
//gor through default module feature list
foreach (var defaultConfig in defaultConfigSetup[module.ModuleID][feature.ModuleFeatureID])
{
//job module special logic - skip system domain level specific configuration
if (module.ModuleID == ModuleID.Job &&
domainID != SP.Const.SystemDomainID &&
(
defaultConfig.Key == SP.Const.MOD_JOB_IsRunnable ||
defaultConfig.Key == SP.Const.MOD_JOB_IsRecordable ||
defaultConfig.Key == SP.Const.MOD_JOB_IsBackDateScheduleSupported ||
defaultConfig.Key == SP.Const.MOD_JOB_IsDomainSpecific ||
defaultConfig.Key == SP.Const.MOD_JOB_ScheduleString
))
{
continue;
}
//service module special logic - skip system domain level specific configuration
if (module.ModuleID == ModuleID.Service &&
domainID != SP.Const.SystemDomainID &&
(
defaultConfig.Key == SP.Const.MOD_SERVICE_BASIC_PublicServiceAPIAllowedIPList
))
{
continue;
}
var selectedConfig = from item in featureConfigList
where item.ParamName == defaultConfig.Key
select item;
string configValue;
if (selectedConfig.Count() > 0)
{
var tmpRec = selectedConfig.First();
configValue = new EncryptedValue(tmpRec.ParamValue, tmpRec.ParamValueIV).Plain;
}
else
{
configValue = defaultConfig.Value;
}
// ----------------- CONFIG ------------- //
var evConfigValue = new EncryptedValue(configValue);
//record
ModuleFeatureConfigRec cfg =
new ModuleFeatureConfigRec()
{
ModuleID = module.ModuleID,
ModuleFeatureID = feature.ModuleFeatureID,
ParamName = defaultConfig.Key,
ParamValue = evConfigValue.Encrypted,
ParamValueHash = evConfigValue.Hashed,
ParamValueIV = evConfigValue.IV
};
//save
Entity<ModuleFeatureConfigRec>.Insert(dbInstance.Get, cfg);
tmpDomainModuleFeatureConfig[domainID][module.ModuleID][feature.ModuleFeatureID][defaultConfig.Key] = configValue;
}
}
}
});
//commit tx
dbInstance.CommitTransaction();
}
//result
Interlocked.Exchange(ref _domainMap, tmpDomainMap);
Interlocked.Exchange(ref _domainModule, tmpDomainModule);
Interlocked.Exchange(ref _domainModuleFeature, tmpDomainModuleFeature);
Interlocked.Exchange(ref _domainModuleFeatureConfig, tmpDomainModuleFeatureConfig);
//init vendors
InstallDomainVendors(dbInstance.Get, _vendorSetup);
//init roles
InstallDomainRoles(dbInstance.Get, _roleSetup);
}
}
