protected override bool Initialize()
{
lock (this)
{
if (!this.initialized)
{
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(typeof(PgUserPasswordHistoryProviderFactory), "connectionString");
if (param != null)
{
string tName = param.Value as string;
if (!string.IsNullOrEmpty(tName))
{
if (NpgSqlCommandUtils.TestConnection(tName))
{
Db.ConnectionString = tName;
this.initialized = true;
return(true);
}
}
}
}
}
}
return(false);
}
internal static bool Initialize()
{
LogProviderBase log = null;
if (LogManager.Instance.State == RunState.Running)
{
log = LogManager.Instance.GetProvider(typeof(OncorServer));
}
if (log == null)
{
log = new NullLogger(typeof(OncorServer));
}
ConfigurationProviderBase prov = ConfigurationManager.Instance.GetProvider();
if (prov != null)
{
ConfigurationParameter param = prov.Get(typeof(HttpListenerServerListener), "listenerUrls");
List <string> listenUrls = new List <string>();
if (param != null)
{
string[] tmp = (string[])param.Value;
listenUrls.AddRange(tmp);
List <IHandlerMapper> handlers = new List <IHandlerMapper>();
handlers.Add(InitApi(prov));
handlers.Add(InitFiles(prov));
Server = InitServer(listenUrls, handlers);
return(Server != null);
}
}
return(false);
}
protected override void Operation()
{
ConfigurationParameter configuration = this.Manager.Parameter.Configuration;
JobManager jobManager = this.Manager.JobManager;
this.Manager.ClearStatistics(this.Time);
configuration.JobRelease.PreOperation();
jobManager.ReadReleaseInformation(configuration.JobRelease.GetStream(), this.Time);
configuration.JobRelease.PostOperation();
if (configuration.SimulationPeriodType == SimulationPeriodType.JobBased)
{
if (jobManager.JobMix.Unreleased == 0 && jobManager.Jobs.Count == 0)
{
this.Manager.EventCalendar.ScheduleEndSimulationEvent(this.Time);
return;
}
}
if (this.Manager.Time != 0) //if (configuration.LoadingPeriodType == LoadingPeriodType.JobBased && this.Manager.Time != 0)
{ //Assumption: planning period loading periodun tam katý deðilse, burada loading schedule edip override ediyoruz.
//IE486fall18 fonksiyon loading period olmadigindan dolayi mundar oldu. (rip)
//this.Manager.EventCalendar.ScheduleStartLoadingPeriodEvent(this.Manager.Time);
}
if (configuration.PlanningPeriodType == PlanningPeriodType.TimeBased)
{
this.Manager.EventCalendar.ScheduleEndPlanningPeriodEvent(this.Time + configuration.PlanningPeriodTime);
}
}
public DocumentDetailsDataSimple(string _mode, WareDocument document, List <WareDocumentDetail> documentDetails, WareDocumentDetail documentDetail)
{
InitializeComponent();
manager = new ContextManager();
mode = _mode;
MessageL.Text = "Оберіть одиницю";
Document = document;
DocumentDetails = documentDetails;
DocumentDetail = documentDetail;
//categoriesUC1.Fill();
//categoriesUC1.ExpandAll();
wareSelectorUC1.Init("");
ConfigurationParametersLogic config = new ConfigurationParametersLogic(manager);
ConfigurationParameter param0 = config.Get(ParametersLogic.Parameter.DOCUMENTDETAILS_SHOW_SECONDARY_UNIT.ToString());
if (param0 != null)
{
SecondaryGroupGB.Visible = Helpers.ConfigDataTypeConverter.ConvertToBoolean(param0.Value);
}
ConfigurationParameter param1 = config.Get(ParametersLogic.Parameter.DOCUMENTDETAILS_SHOW_FONTSIZE.ToString());
if (param1 != null)
{
float size = Helpers.ConfigDataTypeConverter.ConvertToFloat(param1.Value);
wareSelectorUC1.FontSize = size;
//this.Font = new Font(this.Font.Name, size);
}
ConfigurationParameter param2 = config.Get(ParametersLogic.Parameter.DOCUMENTDETAILS_SHOW_WARES_MINROWHEIGHT.ToString());
if (param2 != null)
{
int size = Convert.ToInt32(param2.Value);
wareSelectorUC1.MinRowHeight = size;
}
ConfigurationParameter param3 = config.Get(ParametersLogic.Parameter.DOCUMENTDETAILS_SHOW_WARES_VIEWMODE.ToString());
if (param3 != null)
{
switch (param3.ToString().ToUpper())
{
case "TREEVIEW":
{
wareSelectorUC1.CategoriesViewMode = UC.CategoriesUC.Mode.TreeView;
break;
}
case "BUTTON":
{
wareSelectorUC1.CategoriesViewMode = UC.CategoriesUC.Mode.Button;
break;
}
}
}
}
public void Ctor_GivenBothDefaultValueAndValueMappingEmpty_ThrowsArgumentException()
{
var configurationParameter = new ConfigurationParameter("threadLimit", "");
Assert.That(configurationParameter.Name, Is.EqualTo("threadLimit"));
Assert.That(configurationParameter.Description, Is.Null);
Assert.That(configurationParameter.DefaultValue, Is.Empty);
}
/// <summary>
/// Tries to intialize by configuration, if no configuartion parameter is found, tries to use local static configuration property.
/// If that is not found, initialization fails.
/// </summary>
/// <returns></returns>
protected override bool Initialize()
{
lock (syncRoot)
{
LogProviderBase logger = LogManager.Instance.GetProvider(typeof(FlatFileLogFactory));
if (logger == null)
{
logger = new NullLogger(typeof(FlatFileLogFactory));
}
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(typeof(FlatFileLogFactory), "fileName");
if (param != null)
{
try
{
string fileName = (string)param.Value;
if (Init(fileName))
{
logger = null; //make sure to clear it out
return(true);
}
else
{
logger.Log(1000, "InitImpl: Failed to get or create log file: " + fileName);
}
}
catch
{
logger.Log(1000, "InitImpl: Failed to get configuration param");
}
}
else
{
if (Init(Configuration))
{
logger = null; //make sure to clear it out
return(true);
}
logger.Log(1000, "InitImpl: Failed to get config parameter: fileName");
}
}
else
{
logger.Log(1000, "InitImpl: Failed to get config provider");
if (Init(Configuration))
{
logger = null; //make sure to clear it out
return(true);
}
}
logger = null; //make sure to clear it out
return(false);
}
}
private object MapParamProperties(ConfigurationParameter parameter)
{
if (IsEntireParameterDegenerated(parameter))
{
return(parameter.DefaultValue);
}
return(GetParamRegularPropertiesMapping(parameter));
}
private object MapParamValues(ConfigurationParameter parameter)
{
if (IsParameterValueDegenerated(parameter))
{
return(parameter.DefaultValue);
}
return(GetEnvironmentValuesMapping(parameter));
}
public MainForm()
{
InitializeComponent();
ConfigurationParameter = new ConfigurationParameter();
DatabaseHelper.CreateDatabase();
_frmKonfiguracja = new KonfiguracjaForm(this);
_frmPomiar = new PomiarForm(this);
_frmRaport = new RaportForm(this);
InitTabs();
}
static void Main(string[] args)
{
ConfigurationManager.Instance.Bootstrap();
ConfigurationManager.Instance.Initialize();
ConfigurationManager.Instance.Start();
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
ConfigurationParameter param = config.Get(typeof(Program), "hostList");
Console.WriteLine("Enter to exit");
Console.ReadLine();
}
//Update in DB
public void Edit(ConfigurationParameter configurationParameter)
{
string adminUserGuid = HttpContext.Current.User.Identity.Name.Split(new[] { '|' })[0];
db.spDesktopDataAdmin_UpdateConfigurationParameter_v1(
configurationParameter.ConfigurationParameterName,
configurationParameter.ConfigurationParameterValue,
adminUserGuid,
configurationParameter.VersionNumber
);
}
private static void AddDefaultValueIfKnown(List <object> environmentValuesMapping,
ConfigurationParameter parameter)
{
if (!ConfigurationParameter.IsValueUnknown(parameter.DefaultValue))
{
environmentValuesMapping.Add(new Dictionary <string, string>
{
{ "default", parameter.DefaultValue }
});
}
}
public void Bootstrap()
{
lock (instance)
{
if (RuntimeUtils.Bootstrappable(this.State))
{
string meth = "Bootstrap";
this.State = RunState.Bootstrapping;
this.logger = LogManager.Instance.GetProvider(typeof(IdentityManager));
Log(meth, LogLevel.Info, "Called");
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(typeof(IdentityManager), "provider");
if (param != null)
{
string tName = param.Value as string;
if (!string.IsNullOrEmpty(tName))
{
TypeNameReference typeName = TypeNameReference.Parse(tName);
if (typeName != null)
{
IdentityConfiguration iConfig = new IdentityConfiguration();
iConfig.FactoryTypeName = typeName;
Bootstrap(iConfig);
return;
}
else
{
Log(meth, LogLevel.Error, "Failed to parse provider param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get provider param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get provider param");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider");
}
this.State = RunState.FailedBootstrapping;
}
}
}
protected override void RealPut(ConfigurationParameter setting, string value)
{
// If encryption is required, it will be performed by Settings
if (trans == null)
{
Settings.SetPersistent(setting.GetUniqueName(), value, setting.IsNodeConfiguration(), setting.IsEncryptedConfiguration());
}
else
{
Settings.SetPersistent(trans, setting.GetUniqueName(), value, setting.IsNodeConfiguration(), setting.IsEncryptedConfiguration());
}
}
private object GetParamRegularPropertiesMapping(ConfigurationParameter parameter)
{
var regularMapping = new Dictionary <string, object>();
if (!string.IsNullOrEmpty(parameter.Description))
{
regularMapping.Add("description", parameter.Description);
}
regularMapping.Add("value", MapParamValues(parameter));
return(regularMapping);
}
private static void AddEnvironmentValueIfOtherThanDefault(List <object> environmentValuesMapping,
ConfigurationParameter parameter, ConfigurableEnvironment environment)
{
if (IsEnvironmentValueSameAsDefault(parameter, environment, out var valueToSerialize))
{
return;
}
environmentValuesMapping.Add(new Dictionary <string, string>
{
{ environment.Name, valueToSerialize ?? string.Empty }
});
}
protected override void InitializeImpl()
{
lock (instance)
{
if (RuntimeUtils.Initializable(this.State))
{
string meth = "Initialize";
this.State = RunState.Initializing;
this.logger = LogManager.Instance.GetProvider(typeof(InstrumentManager));
Log(meth, LogLevel.Info, "Called");
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(typeof(InstrumentManager), "provider");
if (param != null)
{
string tName = param.Value as string;
if (!string.IsNullOrEmpty(tName))
{
TypeNameReference typeName = TypeNameReference.Parse(tName);
if (typeName != null)
{
this.Initialize(typeName);
return;
}
else
{
Log(meth, LogLevel.Error, "Failed to parse role provider param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get role provider param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get role provider param");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider");
}
this.State = RunState.FailedInitializing;
}
}
}
protected override void Operation()
{
JobManager jobManager = this.Manager.JobManager;
LayoutManager layoutManager = this.Manager.LayoutManager;
this.Manager.EventCalendar.Reset();
jobManager.Reset(this.Time);
layoutManager.Reset(this.Time);
ConfigurationParameter configuration = this.Manager.Parameter.Configuration;
configuration.PeriodState.PreOperation();
configuration.PeriodState.PostOperation();
this.Manager.EventCalendar.ScheduleStartPlanningPeriodEvent(this.Time);
}
private object GetEnvironmentValuesMapping(ConfigurationParameter parameter)
{
var environmentsAvailableSorted = _configuration.Environments.OrderBy(env => env.Name);
var environmentValuesMapping = new List <object>();
foreach (var environment in environmentsAvailableSorted)
{
AddEnvironmentValueIfOtherThanDefault(environmentValuesMapping, parameter, environment);
}
AddDefaultValueIfKnown(environmentValuesMapping, parameter);
return(environmentValuesMapping);
}
public override IEnumerable <ValidationResultMessage> Validate(ConfigurationParameter configurationParameter)
{
var messages = new List <ValidationResultMessage>();
if (Package.Configuration.DocumentElement != null)
{
var xNodes = GetConfigurationParameters(configurationParameter);
if (xNodes.Count == 0)
{
var message = new ValidationResultMessage
{
Body = configurationParameter.Name,
Status = configurationParameter.IsRequired ? StatusWords.ERR : StatusWords.WARN
};
messages.Add(message);
}
else
{
for (int i = 0; i < xNodes.Count; i++)
{
messages.Add(new ValidationResultMessage
{
Body = configurationParameter.Name,
Status = StatusWords.OK
});
foreach (var attribute in configurationParameter.Attributes)
{
messages.AddRange(ValidatorFactory.GetValidator(attribute.ValidationMode, Package, attribute.AuxiliaryValues).Validate(attribute, i));
}
foreach (var parameter in configurationParameter.NestedParameters)
{
messages.AddRange(ValidatorFactory.GetValidator(parameter.ValidationMode, Package, parameter.AuxiliaryValues).Validate(parameter));
}
}
}
}
else
{
messages.Add(new ValidationResultMessage
{
Body = "Configuration file is empty",
Status = StatusWords.CRITICAL
});
}
return(messages);
}
private static void HandleWsCommand(string dashboardUserId, string groupId, string parameter, string value)
{
TelegramGroup group = CacheData.Groups.Values
.SingleOrDefault(x => x.GroupId == groupId);
if (group == null)
{
return;
}
if (!UserTools.CanHandleGroup(dashboardUserId, groupId))
{
return;
}
if (parameter == "WelcomeText")
{
CacheData.Groups[group.TelegramChatId].WelcomeText = value;
return;
}
else if (parameter == "RulesText")
{
CacheData.Groups[group.TelegramChatId].RulesText = value;
return;
}
else if (parameter == "ReportChatId")
{
if (!Int64.TryParse(value, out long reportChatId))
{
return;
}
CacheData.Groups[group.TelegramChatId].ReportChatId = reportChatId;
return;
}
ConfigurationParameter config = CacheData.GroupConfigs[group.TelegramChatId]
.Where(x => x.ConfigurationParameterId == parameter)
.SingleOrDefault();
if (config == null)
{
return;
}
CacheData.GroupConfigs[group.TelegramChatId]
[CacheData.GroupConfigs[group.TelegramChatId]
.IndexOf(config)]
.Value = value;
}
private void requestNewValue(CallbackQuery callbackQuery,
string configurationParameterId)
{
Manager.BotClient.DeleteMessageAsync(callbackQuery.Message.Chat.Id, callbackQuery.Message.MessageId);
ConfigurationParameter conf = CacheData.GroupConfigs[callbackQuery.Message.Chat.Id]
.Where(x => x.ConfigurationParameterId == configurationParameterId)
.SingleOrDefault();
if (conf == null)
{
return;
}
switch (conf.Type)
{
case "string":
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = callbackQuery.Message.Chat,
ParseMode = ParseMode.Markdown,
Text = $"*[ADMIN] Settings [r:{callbackQuery.Message.MessageId}]*\nProvide new value:",
ReplyMarkup = new ForceReplyMarkup()
{
Selective = true
}
});
break;
case "language":
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = callbackQuery.Message.Chat,
ParseMode = ParseMode.Markdown,
Text = $"*[ADMIN] Settings [r:{callbackQuery.Message.MessageId}]*\nSelect language:",
ReplyMarkup = new InlineKeyboardMarkup(
buildLanguageSelectionMenu(callbackQuery.From.Id)
)
});
break;
default:
break;
}
}
public ConfigurationParameter Update(ConfigurationParameter configurationParameter, int callerId)
{
using (UBContext ubc = new UBContext())
{
ConfigurationParameter exists = ubc.Group_ConfigurationParameters
.Where(x => x.ConfigurationParameterId == configurationParameter.ConfigurationParameterId)
.FirstOrDefault();
if (exists == null)
{
return(null);
}
try
{
exists.Value = configurationParameter.Value;
exists.Type = configurationParameter.Type;
exists.Values = configurationParameter.Values;
ubc.SaveChanges();
return(configurationParameter);
}
catch (Exception ex)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban",
Date = DateTime.Now,
Function = "Unifiedban.Data.ConfigurationParameterService.Update",
Level = SystemLog.Levels.Warn,
Message = ex.Message,
UserId = callerId
});
if (ex.InnerException != null)
{
Utils.Logging.AddLog(new SystemLog()
{
LoggerName = "Unifiedban.Data",
Date = DateTime.Now,
Function = "Unifiedban.Data.ConfigurationParameterService.Update",
Level = SystemLog.Levels.Warn,
Message = ex.InnerException.Message,
UserId = callerId
});
}
}
return(null);
}
}
protected override void InitializeImpl()
{
lock (instance)
{
if (RuntimeUtils.Initializable(this.State))
{
string meth = "Initialize";
this.State = RunState.Initializing;
this.logger = LogManager.Instance.GetProvider(typeof(UserAffilationSecurityManager));
Log(meth, LogLevel.Info, "Called");
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(NameReflectionUtils.GetType(TypeNameReference.Parse("Osrs.WellKnown.FieldActivities.Providers.PgFieldActivityProviderFactory, Osrs.WellKnown.FieldActivities.Providers.Postgres")), "connectionString");
if (param != null)
{
string tName = param.Value as string;
if (!string.IsNullOrEmpty(tName))
{
if (NpgSqlCommandUtils.TestConnection(tName))
{
Db.ConnectionString = tName;
this.initialized = true;
this.State = RunState.Initialized;
return;
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get connectionString param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get connectionString param");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider");
}
this.State = RunState.FailedInitializing;
}
}
}
protected override void InitializeImpl()
{
lock (instance)
{
if (RuntimeUtils.Initializable(this.State))
{
string meth = "Initialize";
this.State = RunState.Initializing;
this.logger = LogManager.Instance.GetProvider(typeof(EntityBundleManager));
Log(meth, LogLevel.Info, "Called");
ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
if (config != null)
{
ConfigurationParameter param = config.Get(typeof(EntityBundleProvider), "connectionString");
if (param != null)
{
string tName = param.Value as string;
if (!string.IsNullOrEmpty(tName))
{
if (NpgSqlCommandUtils.TestConnection(tName))
{
Db.ConnectionString = tName;
Log(meth, LogLevel.Info, "Succeeded");
this.State = RunState.Initialized;
return;
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get connectionString param value");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get connectionString param");
}
}
else
{
Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider");
}
this.State = RunState.FailedInitializing;
}
}
}
protected override void Operation()
{
JobType jobType = this.job.JobType;
JobManager jobManager = this.Manager.JobManager;
jobManager.JobDeparture(this.Time, this.job);
ConfigurationParameter configuration = this.Manager.Parameter.Configuration;
if (configuration.SimulationPeriodType == SimulationPeriodType.JobBased)
{
if (jobManager.Jobs.Count == 0)
{
this.Manager.EventCalendar.ScheduleEndSimulationEvent(this.Time);
}
}
}
void OnParameterConfigured(ConfigurationParameter parameter)
{
if (!enabled)
{
return;
}
if (parameter.Name == ParameterName)
{
/* Give parameter opportunity to propagate,
* otherwise weapon which is going to receive OnFireTriggered
* message might miss updated value. */
performFire = true;
paramChangedTimestamp = Time.fixedTime;
}
}
private static bool IsEnvironmentValueSameAsDefault(
ConfigurationParameter parameter, ConfigurableEnvironment environment,
out string environmentValue)
{
var isEnvironmentValueDefined = parameter.Values.TryGetValue(environment, out environmentValue);
if (!isEnvironmentValueDefined && ConfigurationParameter.IsValueUnknown(parameter.DefaultValue) ||
isEnvironmentValueDefined &&
((ConfigurationParameter.IsValueUnknown(environmentValue) &&
ConfigurationParameter.IsValueUnknown(parameter.DefaultValue)) ||
environmentValue == parameter.DefaultValue))
{
return(true);
}
return(false);
}
// GET: /View
public ActionResult ViewItem(string id)
{
//Check Exists
ConfigurationParameter configurationParameter = new ConfigurationParameter();
configurationParameter = configurationParameterRepository.GetConfigurationParameter(id);
if (configurationParameter == null)
{
ViewData["ActionMethod"] = "ViewGet";
return(View("RecordDoesNotExistError"));
}
ConfigurationParameterVM configurationParameterVM = new ConfigurationParameterVM();
configurationParameterVM.ConfigurationParameter = configurationParameter;
return(View(configurationParameterVM));
}
public void Pass_CreateNew(bool sensitive)
{
// Setup
var name = Fakes.RandomString();
var value = Fakes.RandomString();
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(CreateXml(name, value));
// Execute
var param = new ConfigurationParameter(xmlDoc.DocumentElement, sensitive);
// Assert
Assert.NotNull(param);
Assert.Equal(name, param.Name);
Assert.Equal(sensitive ? null : value, param.Value);
Assert.Equal(sensitive, param.Sensitive);
}
internal Dictionary<String, DateTime> GetUsage(ConfigurationParameter cp)
{
Dictionary<string, DateTime> usage = new Dictionary<string, DateTime>();
HistoryItem item;
string key = cp.GetType().FullName;
if (_history.TryGetValue(key, out item))
{
foreach (var pair in item.TimeByUser)
{
usage[pair.Key] = new DateTime(pair.Value);
}
}
return usage;
}
/// <summary>
/// A log that was loaded from the database
/// </summary>
/// <param name="cp"></param>
/// <param name="?"></param>
internal void LoadedLog(ConfigurationParameter cp, Dictionary<string, DateTime> usersDic)
{
try
{
HistoryItem item;
string key = cp.GetType().FullName;
if (!_history.TryGetValue(key, out item))
{
_history[key] = item = new HistoryItem(key);
}
foreach (var pair in usersDic)
{
item.AddUser(pair.Key, pair.Value);
}
}
catch
{
// A exception shall not stop the server
}
}
internal void Log(ConfigurationParameter configurationParameter, Type type)
{
try
{
HistoryItem item;
string key = configurationParameter.GetType().FullName;
if (!_history.TryGetValue(key, out item))
{
_history[key] = item = new HistoryItem(key);
item.AddUser(type);
}
_isModified = true;
}
catch
{
// A exception shall not stop the server
}
}
internal static void Log(ConfigurationParameter configurationParameter, Type type)
{
_history.Log(configurationParameter, type);
}
internal static Dictionary<String, DateTime> GetUsage(ConfigurationParameter cp)
{
return _history.GetUsage(cp);
}
