public void CanGetRemarksIfExists()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.False(string.IsNullOrWhiteSpace(builder.Remarks));
Assert.Equal(TestParameterClass.ParameterRemarks, builder.Remarks);
}
private void InitContent()
{
// data managers
this.COMPFactory = new ComponentFactory(ComponentManagerType.ADMINISTRATOR);
this.PFactory = new ParameterFactory();
this.MVFactory = new MultiValueFactory();
this.MarkedForImport = new List <Component>();
// commands: main function
this.btn_import.Command = new RelayCommand((x) => ImportComponentsFromDXF(),
(x) => CanExecute_ImportComponentsFromDXF());
this.btn_import_MV.Command = new RelayCommand((x) => ImportMultiValueFiledsFromDXF(),
(x) => CanExecute_ImportMultiValueFiledsFromDXF());
this.btn_OK.Command = new RelayCommand((x) => PepareToExportToProject(),
(x) => CanExecute_PepareToExportToProject());
// commands: display
this.btn_unfold_all.Command = new RelayCommand((x) =>
{
this.COMPFactory.ExpandAll();
this.tve_components.ItemsSource = new List <ParameterStructure.Component.Component>(this.COMPFactory.ComponentRecord);
});
this.btn_unfold_selected.Command = new RelayCommand((x) =>
{
Component selcomp = this.tve_components.SelectedItem_ as Component;
this.COMPFactory.ExpandComp(selcomp);
this.tve_components.ItemsSource = new List <ParameterStructure.Component.Component>(this.COMPFactory.ComponentRecord);
},
(x) => this.tve_components.SelectedItem_ != null);
this.btn_collapse.Command = new RelayCommand((x) =>
{
this.COMPFactory.CollapseAll();
this.tve_components.ItemsSource = new List <ParameterStructure.Component.Component>(this.COMPFactory.ComponentRecord);
});
this.btn_mark_all.Command = new RelayCommand((x) => this.COMPFactory.MarkAll(true),
(x) => this.COMPFactory != null && this.COMPFactory.ComponentRecord.Count > 0);
this.btn_unmarkall.Command = new RelayCommand((x) => this.COMPFactory.MarkAll(false),
(x) => this.COMPFactory != null && this.COMPFactory.ComponentRecord.Count > 0);
this.btn_mark_w_refs.Command = new RelayCommand((x) =>
{
Component selcomp = this.tve_components.SelectedItem_ as Component;
this.COMPFactory.MarkWReferences(selcomp);
},
(x) => this.COMPFactory != null && this.tve_components.SelectedItem_ != null);
}
public void CanGetOptionalAndDefaultValue()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodOptional))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.True(builder.IsOptional);
Assert.NotNull(builder.DefaultValue);
Assert.Equal(TestParameterClass.ParameterDefaultValue, builder.DefaultValue);
}
public void ParameterUnit_DeviceUnitWithNullValueUpdatedWhenDisposed_DeviceUnitChangedIsNotRaised()
{
// arrange
var parameter = new ParameterUnit
{
DeviceUnit = null,
};
bool eventRaised = false;
parameter.DeviceUnitChanged += (s, e) => { eventRaised = true; };
parameter.Dispose();
// act
parameter.DeviceUnit = ParameterFactory.Create("dummy");
// assert
Assert.IsFalse(eventRaised);
}
public void UpdateFrame(IMapedFrame frame, Guid playerId, Guid gameId)
{
Parameters.Clear();
Command = "UpdateFrame";
Parameters.Add(ParameterFactory.Create("PlayerId", DbType.Guid, playerId));
Parameters.Add(ParameterFactory.Create("GameId", DbType.Guid, gameId));
Parameters.Add(ParameterFactory.Create("FrameId", DbType.Int32, frame.Index));
Parameters.Add(ParameterFactory.Create("Bonus", DbType.Int32, frame.BonusScore));
Parameters.Add(ParameterFactory.Create("TotalScore", DbType.Int32, frame.TotalScore));
Parameters.Add(ParameterFactory.Create("CumulativeScore", DbType.Int32, frame.CumulativeTotalScore));
ExecuteTask(Update);
}
public static object InvokeMethod(this object entity, string methodName, object[] parameters)
{
try
{
MethodInfo methodInfo = MethodFactory.GetMethodInfo(entity.GetType(), methodName);
if (methodInfo != null)
{
ParameterInfo[] pareameterInfos = ParameterFactory.GetParameterInfos(methodInfo);
return(methodInfo.Invoke(entity, parameters));
}
else
{
throw new Exception("没有找到指定调用方法");
}
}
catch (Exception e)
{
throw new Exception(string.Format("调用指定调用方法时出错,{0}", e.Message));
}
}
public void CanBuild()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameterInfo = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var builder = factory.BuildParameter(commandBuilder, parameterInfo);
var command = new Mock <ICommand>().Object;
var parameter = builder.Build(command);
Assert.NotNull(parameter);
}
public GrassCommand(string filePath)
{
var lines = File.ReadAllLines(filePath);
Name = lines[0];
Description = lines[1];
Group = lines[2];
Parameters = new List <IParameter>();
for (int i = 3; i < lines.Length; i++)
{
if (string.IsNullOrEmpty(lines[i]))
{
Console.WriteLine(lines[i]);
}
else
{
Parameters.Add(ParameterFactory.CreateParameter(lines[i]));
}
}
}
public void CanGetAllAttributes()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var attributes = parameter.GetCustomAttributes();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.NotEmpty(builder.Attributes);
Assert.Equal(attributes, builder.Attributes);
}
public void ParameterFactoryHelpTest()
{
var command = @"-h";
var parameter = ParameterFactory.GetParameter(command);
Assert.IsTrue(parameter.GetType() == typeof(Help) && parameter.Validate());
command = @"-help";
parameter = ParameterFactory.GetParameter(command);
Assert.IsTrue(parameter.GetType() == typeof(Help) && parameter.Validate());
command = @"-help something\here";
parameter = ParameterFactory.GetParameter(command);
Assert.IsFalse(parameter.Validate());
}
public DeterminatieTabel MaakDeterminatieTabel()
{
DeterminatieTabel dt = new DeterminatieTabel();
ParameterFactory _parameterFactory = new ParameterFactory();
ResultaatBlad jajaResultaatKnoop = new ResultaatBlad(new VegetatieType("Ijswoestijnklimaat", ""), "Koud klimaat zonder dooiseizoen");
ResultaatBlad janeeResultaatKnoop = new ResultaatBlad(new VegetatieType("Ijswoestijnklimaat", "Toendraklimaat"), "Koud klimaat met dooiseizoen");
ResultaatBlad neejaResultaatKnoop = new ResultaatBlad(new VegetatieType("Taigaklimaat", ""), "Koudgematigd klimaat met strenge winter");
ResultaatBlad neeneejajaResultaatKnoop = new ResultaatBlad(new VegetatieType("Woestijnklimaat van de middelbreedten", ""), "Gematigd altijd droog klimaat");
ResultaatBlad neeneejaneeResultaatKnoop = new ResultaatBlad(new VegetatieType("Woestijnklimaat van de tropen", ""), "Warm altijd droog klimaat");
ResultaatBlad neeneeneejajaResultaatKnoop = new ResultaatBlad(new VegetatieType("Steppeklimaat", ""), "Gematigd, droog klimaat");
ResultaatBlad neeneeneejaneejaResultaatKnoop = new ResultaatBlad(new VegetatieType("Taigaklimaat", ""), "Koudgematigd klimaat met strenge winter");
ResultaatBlad neeneeneejaneeneejajaResultaatKnoop = new ResultaatBlad(new VegetatieType("Gemengd-woudklimaat", ""), "Koelgematigd klimaat met koude winter");
ResultaatBlad neeneeneejaneeneejaneejaResultaatKnoop = new ResultaatBlad(new VegetatieType("Loofbosklimaat", ""), "Koelgematigd klimaat met zachte winter");
ResultaatBlad neeneeneejaneeneejaneeneeResultaatKnoop = new ResultaatBlad(new VegetatieType("Subtropisch regenwoudklimaat", ""), "Warmgematigd altijd nat klimaat");
ResultaatBlad neeneeneejaneeneeneejajaResultaatKnoop = new ResultaatBlad(new VegetatieType("Hardbladige-vegetatieklimaat van de centrale middelbreedten", ""), "Koelgematigd klimaat met natte winter");
ResultaatBlad neeneeneejaneeneeneejaneeResultaatKnoop = new ResultaatBlad(new VegetatieType("Hardbladige-vegetatieklimaat van de subtropen", ""), "Warmgematigd klimaat met natte winter");
ResultaatBlad neeneeneejaneeneeneeneeResultaatKnoop = new ResultaatBlad(new VegetatieType("Subtropisch savanneklimaat", ""), "Warmgematigd klimaat met natte zomer");
ResultaatBlad neeneeneeneeneeResultaatKnoop = new ResultaatBlad(new VegetatieType("Tropisch savanneklimaat", ""), "Warm klimaat met nat seizoen");
ResultaatBlad neeneeneeneejaResultaatKnoop = new ResultaatBlad(new VegetatieType("Tropisch regenwoudklimaat", ""), "Warm altijd nat klimaat");
BeslissingsKnoop jaBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tw"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(0)), jajaResultaatKnoop, janeeResultaatKnoop);
BeslissingsKnoop neeneejaBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tk"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(15)), neeneejajaResultaatKnoop, neeneejaneeResultaatKnoop);
BeslissingsKnoop neeneeneeneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("D"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(1)), neeneeneeneejaResultaatKnoop, neeneeneeneeneeResultaatKnoop);
BeslissingsKnoop neeneeneejaneeneeneejaBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tw"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(22)), neeneeneejaneeneeneejajaResultaatKnoop, neeneeneejaneeneeneejaneeResultaatKnoop);
BeslissingsKnoop neeneeneejaneeneeneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Nz"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakParameter("Nw")), neeneeneejaneeneeneejaBeslissingsKnoop, neeneeneejaneeneeneeneeResultaatKnoop);
BeslissingsKnoop neeneeneejaneeneejaneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tw"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(22)), neeneeneejaneeneejaneejaResultaatKnoop, neeneeneejaneeneejaneeneeResultaatKnoop);
BeslissingsKnoop neeneeneejaneeneejaBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tk"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(-3)), neeneeneejaneeneejajaResultaatKnoop, neeneeneejaneeneejaneeBeslissingsKnoop);
BeslissingsKnoop neeneeneejaneeneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("D"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(1)), neeneeneejaneeneejaBeslissingsKnoop, neeneeneejaneeneeneeBeslissingsKnoop);
BeslissingsKnoop neeneeneejaneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tk"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(-10)), neeneeneejaneejaResultaatKnoop, neeneeneejaneeneeBeslissingsKnoop);
BeslissingsKnoop neeneeneejaBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Nj"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(400)), neeneeneejajaResultaatKnoop, neeneeneejaneeBeslissingsKnoop);
BeslissingsKnoop neeneeneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tk"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(18)), neeneeneejaBeslissingsKnoop, neeneeneeneeBeslissingsKnoop);
BeslissingsKnoop neeneeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Nj"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(200)), neeneejaBeslissingsKnoop, neeneeneeBeslissingsKnoop);
BeslissingsKnoop neeBeslissingsKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tj"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(0)), neejaResultaatKnoop, neeneeBeslissingsKnoop);
BeslissingsKnoop hoofdKnoop = new BeslissingsKnoop(new Vergelijking(_parameterFactory.MaakParameter("Tw"), Operator.KleinerDanOfGelijkAan, _parameterFactory.MaakConstanteParameter(10)), jaBeslissingsKnoop, neeBeslissingsKnoop);
dt.BeginKnoop = hoofdKnoop;
return(dt);
}
public GrassCommand()
{
string filePath = @"C:\Users\Administrator\Desktop\description\i.albedo.txt";
var lines = File.ReadAllLines(filePath);
Name = lines[0];
Description = lines[1];
Group = lines[2];
Parameters = new List <IParameter>();
for (int i = 3; i < lines.Length; i++)
{
if (string.IsNullOrEmpty(lines[i]))
{
Console.WriteLine(lines[i]);
}
else
{
Parameters.Add(ParameterFactory.CreateParameter(lines[i]));
}
}
}
static void Main(String[] args)
{
Console.WriteLine();
Console.WriteLine();
if (args.Length == 0)
{
Console.WriteLine("Usage: TFSUtility command:<command> [<options>|help]");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Availiable commands:");
Console.WriteLine(" map Map completed work of Users x Dates");
Console.WriteLine(" workOfUser Get all work of user");
Console.WriteLine();
}
var parameters = ParameterFactory.GetParameters(args);
try
{
switch (parameters.Command)
{
case Parameters.MAPWORK_COMMAND:
CommandFactory.GetMapWork(parameters).Execute(Console.Out);
break;
case Parameters.WORKOFUSER_COMMAND:
CommandFactory.GetWorkOfUser(parameters).Execute(Console.Out);
break;
}
}
catch (Exception e)
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine(e.Message);
}
}
public void CanGetAllPreconditions()
{
var options = new MariCommandsOptions();
var factory = new ParameterFactory(options);
var commandBuilder = new Mock <ICommandBuilder>().Object;
var parameter = typeof(TestParameterClass)
.GetMethod(nameof(TestParameterClass.TestMethodAttribute))
.GetParameters()
.FirstOrDefault();
var preconditions = parameter
.GetCustomAttributes()
.Where(a => typeof(ParamPreconditionAttribute).IsAssignableFrom(a.GetType()))
.Select(a => a as ParamPreconditionAttribute)
.ToList();
var builder = factory.BuildParameter(commandBuilder, parameter);
Assert.NotNull(builder);
Assert.NotEmpty(builder.Preconditions);
Assert.Equal(preconditions, builder.Preconditions);
}
public static Parameter ValidateArgs(string command)
{
var args = Regex.Split(command, @"(?=-)").ToList();
args.RemoveAll(arg => arg == string.Empty);
if (args.Count == 0)
{
Logger.GetLoggerInstance().Error("Invalid number of parameters.");
return(null);
}
else
{
var source = args[0].ToLower();
var parameter = ParameterFactory.GetParameter(source);
if (parameter == null)
{
Logger.GetLoggerInstance().Error(string.Format("Unable to match '{0}' with any known parameter. Type -h/help for manual."));
return(null);
}
return(parameter.Validate() ? parameter : null);
}
}
/// <summary>
/// 获取数据库命令
/// </summary>
/// <param name="connection">数据库连接对象【已打开】</param>
/// <param name="sql">SQL语句或存储过程名称</param>
/// <param name="parameter">参数。类型为Dictionary字典（参数名带不带@都可以）或 SqlParameter[] </param>
/// <param name="commandType">命令类型</param>
/// <returns></returns>
public static MySqlCommand GetMySqlCommand(MySqlConnection connection, string sql, object parameter, CommandType commandType)
{
if (connection.State == ConnectionState.Broken)
{
connection.Close();
connection.Open();
}
else if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
using (MySqlCommand cmd = new MySqlCommand(sql, connection)) {
cmd.CommandTimeout = 60;
cmd.CommandType = commandType;
cmd.Parameters.Clear();
if (parameter == null)
{
return(cmd);
}
else if (parameter is Dictionary <string, object> )
{
Dictionary <string, object> _parameter = (Dictionary <string, object>)parameter;
#region SQL语句的参数处理
if (CommandType.Text == commandType)
{
/*
* SQL语句的参数处理。
* 支持参数不带‘@’。
*/
MatchCollection ms = Regex.Matches(sql, @"@\w+");
if (ms.Count > 0)
{
foreach (Match m in ms)
{
string key = m.Value;
string key2 = m.Value.Substring(1);//去除 @
Object value;
if (_parameter.ContainsKey(key2) || _parameter.ContainsKey(key))
{
value = _parameter.ContainsKey(key2) ? _parameter[key2] : _parameter[key];
}
else
{
value = DBNull.Value;
}
cmd.Parameters.Add(new MySqlParameter(key, value));
}
}
cmd.CommandText = sql;
}
#endregion
#region 存储过程的参数处理
else if (CommandType.StoredProcedure == commandType)
{
cmd.Parameters.AddRange(ParameterFactory.GetMySqlParameters(sql, _parameter));
}
#endregion
}
else if (parameter is MySqlParameter[])
{
cmd.Parameters.AddRange((MySqlParameter[])parameter);
}
else
{
throw new Exception("不支持的参数类型。");
}
return(cmd);
}
}
public void Initialize()
{
m_parameterFactory = new ParameterFactory(ServiceLocator.Instance.Get <IUserProfileModel>().CurrentCity);
InitializeDynamicParameters();
}
public CommandBuilder(DbCommand command, ParameterFactory parameterFactory)
: base(command, parameterFactory)
{
}
private void AddIndexedPositionWeight(Function vsMain, int index, ref int funcCounter)
{
Operand.OpMask indexMask = IndexToMask(index);
FunctionInvocation curFuncInvocation;
var outputMask = (int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z);
if (paramInWorldMatrices.Type == GpuProgramParameters.GpuConstantType.Matrix_4X4)
{
outputMask = (int)Operand.OpMask.All;
}
//multiply posiiton with world matrix and put into temporary param
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInWorldMatrix, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)indexMask, 1);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out, outputMask);
vsMain.AddAtomInstance(curFuncInvocation);
//set w value of temporary param to 1
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out, (int)Operand.OpMask.W);
vsMain.AddAtomInstance(curFuncInvocation);
//multiply temporary param with weight
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInWeights, Operand.OpSemantic.In, (int)indexMask);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//check if on first iteration
if (index == 0)
{
//set the local param as the value of the world param
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
else
{
//add the local param as the value of the world param
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
}
public void Setup()
{
_parameterFactory = new ParameterFactory();
}
public ValueSetMetadataModule(
ISwaggerModelCatalog modelCatalog,
ISwaggerTagCatalog tagCatalog,
TerminologySqlSettings settings)
: base(modelCatalog, tagCatalog)
{
modelCatalog.AddModels(
typeof(ValueSetFindByTermQuery),
typeof(PagedCollection <ValueSetApiModel>),
typeof(PagedCollection <ValueSetItemApiModel>),
typeof(PagerSettings),
typeof(ValueSetApiModel),
typeof(ValueSetItemApiModel),
typeof(ValueSetCodeApiModel),
typeof(ValueSetCodeCountApiModel),
typeof(ClientTermValueSetApiModel),
typeof(CodeOperation),
typeof(ValueSetCopyApiModel),
typeof(ValueSetStatus),
typeof(CodeOperationSource),
typeof(OperationInstruction),
typeof(SortDirection),
typeof(Guid)
);
// /{valueSetGuid}
this.RouteDescriber.DescribeRouteWithParams(
"GetValueSet",
"Returns a ValueSet by it's ValueSetGuid",
"Gets a ValueSet by it's ValueSetGuid",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 400, Message = "Bad Request"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetValueSetGuid(),
ParameterFactory.GetSummary(),
ParameterFactory.GetCodeSystemGuidsArray()
},
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetMultipleValueSets",
"Gets multiple ValueSets",
"Gets a collection of ValueSet's given a collection of ValueSetGuid(s)",
new[]
{
new HttpResponseMetadata <PagedCollection <ValueSetApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <MultipleValueSetsQuery>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetPaged",
"Returns a paged list of ValueSets",
"Gets a paged collection of ValueSets",
new[]
{
new HttpResponseMetadata <PagedCollection <ValueSetApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetSkip(),
ParameterFactory.GetTop(settings.DefaultItemsPerPage),
ParameterFactory.GetSummary(),
ParameterFactory.GetCodeSystemGuidsArray(),
ParameterFactory.GetQueryStringStatusCode(),
ParameterFactory.GetOrderBy("Name")
},
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetValueSetVersions",
"Gets all versions of a ValueSet",
"Gets all versions of a ValueSet by it's published ID (Usually OID)",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[] { ParameterFactory.GetValueSetReferenceId(), ParameterFactory.GetSummary(), ParameterFactory.GetCodeSystemGuidsArray() },
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"Search",
"Search by 'Name' of ValueSet operation",
"Gets a paged collection of ValueSet's matching the 'Name' filter",
new[]
{
new HttpResponseMetadata <PagedCollection <ValueSetApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <ValueSetFindByTermQuery>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"AddValueSet",
"Creates a new value set",
"Creates a new value set",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 400, Message = "Bad Request"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <ClientTermValueSetApiModel>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[]
{
TagsFactory.GetValueSetTag()
});
this.RouteDescriber.DescribeRouteWithParams(
"PatchValueSet",
"Updates a value set",
"Updates a value set",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 400, Message = "Bad Request"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetValueSetGuid(),
new BodyParameter <ClientTermValueSetApiModel>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[]
{
TagsFactory.GetValueSetTag()
});
this.RouteDescriber.DescribeRouteWithParams(
"ChangeValueSetStatus",
"Updates the status of an existing value set",
"Updates the status of an existing value set. Draft may be changed to active. Active may be changed to Archived. Archived may be changed to Active.",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetValueSetGuid(),
ParameterFactory.GetPathStatusCode()
},
new[]
{
TagsFactory.GetValueSetTag()
});
this.RouteDescriber.DescribeRouteWithParams(
"CopyValueSet",
"Creates a copy of a ValueSet",
"Creates a copy of a ValueSet",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <ValueSetCopyApiModel>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[]
{
TagsFactory.GetValueSetTag()
});
this.RouteDescriber.DescribeRouteWithParams(
"CompareValueSets",
"Compares two or more ValueSets",
"Compares two or more ValueSets",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <CompareValueSetsQuery>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[]
{
TagsFactory.GetValueSetTag()
});
this.RouteDescriber.DescribeRouteWithParams(
"DeleteValueSet",
"Deletes a client term ValueSet",
"Deletes a client term ValueSet. Request is only valid for client term value sets with a 'Draft' status.",
new[]
{
new HttpResponseMetadata {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 400, Message = "Bad Request"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetValueSetGuid()
},
new[]
{
TagsFactory.GetValueSetTag()
});
}
/// <summary> /// Производные классы переопределяют этот метод, чтобы в нём создать свои параметры /// с помощью посланного им объекта класса ParameterFactory. /// </summary> /// <param name="factory">Фабрика параметров</param> protected abstract void InitializeParameters(ParameterFactory factory);
private void AddPositionCalculations(Function vsMain, ref int funcCounter)
{
FunctionInvocation curFuncInvocation = null;
if (doBoneCalculations)
{
if (scalingShearingSupport)
{
//Construct a scaling and shearing matrix based on the blend weights
for (int i = 0; i < WeightCount; i++)
{
//Assign the local param based on the current index of the scaling and shearing matrices
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramInScaleShearMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)IndexToMask(i), 1);
curFuncInvocation.PushOperand(this.paramTempFloat3x4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Calculate the resultant scaling and shearing matrix based on the weigts given
AddIndexedPositionWeight(vsMain, i, this.paramTempFloat3x4, this.paramTempFloat3x4, this.paramBlendS,
ref funcCounter);
}
//Transform the position based on the scaling and shearing matrix
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramBlendS, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
else
{
//Assign the input position to the local blended position
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In,
(int)(Operand.OpMask.X | Operand.OpMask.Y | Operand.OpMask.Z));
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
//Set functions to calculate world position
for (int i = 0; i < weightCount; i++)
{
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAssign,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInIndices, Operand.OpSemantic.In, (int)IndexToMask(i));
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//multiply the index by 2
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncModulate,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(2.0f), Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Add 1 to the index and assign as the second row's index
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncAdd,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(ParameterFactory.CreateConstParamFloat(1.0f), Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex2, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Build the dual quaternion matrix
curFuncInvocation = new FunctionInvocation(
DualQuaternionSkinning.SGXFuncBuildDualQuaternionMatrix,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform, funcCounter++);
curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex1, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1);
curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramIndex2, Operand.OpSemantic.In, (int)Operand.OpMask.All, 1);
curFuncInvocation.PushOperand(this.paramTempFloat2x4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
if (correctAntipodalityHandling)
{
AdjustForCorrectAntipodality(vsMain, i, ref funcCounter, this.paramTempFloat2x4);
}
//Calculate the resultant dual quaternion based based on the weights given
AddIndexedPositionWeight(vsMain, i, this.paramTempFloat2x4, this.paramTempFloat2x4, this.paramBlendDQ,
ref funcCounter);
}
//Normalize the dual quaternion
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncNormalizeDualQuaternion,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramBlendDQ, Operand.OpSemantic.InOut);
vsMain.AddAtomInstance(curFuncInvocation);
//Calculate the blend position
curFuncInvocation = new FunctionInvocation(DualQuaternionSkinning.SGXFuncCalculateBlendPosition,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(this.paramLocalBlendPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(this.paramBlendDQ, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//Update from object to projective space
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInViewProjMatrix, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramTempFloat4, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramOutPositionProj, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
else
{
//update from object to world space
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInWorldMatrices, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramLocalPositionWorld, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
//update from object to projective space
curFuncInvocation = new FunctionInvocation(FFPRenderState.FFPFuncTransform,
(int)FFPRenderState.FFPVertexShaderStage.VSTransform,
funcCounter++);
curFuncInvocation.PushOperand(paramInWorldViewProjMatrix, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramInPosition, Operand.OpSemantic.In);
curFuncInvocation.PushOperand(paramOutPositionProj, Operand.OpSemantic.Out);
vsMain.AddAtomInstance(curFuncInvocation);
}
}
public static SqlParameter[] AddNewParameter(SqlParameter[] parameterArray, string parameterName, object value, SqlDbType type, int size = 0)
{
return(ParameterFactory.AddNewParameter(parameterArray, parameterName, value, type, size));
}
protected override void Seed(KlimatogramContext context)
{
try
{
/*
* ==================================================================
* Continenten aanmaken
* ==================================================================
*/
//Europa
Continent europa = new Continent("Europa", "150");
//Afrika
Continent afrika = new Continent("Afrika", "002");
//Azië
Continent azie = new Continent("Azië", "142");
//Oceanië
Continent oceanie = new Continent("Oceanië", "009");
//Noord Amerika
Continent noordAmerika = new Continent("Noord-Amerika", "021");
//Zuid Amerika
Continent zuidAmerika = new Continent("Zuid-Amerika", "005");
/*
* ==================================================================
* Landen aanmaken
* ==================================================================
*/
//België
Land belgie = new Land("België", "BE");
//Frankrijk
Land frankrijk = new Land("Frankrijk", "FR");
//Ivoorkust
Land ivoorkust = new Land("Ivoorkust", "CI");
//China
Land china = new Land("China", "CN");
//Nieuw Zeeland
Land nieuwZeeland = new Land("Nieuw Zeeland", "NZ");
//Verenigde Staten
Land verenigdeStaten = new Land("Verenigde Staten", "US");
//Peru
Land peru = new Land("Peru", "PE");
/*
* ==================================================================
* Locaties aanmaken
* klimatogram aanmaken
* Koppelen
* ==================================================================
*/
//Eerste 2 lijsten aanmaken voor de temperaturen en neerslagen
IList <double> temperaturen;
IList <int> neerslagen;
Klimatogram klimatogram;
//Ukkel
Locatie ukkel = new Locatie("Ukkel");
temperaturen = new[] { 2.5, 3.2, 5.7, 8.7, 12.7, 15.5, 17.2, 17, 14.4, 10.4, 6, 3.4 };
neerslagen = new[] { 67, 54, 73, 57, 70, 78, 75, 63, 59, 71, 78, 76 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 50.802398, 4.340670, 1961, 1990);
ukkel.Klimatogram = klimatogram;
//Gent-Melle
Locatie gentMelle = new Locatie("Gent-Melle");
temperaturen = new[] { 2.4, 3, 5.2, 8.4, 12.1, 15.1, 16.8, 16.6, 14.3, 10.3, 6.2, 3.2 };
neerslagen = new[] { 51, 42, 46, 50, 59, 65, 72, 74, 72, 72, 64, 59 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 51.003672, 3.800314, 1960, 1996);
gentMelle.Klimatogram = klimatogram;
//Abidjan
Locatie abidjan = new Locatie("Abidjan");
temperaturen = new[] { 26.8, 27.7, 27.9, 27.7, 26.9, 25.8, 24.7, 24.5, 25.6, 26.8, 27.4, 27 };
neerslagen = new[] { 16, 49, 107, 141, 294, 562, 206, 37, 81, 138, 143, 75 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 5.316667, -4.033333, 1961, 1990);
abidjan.Klimatogram = klimatogram;
//Parijs
Locatie parijs = new Locatie("Parijs");
temperaturen = new[] { 3.5, 4.5, 6.8, 9.7, 13.3, 16.4, 18.4, 18.2, 15.7, 11.8, 6.9, 4.3 };
neerslagen = new[] { 54, 46, 54, 47, 63, 58, 54, 52, 54, 56, 56, 56 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 48.856614, 2.352222, 1960, 1990);
parijs.Klimatogram = klimatogram;
//Peking
Locatie peking = new Locatie("Peking");
temperaturen = new[] { -4.3, -1.9, 5.1, 13.6, 20.0, 24.2, 25.9, 24.6, 19.6, 12.7, 4.3, -2.2 };
neerslagen = new[] { 3, 6, 9, 26, 29, 71, 176, 182, 49, 19, 6, 2 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 39.904211, 116.407395, 1961, 1990);
peking.Klimatogram = klimatogram;
//Wellington
Locatie wellington = new Locatie("Wellington");
temperaturen = new[] { 17.8, 17.7, 16.6, 14.3, 11.9, 10.1, 9.2, 9.8, 11.2, 12.8, 14.5, 16.4 };
neerslagen = new[] { 67, 48, 76, 87, 99, 113, 111, 106, 82, 81, 74, 74 };
klimatogram = new Klimatogram(temperaturen, neerslagen, -41.286460, 174.776236, 1961, 1990);
wellington.Klimatogram = klimatogram;
//Oklahoma City
Locatie oklahomaCity = new Locatie("Oklahoma City");
temperaturen = new[] { 2.2, 4.9, 10.2, 15.8, 20.2, 24.8, 27.8, 27.3, 22.8, 16.7, 9.8, 4.1 };
neerslagen = new[] { 29, 40, 69, 70, 133, 110, 66, 66, 98, 82, 50, 36 };
klimatogram = new Klimatogram(temperaturen, neerslagen, 35.467560, -97.516428, 1961, 1990);
oklahomaCity.Klimatogram = klimatogram;
//
Locatie lima = new Locatie("Lima");
temperaturen = new[] { 22.7, 23.3, 22.9, 21.2, 19.2, 17.8, 17.1, 16.8, 17.0, 17.9, 19.3, 21.3 };
neerslagen = new[] { 1, 0, 0, 0, 0, 1, 1, 2, 1, 0, 0, 0 };
klimatogram = new Klimatogram(temperaturen, neerslagen, -12.046374, -77.042793, 1961, 1990);
lima.Klimatogram = klimatogram;
/*
* ==================================================================
* Locaties aan landen koppelen
* ==================================================================
*/
//Aan Belgie
belgie.VoegLocatieToe(ukkel);
belgie.VoegLocatieToe(gentMelle);
//Aan Frankrijk
frankrijk.VoegLocatieToe(parijs);
//Aan Ivoorkust
ivoorkust.VoegLocatieToe(abidjan);
//Aan China
china.VoegLocatieToe(peking);
//Aan Nieuw Zeeland
nieuwZeeland.VoegLocatieToe(wellington);
//Aan Verenigde Staten
verenigdeStaten.VoegLocatieToe(oklahomaCity);
//Aan Peru
peru.VoegLocatieToe(lima);
/*
* ==================================================================
* Landen aan continenten koppelen
* ==================================================================
*/
//Aan Europa
europa.VoegLandToe(belgie);
europa.VoegLandToe(frankrijk);
//Aan Afrika
afrika.VoegLandToe(ivoorkust);
//Aan Azië
azie.VoegLandToe(china);
//Aan Oceanië
oceanie.VoegLandToe(nieuwZeeland);
//Aan Noord-Amerika
noordAmerika.VoegLandToe(verenigdeStaten);
//Aan Zuid-Amerika
zuidAmerika.VoegLandToe(peru);
/*
* ===================================================================
* Kenmerken aanmaken
*
* Moet in juiste volgorde gemaakt zijn zodat determinatietabel
* klopt.
* ===================================================================
*/
IList <Kenmerk> kenmerkList = new List <Kenmerk>();
string[] klimaten = (new string[] { "Koud klimaat zonder dooiseizoen", "Koud klimaat met dooiseizoen", "Koudgematigd klimaat met strenge winter", "Gematigd altijd droog klimaat", "Warm altijd droog klimaat", "Gematigd, droog klimaat", "Koudgematigd klimaat met strenge winter", "Koelgematigd klimaat met koude winter", "Koelgematigd klimaat met zachte winter", "Warmgematigd altijd nat klimaat", "Koelgematigd klimaat met natte winter", "Warmgematigd klimaat met natte winter", "Warmgematigd klimaat met natte zomer", "Warm klimaat met nat seizoen", "Warm altijd nat klimaat", "Koud zonder dooiseizoen", "Koud met dooiseizoen", "Koud gematigd", "Koel gematigd met strenge winter", "Koel gematigd met zachte winter", "Warm gematigd met natte winter", "Gematigd en droog", "Warm" });
string[] vegetaties = (new string[] { "Ijswoestijn", "Toendra", "Taiga", "Woestijn van de middelbreedten", "Woestijn van de tropen", "Steppe", "Taiga", "Gemengd-woud", "Loofbos", "Subtropisch regenwoud", "Hardbladige-vegetatie van de centrale middelbreedten", "Hardbladige-vegetatie van subtropen", "Subtropische savanne", "Tropische savanne", "Tropisch regenwoud", "Koud", "Koud", "Gematigd", "Gematigd", "Gematigd", "Gematigd", "Droog", "Warm" });
for (int i = 0; i < klimaten.Length; ++i)
{
Kenmerk k = new Kenmerk();
k.KlimaatKenmerk = klimaten[i];
k.VegetatieKenmerk = vegetaties[i];
kenmerkList.Add(k);
}
/*
* ===================================================================
* Test determinatietabel maken
*
* Rechts is ja
* Omlaag is nee
*
* Zie Use case 3 determineertabel graad 2 & 3
* ===================================================================
*/
//Factories maken, deze zorgen dat dezelfde waarden maar 1 keer in de db komen
VergelijkingFactory vergelijkingFactory = new VergelijkingFactory();
ParameterFactory parameterFactory = new ParameterFactory();
//De vragen aanmaken
//TW <= 10
DeterminatieVraag d1 = new DeterminatieVraag();
d1.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d1.Parameter2 = parameterFactory.GeefConstanteParameter(10);
d1.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//TW <= 0
DeterminatieVraag d2 = new DeterminatieVraag();
d2.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d2.Parameter2 = parameterFactory.GeefConstanteParameter(0);
d2.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//TJ <= 0
DeterminatieVraag d3 = new DeterminatieVraag();
d3.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.GemiddeldeJaarTemperatuur);
d3.Parameter2 = parameterFactory.GeefConstanteParameter(0);
d3.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//NJ <= 200
DeterminatieVraag d4 = new DeterminatieVraag();
d4.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.TotaleJaarNeerslag);
d4.Parameter2 = parameterFactory.GeefConstanteParameter(200);
d4.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//TK <= 15
DeterminatieVraag d5 = new DeterminatieVraag();
d5.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d5.Parameter2 = parameterFactory.GeefConstanteParameter(15);
d5.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//TK <= 18
DeterminatieVraag d6 = new DeterminatieVraag();
d6.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d6.Parameter2 = parameterFactory.GeefConstanteParameter(18);
d6.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//NJ <= 400
DeterminatieVraag d7 = new DeterminatieVraag();
d7.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.TotaleJaarNeerslag);
d7.Parameter2 = parameterFactory.GeefConstanteParameter(400);
d7.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//Tk <= -10
DeterminatieVraag d8 = new DeterminatieVraag();
d8.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d8.Parameter2 = parameterFactory.GeefConstanteParameter(-10);
d8.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//D <= 1
DeterminatieVraag d9 = new DeterminatieVraag();
d9.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.AantalDrogeMaanden);
d9.Parameter2 = parameterFactory.GeefConstanteParameter(1);
d9.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//Tk <= -3
DeterminatieVraag d10 = new DeterminatieVraag();
d10.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d10.Parameter2 = parameterFactory.GeefConstanteParameter(-3);
d10.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//TW <= 22
DeterminatieVraag d11 = new DeterminatieVraag();
d11.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d11.Parameter2 = parameterFactory.GeefConstanteParameter(22);
d11.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//NZ <= NW
DeterminatieVraag d12 = new DeterminatieVraag();
d12.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.NeerslagZomer);
d12.Parameter2 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.NeerslagWinter);
d12.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDanOfGelijkAan);
//Boom opmaken vanaf de leafs
Node n14 = new VraagNode(d9);
n14.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[14]));
n14.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[13]));
Node n13 = new VraagNode(d11);
n13.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[10]));
n13.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[11]));
Node n12 = new VraagNode(d12);
n12.VoegKindToeAanJaNode(n13);
n12.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[12]));
Node n11 = new VraagNode(d11);
n11.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[8]));
n11.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[9]));
Node n10 = new VraagNode(d10);
n10.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[7]));
n10.VoegKindToeAanNeeNode(n11);
Node n9 = new VraagNode(d9);
n9.VoegKindToeAanJaNode(n10);
n9.VoegKindToeAanNeeNode(n12);
Node n8 = new VraagNode(d8);
n8.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[6]));
n8.VoegKindToeAanNeeNode(n9);
Node n7 = new VraagNode(d7);
n7.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[5]));
n7.VoegKindToeAanNeeNode(n8);
Node n6 = new VraagNode(d6);
n6.VoegKindToeAanJaNode(n7);
n6.VoegKindToeAanNeeNode(n14);
Node n5 = new VraagNode(d5);
n5.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[3]));
n5.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[4]));
Node n4 = new VraagNode(d4);
n4.VoegKindToeAanJaNode(n5);
n4.VoegKindToeAanNeeNode(n6);
Node n3 = new VraagNode(d3);
n3.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[2]));
n3.VoegKindToeAanNeeNode(n4);
Node n2 = new VraagNode(d2);
n2.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[0]));
n2.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[1]));
Node root = new VraagNode(d1);
root.VoegKindToeAanJaNode(n2);
root.VoegKindToeAanNeeNode(n3);
DeterminatieTree determinatieGraad2 = new DeterminatieTree(root, Graad.graad2);
DeterminatieTree determinatieGraad3 = new DeterminatieTree(root, Graad.graad3);
//Opstellen determinatietree eerste graad
//TW < 10
d1 = new DeterminatieVraag();
d1.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d1.Parameter2 = parameterFactory.GeefConstanteParameter(10);
d1.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//TW < 0
d2 = new DeterminatieVraag();
d2.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d2.Parameter2 = parameterFactory.GeefConstanteParameter(0);
d2.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//(TM >= 10) < 4
d3 = new DeterminatieVraag();
d3.Parameter1 =
parameterFactory.GeefAantalMaandenParameter(AantalMaandenParameterEnum.aantalMaandenMetTemperatuur,
10, vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.GroterDanOfGelijkAan));
d3.Parameter2 = parameterFactory.GeefConstanteParameter(4);
d3.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//TK < 18
d4 = new DeterminatieVraag();
d4.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d4.Parameter2 = parameterFactory.GeefConstanteParameter(18);
d4.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//NJ > 400
d5 = new DeterminatieVraag();
d5.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.TotaleJaarNeerslag);
d5.Parameter2 = parameterFactory.GeefConstanteParameter(400);
d5.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.GroterDan);
//TK < -3
d6 = new DeterminatieVraag();
d6.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurKoudsteMaand);
d6.Parameter2 = parameterFactory.GeefConstanteParameter(-3);
d6.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//TW < 22
d7 = new DeterminatieVraag();
d7.Parameter1 = parameterFactory.GeefSimpeleParameter(SimpeleParameterEnum.temperatuurWarmsteMaand);
d7.Parameter2 = parameterFactory.GeefConstanteParameter(22);
d7.Vergelijking = vergelijkingFactory.GeefVergelijking(VergelijkingenEnum.KleinerDan);
//Tree opstellen eerste graad
n7 = new VraagNode(d7);
n7.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[19]));
n7.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[20]));
n6 = new VraagNode(d6);
n6.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[18]));
n6.VoegKindToeAanNeeNode(n7);
n5 = new VraagNode(d5);
n5.VoegKindToeAanJaNode(n6);
n5.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[21]));
n4 = new VraagNode(d4);
n4.VoegKindToeAanJaNode(n5);
n4.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[22]));
n3 = new VraagNode(d3);
n3.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[17]));
n3.VoegKindToeAanNeeNode(n4);
n2 = new VraagNode(d2);
n2.VoegKindToeAanJaNode(new KenmerkNode(kenmerkList[15]));
n2.VoegKindToeAanNeeNode(new KenmerkNode(kenmerkList[16]));
root = new VraagNode(d1);
root.VoegKindToeAanJaNode(n2);
root.VoegKindToeAanNeeNode(n3);
DeterminatieTree determinatieGraad1 = new DeterminatieTree(root, Graad.graad1);
/*
* ==================================================================
* Proberen opslaan zeker?
* ==================================================================
*/
Continent[] continenten = (new Continent[] { europa, afrika, azie, oceanie, noordAmerika, zuidAmerika });
DeterminatieTree[] trees = (new DeterminatieTree[] { determinatieGraad1, determinatieGraad2, determinatieGraad3 });
context.Continenten.AddRange(continenten);
context.DeterminatieTrees.AddRange(trees);
context.Kenmerken.AddRange(kenmerkList.ToArray());
context.SaveChanges();
}
catch (DbEntityValidationException e)
{
string s = "Fout creatie databank ";
foreach (var eve in e.EntityValidationErrors)
{
s += String.Format("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.GetValidationResult());
foreach (var ve in eve.ValidationErrors)
{
s += String.Format("- IsActief: \"{0}\", Error: \"{1}\"", ve.PropertyName, ve.ErrorMessage);
}
}
throw new Exception(s);
}
}
public static SqlParameter BuildParameter(string parameterName, object value, DbType type, int size = 0)
{
return(ParameterFactory.BuildParameter(parameterName, value, type, size));
}
/// <summary>
/// Инициализирует параменты. Производные классы вызывают этот метод где-то в конструкторе (обычно в конце).
/// </summary>
protected void InitializeParameters()
{
var factory = new ParameterFactory(Plugin, parameterCategory, parameterPrefix);
InitializeParameters(factory);
}
void DefineParameters(ParameterDeclarationCollection parameters, ParameterFactory defineParameter)
{
int last = parameters.Count - 1;
for (int i=0; i<parameters.Count; ++i)
{
ParameterBuilder paramBuilder = defineParameter(i+1, GetParameterAttributes(parameters[i]), parameters[i].Name);
if (last == i && parameters.VariableNumber)
{
SetParamArrayAttribute(paramBuilder);
}
SetBuilder(parameters[i], paramBuilder);
}
}
void DefineParameters(ParameterDeclarationCollection parameters, ParameterFactory defineParameter)
{
for (int i=0; i<parameters.Count; ++i)
{
ParameterBuilder paramBuilder = defineParameter(i+1, GetParameterAttributes(parameters[i]), parameters[i].Name);
if (parameters[i].IsParamArray)
{
SetParamArrayAttribute(paramBuilder);
}
SetBuilder(parameters[i], paramBuilder);
}
}
public CodeSystemMetadataModule(
ISwaggerModelCatalog modelCatalog,
ISwaggerTagCatalog tagCatalog)
: base(modelCatalog, tagCatalog)
{
modelCatalog.AddModel <CodeSystemApiModel>();
modelCatalog.AddModel <MultipleCodeSystemQuery>();
modelCatalog.AddModel <Guid>();
this.RouteDescriber.DescribeRouteWithParams(
"GetAll",
"Returns the collection of all available code systems",
"Gets a collection of all available code systems",
new[]
{
new HttpResponseMetadata <IEnumerable <CodeSystemApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
Array.Empty <Parameter>(),
new[] { TagsFactory.GetCodeSystemTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetCodeSystem",
"Returns a code system by it's CodeSystemGuid (key)",
"Gets a CodeSystem by it's CodeSystemGuid",
new[]
{
new HttpResponseMetadata <CodeSystemApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[] { ParameterFactory.GetCodeSystemGuid() },
new[] { TagsFactory.GetCodeSystemTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetCodeSystems",
"Gets multiple CodeSystems",
"Gets an array of CodeSystems matching the CodeSystemGuid collection",
new[]
{
new HttpResponseMetadata <IEnumerable <CodeSystemApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
new BodyParameter <MultipleCodeSystemQuery>(modelCatalog)
{
Required = true, Name = "Model"
}
},
new[] { TagsFactory.GetCodeSystemTag() });
}
public ValueSetMetadataModule(
ISwaggerModelCatalog modelCatalog,
ISwaggerTagCatalog tagCatalog,
TerminologySqlSettings settings)
: base(modelCatalog, tagCatalog)
{
modelCatalog.AddModels(
typeof(CodeSetCodeApiModel),
typeof(CodeSystem),
typeof(FindByTermQuery),
typeof(PagedCollection <ValueSetApiModel>),
typeof(PagerSettings),
typeof(ValueSetApiModel),
typeof(ValueSetCodeApiModel),
typeof(ValueSetCreationApiModel));
// /{valueSetId}
this.RouteDescriber.DescribeRouteWithParams(
"GetValueSet",
"Returns one or more ValueSet(s) by ValueSetUniqueId(s)",
"Gets a ValueSet by it's ValueSetUniqueId or a collection of ValueSets by CSV of ValueSetUniqueId(s)",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 404, Message = "Not Found"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[] { ParameterFactory.GetValueSetIdArray(), ParameterFactory.GetSummary(), ParameterFactory.GetCodeSystemCodesArray() },
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"GetPaged",
"Returns a paged list of ValueSets",
"Gets a paged collection of ValueSets",
new[]
{
new HttpResponseMetadata <PagedCollection <ValueSetApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
ParameterFactory.GetSkip(),
ParameterFactory.GetTop(settings.DefaultItemsPerPage),
ParameterFactory.GetSummary(),
ParameterFactory.GetCodeSystemCodesArray()
},
new[] { TagsFactory.GetValueSetTag() });
this.RouteDescriber.DescribeRouteWithParams(
"Find",
"Search by 'Name' of ValueSet operation",
"Gets a paged collection of ValueSet's matching the 'Name' filter",
new[]
{
new HttpResponseMetadata <PagedCollection <ValueSetApiModel> > {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
//ParameterFactory.GetContentType(),
new BodyParameter <FindByTermQuery>(modelCatalog)
{
Required = false
}
},
new[] { TagsFactory.GetValueSetFindTag() });
this.RouteDescriber.DescribeRouteWithParams(
"AddValueSet",
"Creates a new value set",
"Creates a new value set",
new[]
{
new HttpResponseMetadata <ValueSetApiModel> {
Code = 200, Message = "OK"
},
new HttpResponseMetadata {
Code = 500, Message = "Internal Server Error"
}
},
new[]
{
//ParameterFactory.GetContentType(),
new BodyParameter <ValueSetCreationApiModel>(modelCatalog)
{
Required = true
}
},
new[]
{
TagsFactory.GetValueSetTag()
});
}
public QuerySession(DbConnection connection, ParameterFactory parameterFactory, IsolationLevel isolationLevel)
: base(connection, isolationLevel)
{
_parameterFactory = parameterFactory;
}
