public void Ctor()
{
var dto = new ConfigurationDto();
Assert.Zero(dto.Id);
Assert.AreEqual(dto.TimeInterval, 5);
Assert.False(dto.EnableInterval);
Assert.False(dto.EnableServer);
Assert.NotNull(dto.Devices);
Assert.False(dto.ViewDateTime);
Assert.False(dto.EnableCompressVideo);
Assert.NotNull(dto.PathSaveVideo);
Assert.AreEqual(15, dto.FrameRate);
Assert.AreEqual(100000, dto.BitRate);
Assert.AreEqual(ELegendAlign.BottonRight, dto.LegendAlign);
Assert.NotNull(dto.Font);
Assert.AreEqual(new Font("Arial", 10.0f), dto.Font);
Util.SetProperty(dto, "_font", null);
Util.SetProperty(dto, "_fontSize", 12.0f);
Util.SetProperty(dto, "_fontFamily", "Comic Sans MS");
Assert.AreEqual(12.0f, dto.Font.Size);
Assert.AreEqual("Comic Sans MS", dto.Font.FontFamily.Name);
Assert.False(dto.EnableStart);
Assert.False(dto.EnableStartMinimized);
}
private Result ProcessConfiguration(ConfigurationDto configurationDto)
{
List <string> newAddressHashes = new List <string>();
using (var uow = NewUnitOfWork(UnitOfWorkMode.Writable))
{
var validatorRepo = NewRepository <Validator>(uow);
var validatorAddresses = configurationDto.Validators.Select(v => v.ValidatorAddress);
var validators = validatorRepo.Get(v => validatorAddresses.Contains(v.BlockchainAddress) && !v.IsActive);
var inactiveValidators = validatorRepo.Get(v => !validatorAddresses.Contains(v.BlockchainAddress) && v.IsActive);
foreach (var validator in validators)
{
validator.IsActive = true;
validatorRepo.Update(validator);
}
foreach (var validator in inactiveValidators)
{
validator.IsActive = false;
validatorRepo.Update(validator);
}
}
return(Result.Success());
}
private void ValidateConfiguration(ConfigurationDto configuration)
{
if (configuration == null)
{
throw new Exception("É necessário realizar a configuração no web site para realizar a operação.");
}
}
public static ConfigurationDto CreateConfiguration(ConfigurationDto configuration)
{
var newConf = DbConfigurationManager.CreateConfiguration(
AutoMapper.Instance.Map <Configuration>(configuration));
return(AutoMapper.Instance.Map <ConfigurationDto>(newConf));
}
public async Task <bool> SaveConfiguration(ConfigurationDto configuration)
{
if (File.Exists(_configurationPath))
{
File.Delete(_configurationPath);
}
var jsonConfig = configuration.ToJsonString();
using (var fs = new FileStream(_configurationPath, FileMode.CreateNew, FileAccess.ReadWrite))
{
using (var sw = new StreamWriter(fs))
{
await sw.WriteAsync(jsonConfig);
var exists = File.Exists(_configurationPath);
if (exists)
{
await _logger.LogInformation(
$"Configuration file created at {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
}
else
{
await _logger.LogError("Configuration file could not be created", LogCriticality.High);
}
return(exists);
}
}
}
public static void WriteEnabledDisabledFunctions(ConfigurationDto objConfiguration)
{
var allConfiguration = new ConfigurationManager().LoadInitialConfiguration();
if (!object.ReferenceEquals(allConfiguration, null))
{
RegisterLogFacade(string.Format("ScriptRunner is: [{0}] \n",
allConfiguration.ScripRunnerSettings.IsEnabled ?
"Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
EnumNLogStruct.LogType.Info, true);
RegisterLogFacade(string.Format("IIS Recycler is: [{0}] \n",
allConfiguration.IISRecyclerConfiguration.IsEnabled ?
"Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
EnumNLogStruct.LogType.Info, true);
RegisterLogFacade(string.Format("IIS Restarter is: [{0}] \n",
allConfiguration.IISRestarterConfiguration.IsEnabled ?
"Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
EnumNLogStruct.LogType.Info, true);
RegisterLogFacade(string.Format("Event Log Manager is: [{0}] \n",
allConfiguration.EventLogManager.IsEnabled ?
"Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
EnumNLogStruct.LogType.Info, true);
}
}
public async Task <BaseResponse <int> > Update(ConfigurationDto model)
{
Configuration configuration = await _db.Configurations.FirstOrDefaultAsync();
if (!string.IsNullOrEmpty(model.UpdateStatusDescription))
{
configuration.UpdateStatusDescription = model.UpdateStatusDescription;
}
var result = await _db.SaveChangesAsync();
if (result == 1)
{
return(new BaseResponse <int>
{
Code = RsponseCode.Success,
Message = "تم تحديث الاعدادات بنجاح ",
Data = 0
});
}
return(new BaseResponse <int>
{
Code = RsponseCode.DataBaseError,
Message = "حصل خطأ ",
Data = 0
});
}
private Configuration FillConfiguration(ConfigurationDto configurationDto)
{
return(new Configuration {
ProjectName = configurationDto.ProjectName,
Token = configurationDto.Token,
Url = configurationDto.Url
});
}
private static void RegisterConsoleLog(string message, ConfigurationDto objConfiguration, EnumNLogStruct.LogType typeOfLog)
{
if (!object.ReferenceEquals(objConfiguration, null))
{
var finalMessage = BuildLogInfoWithConfigurationInformation(objConfiguration, false);
Console.WriteLine(string.Concat(finalMessage, message));
}
}
private void Include(ConfigurationDto configurationDto)
{
using (var db = new GetWorkItemContext()) {
var newConfiguration = FillConfiguration(configurationDto);
db.Configurations.Add(newConfiguration);
db.SaveChanges();
}
}
public async Task Create(ConfigurationDto configurationDto)
{
if (configurationDto == null)
{
return;
}
var configuration = _mapper.Map <Domain.ValueObjects.Configuration>(configurationDto);
await _configurationRepository.Add(configuration);
}
private void Edit(ConfigurationDto configurationDto)
{
using (var db = new GetWorkItemContext()) {
var configurationOriginal = db.Configurations.FirstOrDefault();
configurationOriginal.Url = configurationDto.Url;
configurationOriginal.Token = configurationDto.Token;
configurationOriginal.ProjectName = configurationDto.ProjectName;
db.SaveChanges();
}
}
public void Save(ConfigurationDto configurationDto)
{
if (!CheckConfiguration())
{
Include(configurationDto);
}
else
{
Edit(configurationDto);
}
}
public static string BuildLogInfoWithConfigurationInformation(ConfigurationDto objConfiguration, bool WithAppendLine)
{
var objBuilder = default(StringBuilder);
if (!object.ReferenceEquals(objConfiguration, null))
{
objBuilder = new StringBuilder();
objBuilder.AppendFormat("Hostname: {0} ",
objConfiguration.ExecutionInformation.EnvironmentInfo.MachineHostName);
if (WithAppendLine)
{
objBuilder.AppendLine();
}
objBuilder.AppendFormat("IPAddress: {0} ",
objConfiguration.ExecutionInformation.TrackingUsingInfo.IpAddress);
if (WithAppendLine)
{
objBuilder.AppendLine();
}
objBuilder.AppendFormat("SO: {0} ",
objConfiguration.ExecutionInformation.EnvironmentInfo.OperativeSystemVersion);
if (WithAppendLine)
{
objBuilder.AppendLine();
}
objBuilder.AppendFormat("UserName: {0} ",
objConfiguration.ExecutionInformation.TrackingUsingInfo.UserName);
if (WithAppendLine)
{
objBuilder.AppendLine();
}
objBuilder.AppendFormat("UserName from Domain: {0} ",
objConfiguration.ExecutionInformation.TrackingUsingInfo.UserDomainName);
if (WithAppendLine)
{
objBuilder.AppendLine();
}
objBuilder.AppendFormat("Process: {0} ",
objConfiguration.ExecutionInformation.TrackingUsingInfo.ProcesorCount);
//Always will b e a new Line (separator) after the last log register
}
return(objBuilder?.ToString());
}
public ConfigurationManager()
{
var operation = IocManager.Instance.Resolve <IConfigurationOperation>();
var result = operation.GetAllConfiguration();
if (result.IsSuccess)
{
ConfigurationDto = result.Data;
}
else
{
//write log
}
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
ConfigurationDto = configuration.Get <ConfigurationDto>();
// Check configuration.
var installedPath = ConfigurationDto.Program.WorkingDirectory;
if (!Directory.Exists(installedPath))
{
throw new InvalidOperationException(
$"Directory '{installedPath}' not found. Check Program:WorkingDirectory configuration option.");
}
}
/// <summary>
/// Main Task Runner
/// </summary>
static void TaskRunner(ConfigurationDto objConfiguration)
{
IExecutionable objPlayer = null;
if (!object.ReferenceEquals(objConfiguration, null))
{
objPlayer = new CoreContainer().GetAnyInstance <IExecutionable>();
if (!object.ReferenceEquals(objPlayer, null))
{
LogAndConsoleTracker.RegisterLogFacade("Starting Executing features and functions that are enabled... \n",
transversal.dto.Enums.Nlog.EnumNLogStruct.TypeOfRegister.All,
transversal.dto.Enums.Nlog.EnumNLogStruct.LogType.Info, false);
}
}
}
private static void RegisterNLogOnly(string message, ConfigurationDto objConfiguration, EnumNLogStruct.LogType typeOfLog)
{
var finalMessage = BuildLogInfoWithConfigurationInformation(objConfiguration, false);
if (!object.ReferenceEquals(objConfiguration, null))
{
if (object.ReferenceEquals(objLogger, null))
{
objLogger = new LogManagerContainer().GetAnyInstance <ILoggerConfigurable <Logger> >();
}
objLogger.RegisterLogWithCustomInfo(typeOfLog, new LogVo()
{
CustomMessage = string.Concat(finalMessage, message),
CustomType = typeOfLog
});
}
}
protected override void OnWorkerStart(CancellationToken token)
{
IConfigurationObserver obs = null;
try
{
obs = configurationObserverFactory.Invoke();
obs.PropertyChanged += (o, ea) =>
{
var cfgDto = new ConfigurationDto
{
Timeout = obs.DocumentsJoinerConfiguration.Timeout,
BarcodeSeparator = obs.DocumentsJoinerConfiguration.BarcodeSeparatorValue
};
var cmd = new CommandMessage <ConfigurationDto>
{
CommandName = CommandMessageName.UPDATE_CONFIGURATION_COMMAND_NAME,
Payload = cfgDto
};
commandsQueue.SendMessage(cmd.Serialize());
};
obs.Start();
while (!token.IsCancellationRequested)
{
token.WaitHandle.WaitOne(SEND_STATUS_COMMAND_PERIOD_MS);
if (token.IsCancellationRequested)
{
break;
}
var statusCmd = new CommandMessage <object>
{
CommandName = CommandMessageName.SEND_STATUS_COMMAND_NAME
};
commandsQueue.SendMessage(statusCmd.Serialize());
}
}
finally
{
obs?.Dispose();
}
}
public async Task <BaseResponse <ConfigurationDto> > Get()
{
ConfigurationDto configuration = _mapper.Map <ConfigurationDto>(await _db.Configurations.FirstOrDefaultAsync());
if (configuration != null)
{
return(new BaseResponse <ConfigurationDto>
{
Code = RsponseCode.Success,
Message = "",
Data = configuration
});
}
return(new BaseResponse <ConfigurationDto>
{
Code = RsponseCode.NotFound,
Message = "لا يوجد بيانات ",
Data = null
});
}
public async Task <IActionResult> SaveAsync([FromBody] ConfigurationDto dto)
{
var config = await _configurationRepository.GetAsync();
// TODO: Move to application command and add dto validation
config.UpdateInfo(new Configuration
{
SmtpHostName = dto.SmtpHostName,
SmtpPort = dto?.SmtpPort ?? 0,
SmtpUserName = dto.SmtpUserName,
SmtpPassword = dto.SmtpPassword,
SmtpEmail = dto.SmtpEmail,
EndpointFqdn = dto.EndpointFqdn,
EndpointPort = dto?.EndpointPort ?? 0,
RootPassword = dto.RootPassword.ToMd5Hash()
});
var result = await _configurationRepository.UnitOfWork.SaveEntitiesAsync();
return(Json(new { HttpStatusCode.OK, result }));
}
/// <summary>
/// 转换为系统配置实体
/// </summary>
/// <param name="dto">系统配置数据传输对象</param>
public static Configuration ToEntity(this ConfigurationDto dto)
{
if (dto == null)
{
return(new Configuration());
}
return(new Configuration(dto.Id.ToGuid())
{
Name = dto.Name,
Code = dto.Code,
Value = dto.Value,
IsDeleted = dto.IsDeleted.SafeValue(),
Version = dto.Version,
CreationTime = dto.CreationTime,
CreatorId = dto.CreatorId,
LastModificationTime = dto.LastModificationTime,
LastModifierId = dto.LastModifierId,
Enabled = dto.Enabled.SafeValue(),
Note = dto.Note,
TenantId = dto.TenantId,
});
}
private void FillConfiguration()
{
Console.WriteLine("Configurando a requisição");
using (var db = new GetWorkItemContext()) {
var configurationDto = db.Configurations
.Select(c => new ConfigurationDto {
Url = c.Url,
ProjectName = c.ProjectName,
Token = c.Token
})
.FirstOrDefault();
ValidateConfiguration(configurationDto);
_configuration = new ConfigurationDto {
ProjectName = configurationDto.ProjectName,
Token = configurationDto.Token,
Url = configurationDto.Url
};
}
}
public HttpResponseMessage Get(string ReportName)
{
try
{
var configurationData = new ConfigurationDto();
configurationData = _jsonserializer
.Deserialize <ConfigDto>
(System.IO.File.ReadAllText(System.AppContext.BaseDirectory + "ReportConfig.json"))
.ReportConfiguration.Find(x => x.ReportName == ReportName);
if (configurationData == null)
{
return(Request.CreateResponse(HttpStatusCode.ServiceUnavailable,
string.Format("unable to find resource that matches the report name {0}", ReportName)));
}
return(Request.CreateResponse(HttpStatusCode.OK, configurationData));
}
catch (Exception e)
{
return(Request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, "INTERNAL SERVER PROBLEM"));
}
}
/// <summary>
/// register all type of information when AppDynamics extension is running. Also, trace
/// all information from execution environment.
/// </summary>
/// <param name="message"></param>
/// <param name="option"></param>
public static void RegisterLogFacade(string message, EnumNLogStruct.TypeOfRegister option,
EnumNLogStruct.LogType typeOfLog, bool withPrefix)
{
ConfigurationDto objConfigurationGlobal = default(ConfigurationDto);
objLogger = new LogManagerContainer().GetAnyInstance <ILoggerConfigurable <Logger> >();
string prefix = default(string);
if (!string.IsNullOrEmpty(message))
{
try
{
objConfigurationGlobal = new ConfigurationManager().LoadInitialConfiguration();
if (!object.ReferenceEquals(objConfigurationGlobal, null))
{
prefix = withPrefix ?
$"[AppDynamics CCO Extension on " +
$"{objConfigurationGlobal.ExecutionInformation.EnvironmentInfo.MachineHostName} \t" +
$"({objConfigurationGlobal.ExecutionInformation.TrackingUsingInfo.IpAddress}) at: \t" +
$"{DateTime.Now.ToLongDateString()} says: \n" : string.Empty;
;
var fixedFinalMessage = string.Concat(prefix, message);
switch (option)
{
case EnumNLogStruct.TypeOfRegister.NLog:
RegisterNLogOnly(fixedFinalMessage, objConfigurationGlobal, typeOfLog);
break;
case EnumNLogStruct.TypeOfRegister.Console:
RegisterConsoleLog(fixedFinalMessage, objConfigurationGlobal, typeOfLog);
break;
case EnumNLogStruct.TypeOfRegister.All:
RegisterConsoleLog(fixedFinalMessage, objConfigurationGlobal, typeOfLog);
RegisterNLogOnly(fixedFinalMessage, objConfigurationGlobal, typeOfLog);
break;
default:
throw new ArgumentOutOfRangeException(nameof(option), option, null);
}
}
else
{
objLogger.RegisterLogWithCustomInfo(EnumNLogStruct.LogType.Warning, new LogVo()
{
CustomMessage = "[AppDynamics CCO Extension]: Cannot load configuration from execution environment"
});
}
}
catch (Exception ex)
{
objLogger.RegisterLogWithCustomInfo(EnumNLogStruct.LogType.Error, new LogVo()
{
Exception = ex,
CustomMessage = ex.Message
});
}
}
}
public PkoBpDataAnalyzer(ConfigurationDto configuration)
{
_configuration = configuration;
}
public ConfigurationDto Update([FromBody] ConfigurationDto configuration)
{
return(_configurationRepository.Update(configuration));
}
public BankFactory(ConfigurationDto configuration)
{
_configuration = configuration;
}
public ActionResult <bool> SaveConfiguration(ConfigurationDto configurationDto)
{
_configurationService.Save(configurationDto);
return(true);
}
public void SetConfiguration(ConfigurationDto configuration)
{
_productsViewModel.Configuration = configuration;
}
