private void WriteDescription(ParametersModel p)
{
var writer = GetLogWriter();
writer.WriteLine("MFilesImporter written by martin kramer <*****@*****.**>");
p.Options.WriteOptionDescriptions(writer);
}
private void InitializeData()
{
Parameters = new ParametersModel
{
RangeFrom = -4,
RangeTo = 12,
PopulationSize = 10,
NumberOfGenerations = 1,
CrossoverProbability = 0.75f,
MutationProbability = 0.005f,
Elitism = false
};
Precisions = new List <PrecisionModel>()
{
new PrecisionModel()
{
Label = "0,001", Value = 0.001, IntValue = 3
},
new PrecisionModel()
{
Label = "0,01", Value = 0.01, IntValue = 2
},
new PrecisionModel()
{
Label = "0,1", Value = 0.1, IntValue = 1
}
};
SeriesCollection = new SeriesCollection();
}
public OptimizerClass(SequenceClass[] sequences, ParametersModel parameter, double commission, int roundPoint)
{
_parameter = parameter;
_roundPoint = roundPoint;
_commission = commission;
_sequences = sequences;
}
public static ParametersModel CalculateParameters(ParametersModel currentParameters, decimal x1, decimal x2, decimal e)
{
ParametersModel newParameters = new ParametersModel();
decimal eta = 0;
// generates random eta
while (eta == 0)
{
eta = (decimal) new Random().NextDouble();
}
// calculating w1(n+1)
decimal w1p = currentParameters.w1 + (eta * e * x1);
newParameters.w1 = w1p;
// calculating w2(n+1)
decimal w2p = currentParameters.w2 + (eta * e * x2);
newParameters.w2 = w2p;
// Calculating b(n+1);
decimal bp = currentParameters.b + (eta * e);
newParameters.b = bp;
return(newParameters);
}
public IActionResult SetParameters([FromQuery] string parametersFile)
{
ReportsAutoDiscoveryConfigModel pathSearchConfig = GetAutoDiscoveryConfig();
ExecutionConfig config = ExecutionConfigManager.Read(Path.Combine(pathSearchConfig.ParametersFilesDirectory, parametersFile));
ParametersModel model = new ParametersModel();
model.ParametersFile = parametersFile;
if (config.DataSource == ReportDataSource.StoredProcedure)
{
IDictionary <Tuple <ParameterType, string>, object> data = config.StoredProcedureParameters.Select(p =>
new KeyValuePair <Tuple <ParameterType, string>, object>(new Tuple <ParameterType, string>(ParameterType.StoredProcedure, p.ParameterName),
p.ParameterValue)).ToDictionary(item => item.Key, item => item.Value);
model.Parameters = data;
model.IsStoredProcedure = true;
}
else
{
IDictionary <Tuple <ParameterType, string>, object> whereParams = config.ViewParameters.WhereParameters.Select(p =>
new KeyValuePair <Tuple <ParameterType, string>, object>(new Tuple <ParameterType, string>(ParameterType.Where, p.ParameterName),
p.ParameterValue)).ToDictionary(item => item.Key, item => item.Value);
IDictionary <Tuple <ParameterType, string>, object> orderParams = config.ViewParameters.OrderByParameters.Select(p =>
new KeyValuePair <Tuple <ParameterType, string>, object>(new Tuple <ParameterType, string>(ParameterType.Order, p.ParameterName),
p.ParameterValue)).ToDictionary(item => item.Key, item => item.Value);
IDictionary <Tuple <ParameterType, string>, object> groupParams = config.ViewParameters.GroupByParameters.Select(p =>
new KeyValuePair <Tuple <ParameterType, string>, object>(new Tuple <ParameterType, string>(ParameterType.Group, p.ParameterName),
p.ParameterValue)).ToDictionary(item => item.Key, item => item.Value);
IDictionary <Tuple <ParameterType, string>, object> result = new Dictionary <Tuple <ParameterType, string>, object>();
result = result.Concat(whereParams).Concat(orderParams).Concat(groupParams).ToDictionary(item => item.Key, item => item.Value);
model.Parameters = result;
model.IsStoredProcedure = false;
}
return(PartialView("Modals/SetParametersModal", model));
}
public IEnumerable <IParametersModel> GetAll()
{
List <ParametersModel> parameters = new List <ParametersModel>();
string query = "select Id, ProductId, Name, UnitId, Value from Parameters";
using (var db = new SqlCeConnection(connectionString))
{
db.Open();
using (SqlCeCommand command = new SqlCeCommand(query, db))
{
using (SqlCeDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
ParametersModel parameter = new ParametersModel
{
Id = Convert.ToInt32(reader["Id"]),
Name = reader["Name"].ToString(),
ProductId = Convert.ToInt32(reader["ProductId"]),
UnitId = Convert.ToInt32(reader["UnitId"]),
Value = reader["Value"].ToString(),
};
parameters.Add(parameter);
}
}
}
db.Close();
}
return(parameters);
}
public IParametersModel GetById(int id)
{
ParametersModel parameter = new ParametersModel();
using (var db = new SqlCeConnection(connectionString))
{
db.Open();
string query = "select Id, ProductId, Name, UnitId, Value " +
"from Parameters where par.Id=@Id";
using (SqlCeCommand cmd = new SqlCeCommand(query, db))
{
cmd.Prepare();
cmd.Parameters.AddWithValue("@Id", id);
using (SqlCeDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
parameter.Id = Convert.ToInt32(reader["Id"]);
parameter.Name = reader["Name"].ToString();
parameter.ProductId = Convert.ToInt32(reader["ProductId"]);
parameter.UnitId = Convert.ToInt32(reader["UnitId"]);
parameter.Value = reader["Value"].ToString();
}
}
}
db.Close();
}
return(parameter);
}
public ActionResult ShowListOfMetadataNodesForTitleReciever(string Id)
{
SearchMetadataNode SelectedNode = GetMetadataNodes().Where(s => s.DisplayName.Equals(Id)).FirstOrDefault();
ParametersModel model = new ParametersModel();
model.StepInfo = TaskManager.Current();
model.TitleNode = SelectedNode.DisplayName;
model.Entities = GetEntityList();
TaskManager.AddToBus(ImportMetadataStructureTaskManager.TITLE_NODE, SelectedNode.XPath);
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.DESCRIPTION_NODE))
{
model.DescriptionNode = GetDisplayName((string)TaskManager.Bus[ImportMetadataStructureTaskManager.DESCRIPTION_NODE]);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE))
{
model.EntityType = TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE].ToString();
}
return(PartialView("SetParameters", model));
}
public CorneringModel(PrinterModel PrinterModel, PrintModel PrintModel, ParametersModel ParametersModel)
{
_printerModel = PrinterModel;
_printModel = PrintModel;
_parametersModel = ParametersModel;
}
public ParametersModel Parse(string[] args)
{
var p = new ParametersModel();
var options = new Mono.Options.OptionSet();
options.Add("h|help", "prints the help", s => p.Action = ActionType.WriteDescription);
options.Add("v|vault=", "use the specified vault", s => p.Vault = s);
options.Add("u|user="******"use the specified user", s => p.User = s);
options.Add("s|server=", "use the specified server", s => p.Server = s);
options.Add("p|password="******"use the specified password", s => p.Password = s);
options.Add("destroy-by-class=", "destroy objects of the following classes, use Comma ',' as a separator for multiple classes",
s => {
p.Action = ActionType.DestroyObjectsOfClasses;
p.DestroyObjectOfClasses = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
});
options.Add("destroy-by-objecttype=", "destroy objects of the specified object types, use Comma ',' as a separator for multiple classes",
s =>
{
p.Action = ActionType.DestroyObjectsOfObjectTypes;
p.DestroyObjectsOfObjectTypes = s.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
});
options.Add("lc|list-classes", "list all classes and their object counts", s => p.Action = ActionType.ListClassesAndObjects);
options.Add("lo|list-objecttypes", "list all object types and their object counts", s => p.Action = ActionType.ListObjectTypesAndObjects);
options.Parse(args);
p.Options = options;
return(p);
}
private int Run(ParametersModel p)
{
switch (p.Action)
{
case ActionType.WriteDescription:
WriteDescription(p);
WriteUsage();
break;
case ActionType.DestroyObjectsOfClasses:
DestroyObjectsByClass(p);
break;
case ActionType.DestroyObjectsOfObjectTypes:
DestroyObjectsByObjectType(p);
break;
case ActionType.ListClassesAndObjects:
ListClassesAndObjects(p);
break;
case ActionType.ListObjectTypesAndObjects:
ListObjectTypesAndObjects(p);
break;
}
return(0);
}
public IHttpActionResult PostResult(ParametersModel parameters)
{
TargetModel targetData = null;
try
{
targetData = GetMethodAndLibrary(parameters.Method);
Type dataLogicType = GetLibraryPath(targetData.Library);
CheckApiKey(parameters.ApiKey);
// Get result
object result = null;
result = dataLogicType.ExecuteStaticMethod(targetData.Method, parameters.Params ?? new string[0]);
if (result != null)
{
return(Ok(result));
//return MakeOkResponse(result);
}
return(NotFound());
//return new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);
}
catch (Exception ex)
{
return(BadRequest(SmartFormatException(ex)));
//return MakeBadRequestResponse(SmartFormatException(ex));
}
}
private async Task <PollReportPortugueseResult> BuscarDadosSyncAsync(ParametersModel parameters, string anoLetivo, string codigoDre, string codigoEscola, string codigoCurso)
{
var BusinessPoll = new Data.Business.PollPortuguese(_config);
return(await BusinessPoll.BuscarDadosRelatorioPortugues(parameters.Proficiency, parameters.Term, anoLetivo, codigoDre, codigoEscola, codigoCurso));
;
}
protected override void OnExit(ExitEventArgs e)
{
Log.Info("Application closed.");
ParametersModel.Save();
TestBanch.DisconnectAll();
base.OnExit(e);
}
private async Task <Report> PerformTaskAndMakeReport(ParametersModel parameters)
{
var report = await PerformTask(parameters);
await _reportRepository.SaveReport(report);
return(report);
}
protected override void OnStartup(StartupEventArgs e)
{
Log.Info("Application started.");
ParametersModel.Load();
TestBanch.ConnectAll();
base.OnStartup(e);
}
public async Task <ActionResult <string> > ObterDados([FromBody] ParametersModel parameters)
{
if (parameters.Discipline == "Língua Portuguesa")
{
if (parameters.ClassroomReport)
{
PollReportPortugueseStudentResult result = new PollReportPortugueseStudentResult();
result = await BuscarDadosPorTurmaAsync(parameters);
return(Ok(result));
}
else
{
PollReportPortugueseResult result = new PollReportPortugueseResult();
result = await BuscarDadosSyncAsync(parameters, "2019", parameters.CodigoDRE, parameters.CodigoEscola, parameters.CodigoCurso);
return(Ok(result));
}
}
else if (parameters.Discipline == "Matemática")
{
if (parameters.ClassroomReport)
{
if (parameters.Proficiency == "Números")
{
PollReportMathStudentNumbersResult result = BuscaDadosMathTurmaNumbersAsync(parameters.Proficiency,
parameters.Term,
parameters.CodigoDRE,
parameters.CodigoEscola,
parameters.CodigoTurmaEol, parameters.CodigoCurso);
return(Ok(result));
}
else
{
PollReportMathStudentResult result = BuscaDadosMathTurmaAsync(parameters.Proficiency,
parameters.Term,
parameters.CodigoDRE,
parameters.CodigoEscola,
parameters.CodigoTurmaEol, parameters.CodigoCurso);
return(Ok(result));
}
}
else // cONSOLIDADO
{
var result = await BuscaDadosMathAsync(parameters, "2019", parameters.CodigoDRE, parameters.CodigoEscola, parameters.CodigoCurso);
return(Ok(result));
}
}
return(NotFound());
}
private async Task <Report> PerformTask(ParametersModel param)
{
var report = new Report(param);
var dataCollector = new DataCollector();
var dataTask = dataCollector.GetUsersBfs(param.User);
await Task.WhenAny(dataTask);
if (dataTask.IsFaulted)
{
report.Error = ErrorEnum.GetDataError;
return(report);
}
var data = dataTask.Result;
var filter = new UserFilter(param);
var filteredData = data
.Where(filter.IsSuitable)
.Select(filter.FilteredField)
.ToList();
if (filteredData.Count == 0)
{
report.Error = ErrorEnum.EmptyDataError;
return(report);
}
var cloud = CloudContainer().Resolve <ICloudPainter>();
var cloudTask = cloud.GetBitmapAsync(
filteredData,
param.Colors,
param.Width,
param.Height,
param.MinFont,
param.MaxFont,
param.FontName
);
await Task.WhenAny(cloudTask);
if (cloudTask.IsFaulted)
{
report.Error = ErrorEnum.CloudError;
return(report);
}
var cloudBitmap = cloudTask.Result;
var saveTask = _fileRepository.SaveImageAsync(cloudBitmap);
await Task.WhenAny(saveTask);
if (saveTask.IsFaulted)
{
report.Error = ErrorEnum.SaveError;
return(report);
}
report.SetWayToFileWithSuccess(saveTask.Result);
return(report);
}
private Vault CreateVault(ParametersModel parameters)
{
string user = parameters.User;
string password = parameters.Password;
string vault = parameters.Vault;
string networkAddress = parameters.Server;
return(CreateVault(user, password, vault, networkAddress));
}
public SummaryReportBridgeData(IBridgeData bridgeData, BridgeDataHelper bridgeDataHelper, ExcelHelper excelHelper,
HighlightWorkDoneCells highlightWorkDoneCells, ParametersModel parametersModel)
{
this.bridgeData = bridgeData;
this.bridgeDataHelper = bridgeDataHelper;
this.excelHelper = excelHelper;
this.highlightWorkDoneCells = highlightWorkDoneCells;
this.parametersModel = parametersModel;
}
private void DestroyObjectsByObjectType(ParametersModel p)
{
foreach (string objectType in p.DestroyObjectsOfObjectTypes)
{
Log(string.Format("destroying objects of object type: '{0}'", objectType));
int count = this.DestroyObjectService.DestroyObjectsByObjectType(objectType);
Log(string.Format("destroyed {0} objects", count));
}
}
private void DestroyObjectsByClass(ParametersModel p)
{
foreach (string className in p.DestroyObjectOfClasses)
{
Log(string.Format("destroying objects of class: '{0}'", className));
int count = this.DestroyObjectService.DestroyObjectsByClass(className);
Log(string.Format("destroyed {0} objects", count));
}
}
/// <summary>
/// Clones this instance.
/// </summary>
/// <returns>A deep copy of this instance.</returns>
public override ActionViewModelBase Clone()
{
var sendTextAction = new SendTextAction();
return(new SendTextActionViewModel(sendTextAction, ActionDescriptor, ParametersModel.ParameterDescriptions, AllActionDescriptions)
{
CommandText = CommandText, ParametersModel = ParametersModel.Clone(sendTextAction.Parameters)
});
}
private void ListClassesAndObjects(ParametersModel p)
{
var classes = this.ClassesService.GetClasses();
foreach (string className in classes)
{
var searchResults = this.FindObjectsService.FindObjectsByClass(className);
Log(string.Format("class '{0}' has {1} objects", className, searchResults.Count));
}
}
private void ListObjectTypesAndObjects(ParametersModel p)
{
var objectTypes = this.ObjectTypeService.GetObjectTypes();
foreach (string objectType in objectTypes)
{
var searchResults = this.FindObjectsService.FindObjectsByObjectType(objectType);
Log(string.Format("object type: '{0}' has {1} objects", objectType, searchResults.Count));
}
}
public CoordinateModel(CoordinateType Type, bool Writable, ParametersModel ParametersModel, double Position, double MinPosition, double MaxPosition)
{
_type = Type;
_writable = Writable;
_parametersModel = ParametersModel;
_previousCoord = _currentCoord = Position;
_minPosition = MinPosition;
_maxPosition = MaxPosition;
}
public ProcessTCommandModel(PrintModel PrintModel, PrinterModel PrinterModel, RealTimeStatusDataModel RealTimeStatusDataModel, ParametersModel ParametersModel)
{
_printModel = PrintModel;
_printerModel = PrinterModel;
_realTimeStatusDataModel = RealTimeStatusDataModel;
_parametersModel = ParametersModel;
_setWritePrintheadModel = new SetWritePrintheadModel(_parametersModel);
_writeSetAxisModel = new WriteSetAxisModel(_parametersModel);
}
public static ParametersModel GetRandomParameters()
{
ParametersModel randomParameters = new ParametersModel();
Random rnd = new Random();
randomParameters.b = (decimal)rnd.Next(1, 1000000000) / 1000000000;
randomParameters.w1 = (decimal)rnd.Next(1, 1000000000) / 1000000000;
randomParameters.w2 = (decimal)rnd.Next(1, 1000000000) / 1000000000;
return(randomParameters);
}
private async Task <PollReportMathResult> BuscaDadosMathAsync(ParametersModel parameters, string anoLetivo, string codigoDre, string codigoEscola, string anoTurma)
{
var businessPoll = new Data.Business.SondagemMatematica(_config);
return(await businessPoll
.BuscarDadosRelatorioMatematicaAsync(parameters.Proficiency,
parameters.Term,
anoLetivo,
codigoDre,
codigoEscola,
anoTurma));
}
/// <summary>
/// Clones this instance.
/// </summary>
/// <returns>A deep copy of this instance.</returns>
public override ActionViewModelBase Clone()
{
var outputToMainWindowAction = new OutputToMainWindowAction();
return(new OutputToMainWindowActionViewModel(outputToMainWindowAction, ActionDescriptor, ParametersModel.ParameterDescriptions, AllActionDescriptions)
{
BackgroundColor = BackgroundColor,
TextColor = TextColor,
TextToOutput = TextToOutput,
ParametersModel = ParametersModel.Clone(outputToMainWindowAction.Parameters)
});
}
private void UpdateParameters(ParametersModel parameters)
{
if(parameters != null)
{
FadeOut();
Task.Factory.StartNew(() =>
{
var source = ParameterDisplayModel.CreateParameters(parameters.GetParameters().OrderBy(el => el.Name));
Dispatcher.BeginInvoke(new Action(() =>
{
CleanUpParameters();
ParameterDisplay.ItemsSource = source;
ParameterFilterBox.Display = ParameterDisplay;
ParameterFilterBox.Filter = FilterParameters;
ParameterFilterBox.RefreshFilter();
var type = parameters.ModelSystemStructure.Type;
if(type != null)
{
SelectedName.Text = type.Name;
SelectedNamespace.Text = type.FullName;
}
else
{
SelectedName.Text = "None Selected";
SelectedNamespace.Text = string.Empty;
}
DoubleAnimation fadeIn = new DoubleAnimation(0.0, 1.0, new Duration(new TimeSpan(0, 0, 0, 0, 100)));
ParameterDisplay.BeginAnimation(OpacityProperty, fadeIn);
}));
});
}
else
{
ParameterDisplay.ItemsSource = null;
SelectedName.Text = "None Selected";
SelectedNamespace.Text = string.Empty;
}
}
private void ModelSystemDisplay_ParametersChanged(object arg1, ParametersModel parameters)
{
UpdateParameters(parameters);
}
