public static bool IsTypeEqualToParameterTypeEnum(this Type type, ParameterTypeEnum parameterTypeEnum)
{
switch (parameterTypeEnum)
{
case ParameterTypeEnum.ArrayInt:
return(type == typeof(int[]));
case ParameterTypeEnum.Int:
return(type == typeof(int));
case ParameterTypeEnum.ArrayString:
return(type == typeof(string[]));
case ParameterTypeEnum.String:
return(type == typeof(string));
case ParameterTypeEnum.ArrayChar:
return(type == typeof(char[]));
case ParameterTypeEnum.Char:
return(type == typeof(char));
case ParameterTypeEnum.ArrayDouble:
return(type == typeof(double[]));
case ParameterTypeEnum.Double:
return(type == typeof(double));
default:
return(false);
}
}
public ArgumentDescription(ParameterTypeEnum ptype, Boolean required, string name = "")
{
ParameterType = ptype;
Required = required;
Name = name;
BoolValue = null;
Value = null;
}
public static RealExercise Create(string exerciseAssemblyName, ParameterTypeEnum parameterTypeEnum)
{
var objectType = Type.GetType(exerciseAssemblyName);
// var exercise = (RealExercise)Activator.CreateInstance(exerciseAssemblyName, ServiceLocator.Resolve<IParameter>());
return(Activator.CreateInstance(objectType) as RealExercise);
}
public static ParameterValue CreateParameter(string parameterValue, ParameterTypeEnum parameterTypeEnum)
{
// not needed anymore
//if (!ValidateType(parameterTypeEnum))
// throw new Exception("Invalid type");
return(new ParameterValue(ConvertStringToCorrespondentValue(parameterValue, parameterTypeEnum)));
}
public Exercise(int id, string name, string assemblyName, ParameterTypeEnum parameterTypeEnum, ParameterTypeEnum resultTypeEnum)
{
Id = id;
Name = name;
AssemblyName = assemblyName;
ParameterTypeEnum = parameterTypeEnum;
ResultTypeResult = resultTypeEnum;
}
public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
{
System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
this.ParameterType = ((ParameterTypeEnum)(binaryReader.ReadByte()));
this.CombinerIndex = binaryReader.ReadByte();
this.RegisterIndex = binaryReader.ReadByte();
this.ComponentMask = ((ComponentMaskEnum)(binaryReader.ReadByte()));
this.fieldpad = binaryReader.ReadBytes(1);
this.fieldpad0 = binaryReader.ReadBytes(1);
return(pointerQueue);
}
private static int InsertParameter(Parameter parameter, ParameterTypeEnum type)
{
int pkid;
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(_AtParameterID, SqlDbType.Int).Direction = ParameterDirection.Output;
cmd.Parameters.Add(_AtName, SqlDbType.NVarChar, 50).Value = parameter.Name;
cmd.Parameters.Add(_AtType, SqlDbType.Int).Value = (Int32)type;
cmd.Parameters.Add(_AtDescription, SqlDbType.Text).Value = parameter.Description;
SqlHelper.ExecuteNonQueryReturnPKID("ParameterInsert", cmd, out pkid);
return(pkid);
}
private static int CountParameterByName(string name, ParameterTypeEnum type)
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(_AtName, SqlDbType.NVarChar, 50).Value = name;
cmd.Parameters.Add(_AtType, SqlDbType.Int).Value = (Int32)type;
using (SqlDataReader sdr = SqlHelper.ExecuteReader("CountParameterByName", cmd))
{
while (sdr.Read())
{
return(Convert.ToInt32(sdr[_DbCount]));
}
}
return(-1);
}
private static IEnumerable <ParameterBase> executeStoredProcedure(string query,
IEnumerable <IConvertToMiddlewareParam> paramList,
Session currentSession,
ParameterTypeEnum returnWanted,
out Exception error)
{
StoredProcedure theStoredProc = null;
if (StoredProcStore.TheStoredProcStore.TryGetSproc(query.GetHashCode(), out theStoredProc))
{
return(executeQuery(theStoredProc.TheQuerry, paramList, currentSession, returnWanted, out error));
}
error = new ArgumentException("Stored Procedure Not Found");
return(null);
}
/// <summary>
/// Returns the specific parameter or null
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="parameterType"></param>
/// <returns></returns>
public T FindParameter <T>(ParameterTypeEnum parameterType) where T : class, IParameter
{
if (_parameters.ContainsKey(parameterType))
{
if (_parameters[parameterType] is PrefixedParameter <T> )
{
return(((PrefixedParameter <T>)_parameters[parameterType]).SubParameter);
}
else
{
return((T)_parameters[parameterType]);
}
}
else
{
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="pkid"></param>
/// <param name="name"></param>
/// <param name="type"></param>
/// <returns></returns>
public List <Parameter> GetParameterByCondition(int pkid, string name, ParameterTypeEnum type)
{
SqlCommand cmd = new SqlCommand();
cmd.Parameters.Add(_AtParameterID, SqlDbType.Int).Value = pkid;
cmd.Parameters.Add(_AtName, SqlDbType.NVarChar, 50).Value = name;
cmd.Parameters.Add(_AtType, SqlDbType.Int).Value = (Int32)type;
List <Parameter> parameters = new List <Parameter>();
using (SqlDataReader sdr = SqlHelper.ExecuteReader("GetParameterByCondition", cmd))
{
while (sdr.Read())
{
parameters.Add(new Parameter((Int32)sdr[_ParameterID], sdr[_Name].ToString(), sdr[_Description].ToString()));
}
}
return(parameters);
}
internal static IRacoonResponse CreateResponse(ParameterTypeEnum returnWanted)
{
if (returnWanted.HasFlag(ParameterTypeEnum.Multivalue))
{
return(new MultiVariableResponse()); //it matters not what the sub type is here
}
//it;s a single parameter type
switch (returnWanted)
{
case ParameterTypeEnum.String:
return(new ExecuteQueryResponse());
case ParameterTypeEnum.ByteArray:
return(new ExecuteQueryBytesResponse());
case ParameterTypeEnum.NoExtraData:
return(new SimpleRacoonResponse());
}
return(null);
}
/// <summary>
/// This parameter returns a ParameterTypeEnum for the string given.
/// </summary>
/// <param name="parameterTypeSource"></param>
/// <returns></returns>
public static ParameterTypeEnum ParseParameterType(string parameterTypeSource)
{
// initial value
ParameterTypeEnum parameterType = ParameterTypeEnum.No_Parameters;
// determine ParameterType for each case
switch (parameterTypeSource)
{
case "Field_Set":
case "Field Set":
// set parameterType
parameterType = ParameterTypeEnum.Field_Set;
// required
break;
case "No Parameters":
case "No_Parameters":
// set parameterType
parameterType = ParameterTypeEnum.No_Parameters;
// required
break;
case "Single Field":
case "Single_Field":
// set parameterType
parameterType = ParameterTypeEnum.Single_Field;
// required
break;
}
// return value
return(parameterType);
}
public static IRacoonResponse ExecuteQueryAllTypes(byte[] token, string query, IEnumerable <IConvertToMiddlewareParam> inputParameterList,
ParameterTypeEnum returnTypeWanted, bool addLanuageParam = false)
{
Exception error = null;
IRacoonResponse res = CreateResponse(returnTypeWanted);
Session currentSession;
if (SessionStore.TryGetValidSession(token, out currentSession))
{
IEnumerable <ParameterBase> responseParameters = null;
if (addLanuageParam)
{
addLanuageParameter(inputParameterList, currentSession);
}
//ascertain if the passed string is a sp or a sparql query.
//More complex differentiation could go here to allow things other
//than stored procedures to be passed to other datastores for example
if (query.Contains(" "))
{
responseParameters = executeSPARQL(query, inputParameterList, currentSession, returnTypeWanted, out error);
}
else
{
responseParameters = executeStoredProcedure(query, inputParameterList, currentSession, returnTypeWanted, out error);
}
if ((responseParameters != null) && (res is IResponseWithOutput))
{
((IResponseWithOutput)res).SetOutputParameters(responseParameters);
}
SuccessResponse(res, error);
}
else
{
SecurityFailureResponse(res);
}
return(res);
}
public static string GetParameterNameByType(ParameterTypeEnum parameterTypeEnum)
{
switch (parameterTypeEnum)
{
case ParameterTypeEnum.ContractType:
return("合同类型");
case ParameterTypeEnum.Position:
return("职位");
case ParameterTypeEnum.LeaveRequestType:
return("请假类型");
case ParameterTypeEnum.SkillType:
return("技能类型");
case ParameterTypeEnum.TrainFBQuesType:
return("反馈问题类型");
default:
return("");
}
}
public void Setup(ParameterTypeEnum type, string value, string path)
{
Type = type;
Value = value;
Path = ValidatePath(path);
}
/// <summary>
/// This executes the saved SPARQL against the passed server and with the passed parameters
/// </summary>
/// <param name="parameters">Parameters to pass on to the SPARQL query. Can be any of the types that extend MiddlewareParameter</param>
/// <param name="session">This holds server details, including username and password</param>
/// <returns></returns>
public IEnumerable <MiddlewareParameter> ExecuteSelect(IEnumerable <MiddlewareParameter> parameters, Session session, ParameterTypeEnum returnTypeWanted)
{
StardogConnector theConnector = getConnector(session);
SparqlParameterizedString query = getQuery(parameters, sparql);
try
{
IEnumerable <SparqlResult> queryResult = theConnector.Query(query.ToString()) as SparqlResultSet;//actually fire the query
if (queryResult.Count <SparqlResult>() == 0)
{
return(Enumerable.Empty <MiddlewareParameter>());//Don't do unnecessary processing, but returning null causes crashes further up
}
List <MiddlewareParameter> Result = new List <MiddlewareParameter>();
bool linkParams = returnTypeWanted.HasFlag(ParameterTypeEnum.Multivalue);
//I stay null if not doing multivalue requests
MiddlewareParameter <List <MiddlewareParameter> > multiValue = null;
int lineNumber = 1;
foreach (SparqlResult res in queryResult)//for each line
{
if (linkParams)
{
multiValue = new MiddlewareParameter <List <MiddlewareParameter> >(MiddlewareParameterDirection.Out);
multiValue.ParamName = lineNumber++.ToString();
multiValue.ParamValue = new List <MiddlewareParameter>();
returnTypeWanted &= ~ParameterTypeEnum.Multivalue; //The effect of this is allowing us to switch on the return type wanted
}
foreach (KeyValuePair <string, INode> parameterValue in res) //each parameter
{
if (linkParams)
{
handleLanguageTags(multiValue, parameterValue);
}
MiddlewareParameter toAdd = null;
switch (returnTypeWanted)
{
case ParameterTypeEnum.AsSource:
toAdd = createAsPerSourceType(parameterValue);
break;
case ParameterTypeEnum.String:
toAdd = createStringParameter(parameterValue);
break;
case ParameterTypeEnum.ByteArray:
toAdd = createByteParameter(parameterValue);
break;
case ParameterTypeEnum.Uri:
toAdd = createUriParameter(parameterValue);
break;
default:
throw new ArgumentException("Invalid return parameter type specified");
}
if ((toAdd != null) && (!linkParams))
{
Result.Add(toAdd);
}
else if (linkParams)
{
multiValue.ParamValue.Add(toAdd);
}
}
if (linkParams)
{
Result.Add(multiValue);
}
}
return(Result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(query.CommandText);
throw ex;
}
}
void InitializeViews()
{
double moveRatio = 0.1, zoomRatio = Math.Pow(2, 0.5);
this.Width = 1200;
this.Height = this.Width * 2 / 3;
this.Content = new Grid
{
RowDefinitions =
{
new RowDefinition {
Height = new GridLength(3, GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1, GridUnitType.Star)
}
},
ColumnDefinitions =
{
new ColumnDefinition {
Width = new GridLength(2, GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1, GridUnitType.Star)
}
},
Children =
{
SetGridPosition(0, 0, IMGmap = new Image(), 1, 2),
SetGridPosition(1, 0, MainViewPort = new Viewport3D {
ClipToBounds = true
}),
SetGridPosition(1, 1, new Func <UIElement>(() =>
{
string[] tx = { "Height", "Angle", "WHratio" };
Label l1 = new Label {
Content = tx[0]
}, l2 = new Label {
Content = tx[1]
}, lx = new Label(), ly = new Label();
TextBox txbFixed = NewTextBox("...",new Func <string, bool>(s =>
{
double v;
if (!double.TryParse(s, out v))
{
return(false);
}
currentValue.z = v;
Draw();
return(true);
}));
updateInfo = new Action(() =>
{
lx.Content = $"{minValue.x} ~ {maxValue.x}";
ly.Content = $"{minValue.y} ~ {maxValue.y}";
txbFixed.Text = currentValue.z.ToString();
});
return(new Grid
{
RowDefinitions =
{
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
},
new RowDefinition {
Height = new GridLength(1,GridUnitType.Star)
}
},
ColumnDefinitions =
{
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1,GridUnitType.Star)
}
},
Children =
{
SetGridPosition(0, 0, LBstatus = new Label {
Content = "Hello world!"
}, 5, 1),
SetGridPosition(0, 1, NewRadioButton(tx[0], delegate { ParameterType= ParameterTypeEnum.Height; l1.Content = tx[1]; l2.Content = tx[2]; Draw(); })),
SetGridPosition(1, 1, NewRadioButton(tx[1], delegate { ParameterType= ParameterTypeEnum.Angle; l1.Content = tx[0]; l2.Content = tx[2]; Draw(); })),
SetGridPosition(2, 1, NewRadioButton(tx[2], delegate { ParameterType= ParameterTypeEnum.WHratio; l1.Content = tx[0]; l2.Content = tx[1]; Draw(); }, true)),
SetGridPosition(3, 1, txbFixed, 2, 1),
SetGridPosition(0, 2, l1, 1, 2),
SetGridPosition(0, 4, l2, 1, 2),
SetGridPosition(1, 2, NewButton("←→", new Action(() => { maxValue.x= minValue.x + (maxValue.x - minValue.x) * zoomRatio; Draw(); }))),
SetGridPosition(2, 2, NewButton("→←", new Action(() => { maxValue.x= minValue.x + (maxValue.x - minValue.x) / zoomRatio; Draw(); }))),
SetGridPosition(3, 2, NewButton("←", new Action(() => { var v= (maxValue.x - minValue.x) * moveRatio; minValue.x -= v; maxValue.x -= v; Draw(); }))),
SetGridPosition(4, 2, NewButton("→", new Action(() => { var v= (maxValue.x - minValue.x) * moveRatio; minValue.x += v; maxValue.x += v; Draw(); }))),
SetGridPosition(1, 3, lx, 4, 1),
SetGridPosition(1, 4, NewButton("←→", new Action(() => { maxValue.y= minValue.y + (maxValue.y - minValue.y) * zoomRatio; Draw(); }))),
SetGridPosition(2, 4, NewButton("→←", new Action(() => { maxValue.y= minValue.y + (maxValue.y - minValue.y) / zoomRatio; Draw(); }))),
SetGridPosition(3, 4, NewButton("↓", new Action(() => { var v= (maxValue.y - minValue.y) * moveRatio; minValue.y -= v; maxValue.y -= v; Draw(); }))),
SetGridPosition(4, 4, NewButton("↑", new Action(() => { var v= (maxValue.y - minValue.y) * moveRatio; minValue.y += v; maxValue.y += v; Draw(); }))),
SetGridPosition(1, 5, ly, 4, 1),
SetGridPosition(0, 6, new Label {
Content = "Parallelism:"
}),
SetGridPosition(1, 6, NewTextBox(maxDegreeOfParallelism.ToString(), new Func <string, bool>(s =>
{
int v;
if (!int.TryParse(s, out v))
{
return false;
}
maxDegreeOfParallelism = v;
return true;
}))),
SetGridPosition(3, 6, NewCheckBox("Binray Color", new Action <bool>(c => binaryColor= c), binaryColor), 2, 1),
SetGridPosition(0, 7, new Grid
{
ColumnDefinitions =
{
new ColumnDefinition {
Width = new GridLength(1, GridUnitType.Star)
},
new ColumnDefinition {
Width = new GridLength(1, GridUnitType.Star)
}
},
Children =
{
SetGridPosition(0, 0, NewRadioButton("Rectangle", new Action(() => { simulateHexagon= false; Draw(); }), true)),
SetGridPosition(1, 0, NewRadioButton("Hexagon", new Action(() => { simulateHexagon= true; Draw(); })))
}
}, 5, 1)
}
});
})())
}
};
IMGmap.MouseLeftButtonDown += IMGmap_MouseLeftButtonDown;
//default(Grid).colu
//new TuneWindow(Camera, EnvironmentLight).Show();
//new PictureWindow(Constants.picturePort).Show();
}
// This function checks to see if the user input parameters
// are valid and useable (with the exception of directory)
private ErrorCodeEnum CheckParameters(ParameterTypeEnum par_type_id)
{
if (par_type_id != ParameterTypeEnum.ThermoCouples &&
par_type_id != ParameterTypeEnum.Oven)
{
MessageBox.Show(
String.Format(
"Invalid Parameter Type ({0}) submitted to Check Parameters Function.",
Enum.GetName(typeof(ParameterTypeEnum),par_type_id)),
" ERROR!");
return ErrorCodeEnum.Error;
}
int check = 0;
if (String.IsNullOrWhiteSpace(UserNameTextBox.Text) || UserNameTextBox.Text == "User")
{
UserNameTextBox.BackColor = Color.MistyRose;
check++;
}
else
UserNameTextBox.BackColor = Color.White;
if (String.IsNullOrWhiteSpace(BatchIDCodeTextBox.Text) ||
BatchIDCodeTextBox.Text == "_" || BatchIDCodeTextBox.Text ==
UserNameTextBox.Text)
{
BatchIDCodeTextBox.BackColor = Color.MistyRose;
check++;
}
else
BatchIDCodeTextBox.BackColor = Color.White;
if (String.IsNullOrWhiteSpace(OvenNameTextBox.Text))
{
OvenNameTextBox.BackColor = Color.MistyRose;
check++;
}
else
OvenNameTextBox.BackColor = Color.White;
if (par_type_id == ParameterTypeEnum.Oven)
{
try
{
String[] delimeters = new String[] { ",", ";" };
String[] email_addresses = UserEmailTextBox.Text.Split(delimeters,
StringSplitOptions.RemoveEmptyEntries);
if (email_addresses.Length <= 0)
{
throw new Exception("Email Address cannot be blank.");
}
foreach (string addr in email_addresses)
{
if (!Regex.IsMatch(addr.Trim(), permissive_email_reg_ex))
{
throw new Exception(
String.Format(
"Invalid Email Address: {0}{1}",
Environment.NewLine,
addr));
}
}
if (UserEmailTextBox.Text == "*****@*****.**")
throw new Exception("Please change the email address to a " +
"different email from the default email address.");
UserEmailTextBox.BackColor = Color.White;
}
catch
{
UserEmailTextBox.BackColor = Color.MistyRose;
check++;
}
try
{
if (MaxTemperatureNumericUpDown.Value > 800 ||
MaxTemperatureNumericUpDown.Value < 20)
{
MaxTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
else
{
if (MaxTemperatureNumericUpDown.Value >= 150 &&
CoolMethodComboBox.SelectedIndex == 0)
MessageBox.Show(
"Recommend using Nitrogen (N2) " +
"cooling when heating samples to 150 °C and above.",
" SUGGESTION");
MaxTemperatureNumericUpDown.BackColor = Color.White;
}
}
catch
{
MaxTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
try
{
if (HoldTimeAtPeakNumericUpDown.Value > 100 ||
HoldTimeAtPeakNumericUpDown.Value < 5)
{
HoldTimeAtPeakNumericUpDown.BackColor = Color.MistyRose;
check++;
}
else
HoldTimeAtPeakNumericUpDown.BackColor = Color.White;
}
catch
{
HoldTimeAtPeakNumericUpDown.BackColor = Color.MistyRose;
check++;
}
if (CoolMethodComboBox.SelectedItem == null)
{
CoolMethodComboBox.BackColor = Color.MistyRose;
check++;
}
else if (CoolMethodComboBox.SelectedIndex == 1)
{
SwitchToAirTemperatureNumericUpDown.Enabled = true;
try
{
if (SwitchToAirTemperatureNumericUpDown.Value > 500 ||
SwitchToAirTemperatureNumericUpDown.Value < 20)
{
SwitchToAirTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
else
SwitchToAirTemperatureNumericUpDown.BackColor = Color.White;
}
catch
{
SwitchToAirTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
CoolMethodComboBox.BackColor = Color.White;
}
else if (CoolMethodComboBox.SelectedIndex == 0)
{
SwitchToAirTemperatureNumericUpDown.Value = 20;
SwitchToAirTemperatureNumericUpDown.BackColor = Color.White;
SwitchToAirTemperatureNumericUpDown.Enabled = false;
CoolMethodComboBox.BackColor = Color.White;
}
else
CoolMethodComboBox.BackColor = Color.White;
try
{
if (StopCoolingTemperatureNumericUpDown.Value > 50 ||
StopCoolingTemperatureNumericUpDown.Value < 25)
{
StopCoolingTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
else
StopCoolingTemperatureNumericUpDown.BackColor = Color.White;
}
catch
{
StopCoolingTemperatureNumericUpDown.BackColor = Color.MistyRose;
check++;
}
try
{
if (!Program.pid_settings_form.ProgramPidSettings.IsChanged)
{
OpenPIDSettingsWindowButton.BackColor = Color.OrangeRed;
check++;
}
else
{
OpenPIDSettingsWindowButton.BackColor = DefaultBackColor;
}
}
catch
{
OpenPIDSettingsWindowButton.BackColor = Color.MistyRose;
check++;
}
}
if (check > 0)
{
return ErrorCodeEnum.Error;
}
else
{
return ErrorCodeEnum.NoError;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterTypedValue"/> class.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
public ParameterTypedValue(object value, ParameterTypeEnum type = ParameterTypeEnum.ValueParameter)
{
ParameterType = type;
ParameterValue = value;
}
public static void CreateConfigItemIfNotExists(this UnitOfWork uow, List <ConfigurationStatic> existingItems, string configName, ParameterTypeEnum type, string groupName)
{
var existingItem = existingItems.FirstOrDefault(x => x.ParameterName == configName);
if (existingItem == null)
{
new ConfigurationStatic(uow)
{
ParameterName = configName, ParameterType = type, GroupName = groupName
};
uow.CommitChanges();
}
}
public void Setup(ParameterTypeEnum type, string value, string path)
{
Type = type;
Value = value;
Path = ValidatePath(path);
}
public IEnumerable <MiddlewareParameter> Execute(IEnumerable <MiddlewareParameter> parameters, Session session, ParameterTypeEnum returnTypeWanted)
{
StardogQueryTypeEnum qt = StardogQueryTypeProcess.GetQueryType(this.sparql);
if (qt == StardogQueryTypeEnum.SELECT)
{
return(ExecuteSelect(parameters, session, returnTypeWanted));
}
if (qt == StardogQueryTypeEnum.INSERT)
{
Task.Run(() => ExecuteInsert(parameters, session));
return(Enumerable.Empty <MiddlewareParameter>());
}
throw new InvalidOperationException("Could not asertain query type");
}
private static object ConvertStringToCorrespondentValue(string parameterValue, ParameterTypeEnum parameterTypeEnum)
{
if (parameterTypeEnum == ParameterTypeEnum.ArrayInt)
{
return(ConvertStringToArrayInt(parameterValue));
}
if (parameterTypeEnum == ParameterTypeEnum.ArrayDouble)
{
return(ConvertStringToArrayDouble(parameterValue));
}
return(true);
}
private static IEnumerable <ParameterBase> executeQuery(IQuerry anyQueryToExecute, IEnumerable <IConvertToMiddlewareParam> paramList, Session currentSession, ParameterTypeEnum returnWanted, out Exception error)
{
error = null;
try
{
IEnumerable <MiddlewareParameter> results = anyQueryToExecute.Execute(paramList.ConvertToInternalParameter(), currentSession, returnWanted);
return(results.ConvertToOutput());
}
catch (Exception ex)
{
error = ex;
return(Enumerable.Empty <ParameterBase>());
}
}
internal static IEnumerable <ParameterBase> executeSPARQL(string query, IEnumerable <IConvertToMiddlewareParam> paramList, Session currentSession, ParameterTypeEnum returnWanted, out Exception error)
{
StardogQuery queryForStardog = new StardogQuery(query); //if it's a sparql query it's definitely for stardog, not any other data store
return(executeQuery(queryForStardog, paramList, currentSession, returnWanted, out error));
}
public IEnumerable <MiddlewareParameter> Execute(IEnumerable <MiddlewareParameter> parameters, Session session, ParameterTypeEnum returnTypeWanted)
{
IDatabase db = REDISConnector.REDISConnector.GetRedis().GetDatabase(datastore);
// loaded.Evaluate(db, convertParamNames(parameters),convertParamValues(parameters));
RedisResult res = db.ScriptEvaluate(loaded.Hash, convertParamNames(parameters), convertParameterValues(parameters));
return(new List <MiddlewareParameter> {
new MiddlewareParameter <string>("RedisResult", res.ToString(), MiddlewareParameterDirection.Out)
});
}
