public Parameter(ParameterType parType, TokenTypes tokType, object column, object value)
{
this.TokType = tokType;
this.ParType = parType;
this.Column = column.ToString();
this.Value = value;
}
/// <summary>
/// Converts the object to an array of RestSharp parameters.
/// </summary>
/// <returns>The array of RestSharp parameters.</returns>
public IEnumerable<Parameter> ToParameters(ParameterType type)
{
List<Parameter> output = new List<Parameter>();
//Inspiration for this code from https://github.com/jaymedavis/stripe.net
foreach (PropertyInfo property in GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
object value = property.GetValue(this, null);
string propName = property.Name;
if (value == null)
{
continue;
}
if (property.CustomAttributes.Any(x => x.AttributeType == typeof(JsonPropertyAttribute)))
{
//Get the JsonPropertyAttribute for this property, which will give us its JSON name
JsonPropertyAttribute attribute = property.GetCustomAttributes(typeof(JsonPropertyAttribute), false).Cast<JsonPropertyAttribute>().FirstOrDefault();
propName = attribute != null ? attribute.PropertyName : property.Name;
}
var parameter = ToSingleParameter(propName, value, property, type);
output.Add(parameter);
}
return output;
}
public override void DrawGUI(IntelligenceState parentState, Intelligence intelligence, CallbackCollection callbacks)
{
#if UNITY_EDITOR
UnityEditor.EditorGUILayout.BeginHorizontal();
UnityEngine.GUILayout.Label("Method name:");
methodName = UnityEditor.EditorGUILayout.TextField(methodName);
UnityEditor.EditorGUILayout.EndHorizontal();
useTargetVar = UnityEditor.EditorGUILayout.Toggle("Use other target", useTargetVar);
if (useTargetVar)
{
UnityEditor.EditorGUILayout.BeginHorizontal();
UnityEngine.GUILayout.Label("Target var name:");
targetVarName = UnityEditor.EditorGUILayout.TextField(targetVarName);
UnityEditor.EditorGUILayout.EndHorizontal();
}
paramType = (ParameterType)UnityEditor.EditorGUILayout.EnumPopup("Parameter:", paramType);
if (paramType == ParameterType.VarValue)
{
UnityEditor.EditorGUILayout.BeginHorizontal();
UnityEngine.GUILayout.Label("Var name:");
paramTypeValue = UnityEditor.EditorGUILayout.TextField(paramTypeValue);
UnityEditor.EditorGUILayout.EndHorizontal();
}
if (paramType == ParameterType.String)
{
UnityEditor.EditorGUILayout.BeginHorizontal();
UnityEngine.GUILayout.Label("Value:");
paramTypeValue = UnityEditor.EditorGUILayout.TextField(paramTypeValue);
UnityEditor.EditorGUILayout.EndHorizontal();
}
#endif
}
public PersistedParameterInfo(string name, ParameterType parameterType, bool nullable, string defaultValue)
{
Name = name;
ParameterType = parameterType;
Nullable = nullable;
DefaultValue = defaultValue;
}
public Parameter(ParameterInfo parameterInfo, object value, ParameterType parameterType)
{
ParameterInfo = parameterInfo;
ParameterValue = value;
ParameterType = parameterType;
Type = value.GetType();
}
public Parameter(string name, ParameterType type, string desc, int value = 0)
{
Name = name;
ParameterType = type;
Description = desc;
Value = value;
}
public ParameterSchema (ParameterSchema param)
: base (param)
{
this.dataType = param.dataType;
this.paramType = param.paramType;
this.position = param.position;
}
public Parameter(string name, ParameterType type, string minValue, string maxValue)
{
this.nameField = name;
this.typeField = type;
this.minValueField = minValue;
this.maxValueField = maxValue;
}
public ProcedureParameter(string name, ParameterType type, object value, int size)
{
Name = name;
Type = type;
Value = value;
Size = size;
}
public JConnect(IDbConnection connection)
{
this.connection = connection;
commandTimeout = 30;
Type type = connection.GetType();
if (type == typeof(System.Data.Odbc.OdbcConnection))
{
typeOfParameter = ParameterType.QuestionMark;
typeOfVendor = VendorType.Odbc;
}
else if (type == typeof(System.Data.OleDb.OleDbConnection))
{
typeOfParameter = ParameterType.QuestionMark;
typeOfVendor = VendorType.OleDb;
}
else if (type == typeof(System.Data.SqlClient.SqlConnection))
{
typeOfParameter = ParameterType.AtSymbol;
typeOfVendor = VendorType.SqlServer;
GetReturningProc += new GetReturningHandler(SqlServerReturning);
}
else
{
typeOfParameter = ParameterType.Colon;
typeOfVendor = VendorType.Oracle;
GetReturningProc += new GetReturningHandler(OracleReturning);
}
GetTimeStampProc += new GetTimeStampHandler(DefaultGetTimeStampProc);
}
public ProcedureParameter(string name, ParameterType type, ParameterDirection direction, object value)
{
Name = name;
Type = type;
Direction = direction;
Value = value;
}
private static Anito.Data.ParameterType GetParameterType(ParameterType parameterType)
{
switch (parameterType)
{
case ParameterType.Binary:
return Anito.Data.ParameterType.Binary;
case ParameterType.Boolean:
return Anito.Data.ParameterType.Boolean;
case ParameterType.Byte:
return Anito.Data.ParameterType.Byte;
case ParameterType.Currency:
return Anito.Data.ParameterType.Currency;
case ParameterType.DateTime:
return Anito.Data.ParameterType.DateTime;
case ParameterType.Decimal:
return Anito.Data.ParameterType.Decimal;
case ParameterType.Double:
return Anito.Data.ParameterType.Double;
case ParameterType.Int16:
return Anito.Data.ParameterType.Int16;
case ParameterType.Int32:
return Anito.Data.ParameterType.Int32;
case ParameterType.Int64:
return Anito.Data.ParameterType.Int64;
case ParameterType.Single:
return Anito.Data.ParameterType.Single;
case ParameterType.String:
return Anito.Data.ParameterType.String;
case ParameterType.UId:
return Anito.Data.ParameterType.UId;
default:
return Anito.Data.ParameterType.String;
}
}
public ParameterControl(ArticleRecord article, ParameterType type, int batchNumber)
: this()
{
Article = article;
_parameterType = type;
InitPropertiesByType(type);
BatchNumber = batchNumber;
NewMeasurementsDataGrid.ItemsSource = _batch;
InitUpdateMeasuredValueTimer();
_inputDevice.DataReceived += inputDevice_DataReceived;
_inputDevice.ErrorReceived += inputDevice_ErrorReceived;
_bwloader.DoWork += bwloader_DoWork;
_bwloader.RunWorkerCompleted += bwloader_RunWorkerCompleted;
//MeasuringValueBG1.Minimum = MeasuringValueBG2.Minimum = _nominalValue;
//MeasuringValueBG2.Maximum = _maxValue + 3;
//_difference = _nominalValue - _minValue;
//MeasuringValueBG1.Maximum = _nominalValue + _difference +3;
MeasuringValueBG1.Minimum = MeasuringValueBG2.Minimum = _nominalValue;
MeasuringValueBG2.Maximum = 14;
_difference = _nominalValue - _minValue;
MeasuringValueBG1.Maximum = 14;
_bwloader.RunWorkerAsync();
}
/// <summary>
/// Returns shared or built-in parameter of the specified name. parameter.IsShared property identifies the type.
/// If it does not exist it is created in the shared parameters file with specified name in the specified group. That must be defined in advance
/// using SetDefinitionFile() function.
/// </summary>
/// <param name="paramType">Type of the parameter (simplified to base data types)</param>
/// <param name="groupName">Name of the group of the shared parameters</param>
/// <param name="parameterName">Name of the parameter</param>
/// <param name="group">Revit built in parameter group where the parameter is to be created if it doesn't exist</param>
/// <returns>Existing or new parameter</returns>
public static Parameter GetParameter(this Element element, ParameterType paramType, string parameterName, BuiltInParameterGroup group)
{
Parameter parameter = element.get_Parameter(parameterName);
if (parameter != null)
{
//check type and throw error if the type is different
if (parameter.Definition.ParameterType == paramType)
return parameter; //returns existing parameter (it could be any type of parameter not only shared parameter)
else
throw new Exception(String.Format("Parameter type mismatch for pID '{0}': existing type: {1}, desired type {2}.", parameterName, parameter.Definition.ParameterType, paramType));
}
// Create a category set and insert category of wall to it
CategorySet myCategories = element.Document.Application.Create.NewCategorySet();
// Use BuiltInCategory to get category of wall
Category myCategory = element.Category;
myCategories.Insert(myCategory);
bool success = SetNewSharedParameter(element, paramType, myCategories, parameterName, group);
if (!success)
{
Debug.WriteLine("Parameter creation not successfull.\nParameter name: " + parameterName + "\n Existing parameters:");
foreach (Parameter par in element.Parameters)
{
Debug.WriteLine("Parameter name: " + par.Definition.Name + ", group: " + Enum.GetName(typeof(BuiltInParameterGroup), par.Definition.ParameterGroup));
}
throw new Exception("Parameter creation failed.");
}
parameter = element.get_Parameter(parameterName);
return parameter;
}
internal WrongParameterTypeException(string parameterName, ParameterType oldParameterType, ParameterType newParameterType)
{
mParameterName = parameterName;
mOldParameterType = oldParameterType;
mNewParameterType = newParameterType;
}
public ParameterDefinition(string name, ParameterType type, int min, int max)
{
this.name = name;
this.type = type;
this.min = min;
this.max = max;
}
public InvocationParameterInfo(string name, int index, Type type, ParameterType parameterType)
{
Name = name;
Index = index;
Type = type;
ParameterType = parameterType;
}
public ParameterDefinition(string name, Function defaultValue, int min, int max)
{
this.name = name;
this.type = defaultValue.OutputParameter.type;
this.defaultValue = defaultValue;
this.min = min;
this.max = max;
}
public Parameter(string id, Object val, List<Object> possibleVal, Object defVal, ParameterType typ)
{
this.ID = id;
this.value = val;
this.possibleValues = possibleVal;
this.defaultValue = defVal;
this.paramType = typ;
}
public SignatureParameter(
string name,
ParameterType type)
: this()
{
this.Name = name;
this.Type = type;
}
public SerialCommand(string name, ParameterType type)
{
Initialize();
this.nameField = name;
this.parameterTypeField = type;
InitialDefault();
}
public Binding(PhpReference/*!*/ variable, IDataParameter/*!*/ parameter, ParameterType type)
{
Debug.Assert(variable != null && parameter != null && type != ParameterType.Invalid);
this.Variable = variable;
this.Parameter = parameter;
this.Type = type;
}
public SignatureParameter(
string name,
string holder,
ParameterType type)
: this(name, type)
{
this.Holder = holder;
}
public InterceptedParameter(string name, int index, Type type, object value, ParameterType parametertype)
{
Name = name;
Index = index;
Type = type;
Value = value;
ParameterType = parametertype;
}
public static IntegerParameter Create(ParameterType.Integer name, bool isRequired)
{
IntegerParameterDefinition definition = IntegerMap[name];
string nameString = Enum.GetName(typeof (ParameterType.Integer), name);
string nameStringNotNull = Assertions.InternalValueIsNotNull(() => nameString, () => nameString);
return new IntegerParameter(nameStringNotNull, definition.Id, definition.MinValue, definition.MaxValue,
isRequired);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandLineOption"/> class.
/// </summary>
/// <param name="shortName"> Single character name of this parameter. Optional. </param>
/// <param name="longName"> The long name of this parameter. Optional. </param>
/// <param name="description"> Description of this parameter, to be used in the Usings function. </param>
/// <param name="parameterType"> Type of parameter </param>
/// <param name="setFunction"> Function to call when this parameter is found. Function parameter is found value </param>
public CommandLineOption(char shortName, string longName, string description, ParameterType parameterType, SetOptionDelegate setFunction)
{
this.ShortName = shortName;
this.LongName = longName;
this.Description = description;
this.ParameterType = parameterType;
this.SetFunction = setFunction;
this.IsOptional = true;
}
public override bool Equals(ParameterType other)
{
var otherSimple = other as SimpleParameterType;
if (otherSimple == null)
return false;
return this.Name == otherSimple.Name;
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandLineOption"/> class.
/// This constructor is used to create an unnamed parameter
/// </summary>
/// <param name="description"> Description of this parameter, to be used in the Usings function. </param>
/// <param name="parameterType"> Type of parameter </param>
/// <param name="setFunction"> Function to call when this parameter is found. Function parameter is found value </param>
/// <param name="optional"> If false an exception will be thrown if this parameter can not be found. </param>
public CommandLineOption(string description, ParameterType parameterType, SetOptionDelegate setFunction, bool optional = false)
{
this.ShortName = '\0';
this.LongName = null;
this.Description = description;
this.ParameterType = parameterType;
this.SetFunction = setFunction;
this.IsOptional = optional;
}
public override bool Equals(ParameterType other)
{
var otherEnum = other as EnumParameterType;
if (otherEnum == null)
return false;
return this.Values.SequenceEqual(otherEnum.Values);
}
public static Parameter BuildParameter(string Name, object Value, ParameterType Type)
{
return new Parameter
{
Name = Name,
Value = Value,
Type = Type
};
}
public override int GetHashCode()
{
int hashCode = ControllerName.ToUpperInvariant().GetHashCode() ^ ActionName.ToUpperInvariant().GetHashCode();
if (MediaType != null)
{
hashCode ^= MediaType.GetHashCode();
}
if (SampleDirection != null)
{
hashCode ^= SampleDirection.GetHashCode();
}
if (ParameterType != null)
{
hashCode ^= ParameterType.GetHashCode();
}
foreach (string parameterName in ParameterNames)
{
hashCode ^= parameterName.ToUpperInvariant().GetHashCode();
}
return(hashCode);
}
public CommandBuilder Parameter(string name, ParameterType type = ParameterType.Required)
{
if (_areParamsClosed)
{
throw new Exception($"No parameters may be added after a {nameof(ParameterType.Multiple)} or {nameof(ParameterType.Unparsed)} parameter.");
}
if (!_allowRequiredParams && type == ParameterType.Required)
{
throw new Exception($"{nameof(ParameterType.Required)} parameters may not be added after an optional one");
}
_params.Add(new CommandParameter(name, type));
if (type == ParameterType.Optional)
{
_allowRequiredParams = false;
}
if (type == ParameterType.Multiple || type == ParameterType.Unparsed)
{
_areParamsClosed = true;
}
return(this);
}
private Parameter AddParameter(
ElementDefinition elementDefinition,
ParameterType parameterType,
DomainOfExpertise owner,
string value)
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, null)
{
ParameterType = parameterType,
Owner = owner,
Scale = this.scale
};
var valueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, null)
{
Published = new ValueArray <string>(new List <string> {
value
}),
Manual = new ValueArray <string>(new List <string> {
value
}),
Computed = new ValueArray <string>(new List <string> {
value
}),
Formula = new ValueArray <string>(new List <string> {
value
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(valueSet);
elementDefinition.Parameter.Add(parameter);
return(parameter);
}
public void Init()
{
var requestAttribute = ParameterType.CustomAttribute <HttpRequestAttribute>(true);
if (null != requestAttribute)
{
UrlPattern = requestAttribute.Api;
Method = requestAttribute.Method;
Host = requestAttribute.Host;
ParameterType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).ToList().ForEach(propertyInfo =>
{
var propertyName = propertyInfo.Name;
var getter = ResolveGetter(propertyInfo);
Getters.AddOrUpdate(propertyName, getter, (k, v) => getter);
var attribute = propertyInfo.CustomAttribute <HttpComponentAttribute>(true);
if (null == attribute)
{
return;
}
var component = new HttpComponentInfo(propertyName, attribute, NamingRule);
Components.AddOrUpdate(propertyName, component, (p, a) => component);
});
}
}
public Parameter(string name, object value, string contentType, ParameterType type) : this(name, value, type) => ContentType = contentType;
/// <summary>
/// Adds a parameter to the request. There are four types of parameters:
/// - GetOrPost: Either a QueryString value or encoded form value based on method
/// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection
/// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId}
/// - RequestBody: Used by AddBody() (not recommended to use directly)
/// </summary>
/// <param name="restClient">The IRestClient instance</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <param name="type">The type of parameter to add</param>
/// <returns>This request</returns>
public static void AddDefaultParameter(this IRestClient restClient, string name, object value, ParameterType type)
{
restClient.AddDefaultParameter(new Parameter {
Name = name, Value = value, Type = type
});
}
public FormatTagParameterTypeInfo(ParameterType type, bool canBeQuantifier)
{
Type = type;
CanBeQuantifier = canBeQuantifier;
}
/// <summary>
/// Adds a parameter to the request. There are four types of parameters:
/// - GetOrPost: Either a QueryString value or encoded form value based on method
/// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection
/// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId}
/// - RequestBody: Used by AddBody() (not recommended to use directly)
/// </summary>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <param name="type">The type of parameter to add</param>
/// <returns>This request</returns>
public IRestRequest AddParameter(string name, object value, ParameterType type)
{
return(AddParameter(new Parameter {
Name = name, Value = value, Type = type
}));
}
public Parameter(ParameterType type, String value)
{
mParameterType = type;
mValue = value;
}
private void ShowVarGUI(List <GVar> vars, List <ActionParameter> parameters, ParameterType parameterType)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
if (parameterID == -1)
{
variableNumber = -1;
}
if (vars.Count > 0)
{
foreach (GVar _var in vars)
{
labelList.Add(_var.label);
// If a GlobalVar variable has been removed, make sure selected variable is still valid
if (_var.id == variableID)
{
variableNumber = i;
}
i++;
}
if (variableNumber == -1 && (parameters == null || parameters.Count == 0 || parameterID == -1))
{
// Wasn't found (variable was deleted?), so revert to zero
Debug.LogWarning("Previously chosen variable no longer exists!");
variableNumber = 0;
variableID = 0;
}
parameterID = Action.ChooseParameterGUI("Variable:", parameters, parameterID, parameterType);
if (parameterID >= 0)
{
//variableNumber = 0;
variableNumber = Mathf.Min(variableNumber, vars.Count - 1);
variableID = -1;
}
else
{
variableNumber = EditorGUILayout.Popup("Variable:", variableNumber, labelList.ToArray());
variableID = vars [variableNumber].id;
}
string label = "Statement: ";
if (vars [variableNumber].type == VariableType.Boolean)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
label += "=";
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Boolean);
if (setParameterID < 0)
{
boolValue = (BoolValue)EditorGUILayout.EnumPopup(label, boolValue);
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
if (vars [variableNumber].type == VariableType.PopUp)
{
label += "=";
intValue = EditorGUILayout.Popup(label, intValue, vars[variableNumber].popUps);
}
else if (vars [variableNumber].type == VariableType.Integer)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod);
if (setVarMethod == SetVarMethod.Formula)
{
label += "=";
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
formula = EditorGUILayout.TextField(label, formula);
}
#if UNITY_WP8
EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning);
#endif
}
else
{
if (setVarMethod == SetVarMethod.IncreaseByValue)
{
label += "+=";
}
else if (setVarMethod == SetVarMethod.SetValue)
{
label += "=";
}
else if (setVarMethod == SetVarMethod.SetAsRandom)
{
label += ("= 0 to");
}
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Integer);
if (setParameterID < 0)
{
intValue = EditorGUILayout.IntField(label, intValue);
if (setVarMethod == SetVarMethod.SetAsRandom && intValue < 0)
{
intValue = 0;
}
}
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
else if (vars [variableNumber].type == VariableType.Float)
{
setVarMethodIntBool = (SetVarMethodIntBool)EditorGUILayout.EnumPopup("New value is:", setVarMethodIntBool);
if (setVarMethodIntBool == SetVarMethodIntBool.EnteredHere)
{
setVarMethod = (SetVarMethod)EditorGUILayout.EnumPopup("Method:", setVarMethod);
if (setVarMethod == SetVarMethod.Formula)
{
label += "=";
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
formula = EditorGUILayout.TextField(label, formula);
}
#if UNITY_WP8
EditorGUILayout.HelpBox("This feature is not available for Windows Phone 8.", MessageType.Warning);
#endif
}
else
{
if (setVarMethod == SetVarMethod.IncreaseByValue)
{
label += "+=";
}
else if (setVarMethod == SetVarMethod.SetValue)
{
label += "=";
}
else if (setVarMethod == SetVarMethod.SetAsRandom)
{
label += "= 0 to";
}
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.Float);
if (setParameterID < 0)
{
floatValue = EditorGUILayout.FloatField(label, floatValue);
if (setVarMethod == SetVarMethod.SetAsRandom && floatValue < 0f)
{
floatValue = 0f;
}
}
}
}
else if (setVarMethodIntBool == SetVarMethodIntBool.SetAsMecanimParameter)
{
ShowMecanimGUI();
}
}
else if (vars [variableNumber].type == VariableType.String)
{
setVarMethodString = (SetVarMethodString)EditorGUILayout.EnumPopup("New value is:", setVarMethodString);
label += "=";
if (setVarMethodString == SetVarMethodString.EnteredHere)
{
setParameterID = Action.ChooseParameterGUI(label, parameters, setParameterID, ParameterType.String);
if (setParameterID < 0)
{
stringValue = EditorGUILayout.TextField(label, stringValue);
}
}
else if (setVarMethodString == SetVarMethodString.SetAsMenuElementText)
{
menuName = EditorGUILayout.TextField("Menu name:", menuName);
elementName = EditorGUILayout.TextField("Element name:", elementName);
slotNumberParameterID = Action.ChooseParameterGUI("Slot # (optional):", parameters, slotNumberParameterID, ParameterType.Integer);
if (slotNumberParameterID < 0)
{
slotNumber = EditorGUILayout.IntField("Slot # (optional):", slotNumber);
}
}
}
AfterRunningOption();
}
else
{
EditorGUILayout.HelpBox("No variables exist!", MessageType.Info);
variableID = -1;
variableNumber = -1;
}
}
public Command(string name, Action <State> action)
{
Name = name;
Action = (state, param) => action(state);
Parameter = ParameterType.None;
}
/// <summary>
/// Adds a default parameter to the request. There are four types of parameters:
/// - GetOrPost: Either a QueryString value or encoded form value based on method
/// - HttpHeader: Adds the name/value pair to the HTTP request's Headers collection
/// - UrlSegment: Inserted into URL if there is a matching url token e.g. {AccountId}
/// - RequestBody: Used by AddBody() (not recommended to use directly)
/// Used on every request made by this client instance
/// </summary>
/// <param name="restClient">The IRestClient instance</param>
/// <param name="name">Name of the parameter</param>
/// <param name="value">Value of the parameter</param>
/// <param name="type">The type of parameter to add</param>
/// <returns>This request</returns>
public static IRestClient AddDefaultParameter(this IRestClient restClient, string name, object value,
ParameterType type)
=> restClient.AddDefaultParameter(new Parameter(name, value, type));
private static (string err, List <ParamInfo> @params) CheckMethodAssign(MethodInfo minfo, Nancy.Rest.Annotations.Atributes.Rest attribute)
{
List <ParamInfo> parms = new List <ParamInfo>();
MatchCollection collection = rpath.Matches(attribute.Route);
foreach (Match m in collection)
{
if (m.Success)
{
string value = m.Groups[1].Value;
bool optional = false;
string constraint = null;
int idx = value.LastIndexOf("?", StringComparison.InvariantCulture);
if (idx > 0)
{
value = value.Substring(0, idx);
optional = true;
}
idx = value.LastIndexOf(':');
if (idx >= 0)
{
constraint = value.Substring(idx + 1);
value = value.Substring(0, idx);
idx = constraint.LastIndexOf("(", StringComparison.InvariantCulture);
if (idx > 0)
{
constraint = constraint.Substring(0, idx);
}
}
ParamInfo info = new ParamInfo();
info.Name = value;
info.Optional = optional;
if (constraint != null)
{
ParameterType ptype = ParameterType.InstanceTypes.FirstOrDefault(a => a.Name == constraint);
if (ptype == null)
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has an unknown constraint '" + constraint + "'", null);
}
info.Constraint = ptype;
}
parms.Add(info);
}
}
List <ParameterInfo> infos = minfo.GetParameters().ToList();
foreach (ParamInfo p in parms)
{
ParameterInfo pinf = infos.FirstOrDefault(a => a.Name == p.Name);
if (pinf == null)
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has an unknown variable in the route path '" + p.Name + "'", null);
}
if (p.Optional && !pinf.ParameterType.IsNullable())
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' with variable '" + p.Name + "' is marked in the route path as nullable, but the method variable is not", null);
}
if (p.Constraint != null && !p.Constraint.Types.Contains(pinf.ParameterType))
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' with variable '" + p.Name + "' is constrained to type " + p.Constraint.BaseType + " but the method variable is not of the same type", null);
}
if (!pinf.ParameterType.IsRouteable())
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' the variable '" + p.Name + "' is not a value type and is the route path", null);
}
infos.Remove(pinf);
}
if (infos.Count > 0 && attribute.Verb == Verbs.Get)
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has post variables in a GET operation", null);
}
if (infos.Count > 1)
{
return("Method with Name: '" + minfo.Name + "' and Route: '" + attribute.Route + "' has more than one Body object", null);
}
return(null, parms);
}
public CommandParameter(string name, ParameterType type)
{
Name = name;
Type = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:GenericDbParameter" /> class.
/// </summary>
/// <param name="type">The type of the parameter.</param>
/// <param name="name">The name of the parameter.</param>
/// <param name="value">The value of the parameter.</param>
public Parameter(ParameterType type, string name, object value)
{
this.type = type;
this.name = name;
this.value = value;
}
public NotSupportedParameterException(ParameterType parameterType, string language)
: base(parameterType.GetDisplayName() + " not supported in " + language)
{
}
/// <summary>
/// Tries the get the ParameterType value for the given UnitType value.
/// </summary>
/// <param name="unitType">The unit type.</param>
/// <param name="parameterType">The resulting ParameterType value.</param>
/// <returns></returns>
public static bool TryGetParameterType(this UnitType unitType, out ParameterType parameterType)
{
return(parameterTypes.TryGetValue(unitType, out parameterType));
}
/// <summary>
/// Adds a <see cref="ParameterTypeRowViewModel"/>
/// </summary>
/// <param name="parameterType">
/// The associated <see cref="ParameterType"/> for which the row is to be added.
/// </param>
private void AddParameterTypeRowViewModel(ParameterType parameterType)
{
var row = new ParameterTypeRowViewModel(parameterType, this.Session, this);
this.ParameterTypes.Add(row);
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomParameter"/> class.
/// </summary>
/// <param name="name">The name of the parameter</param>
/// <param name="value">The value of the parameter. The caller is responsible for ensuring the value and type contains the correct capitalization and is formatted corectly when converted <see cref="ToString"/>.</param>
public CustomParameter(string name, object value)
{
Name = name;
Value = value;
ParameterType = ParameterType.SingleValue;
}
/// <inheritdoc/>
public bool Remove(ParameterType type, string name)
{
var key = new ParameterKey(type, name);
return(_dictionary.Remove(key));
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomParameter"/> class with a specified parameter type.
/// </summary>
/// <param name="name">The name of the parameter</param>
/// <param name="value">The value of the parameter. The caller is responsible for ensuring the value and type contains the correct capitalization and is formatted corectly when converted <see cref="ToString"/>.</param>
/// <param name="parameterType">How the <paramref name="value"/> should be formatted if it contains a string.</param>
public CustomParameter(string name, object value, ParameterType parameterType)
{
Name = name;
Value = value;
ParameterType = parameterType;
}
public Document settingParamenters(string eleName, string eleXPath, string elefName, Document Revit_Doc)
{
//MessageBox.Show(elefName);
//根据名称在工程文件中查找出对应族
FilteredElementCollector allElements = new FilteredElementCollector(Revit_Doc);
ElementClassFilter familyFilter = new ElementClassFilter(typeof(Family));
allElements = allElements.WherePasses(familyFilter);
var filterFamilyList = from f in allElements
where f.Name.ToString() == elefName
select f as Family;
//MessageBox.Show(filterFamilyList.ToList<Family>()[0].ToString());
//allElements = new FilteredElementCollector(Revit_Doc);
//ElementClassFilter familySymbolFilter = new ElementClassFilter(typeof(FamilySymbol));
//allElements = allElements.WherePasses(familySymbolFilter);
//var filterList = from f in allElements
// where f.Name.ToString() == eleName && (f as FamilySymbol).Family.ToString() == elefName
// select (f as FamilySymbol).Family ;
//Family filtedFamily = filterList.ToList<Family>().FirstOrDefault();
////if (filterList != null)
////{ MessageBox.Show(filterList.ToList<Family>()[0].ToString()); }
Family filtedFamily = filterFamilyList.ToList <Family>().FirstOrDefault();;
MessageBox.Show(filtedFamily.Name.ToString());
//---------------------------------------------------
//MessageBox.Show(eleName);
//if (filtedFamily == null)
//{ MessageBox.Show("filtedFamily is null!!"); }
//---------------------------------------------------
//
Document familyDoc = Revit_Doc.EditFamily(filtedFamily);
if (null != familyDoc && familyDoc.IsFamilyDocument == true)
{
DataTable xdte = new DataTable();
//读取xls文件
ExcelHelper ExcelHelper = new ExcelHelper();
DataTable xdt = ExcelHelper.Reading_Excel_Information(eleXPath);
//获取参数集
FamilyParameterSet rfadocParas = familyDoc.FamilyManager.Parameters;
List <string> rfadocParasListName = new List <string>();
foreach (FamilyParameter rfadocPara in rfadocParas)
{
rfadocParasListName.Add(rfadocPara.Definition.Name);
}
FamilyManager familyMgr = familyDoc.FamilyManager;
if (clearsymbol == true)
{
//清空族内所有类型 仅保留默认族类型
int typesizes = familyMgr.Types.Size;
if (familyMgr.Types.Size > 1 && familyMgr.Types.Size != 0)
{
for (int typenumber = 0; typenumber < typesizes - 1; typenumber++)
{
if (familyMgr.CurrentType != null)
{
Transaction DeleteType = new Transaction(familyDoc, "DeleteType");
DeleteType.Start();
familyMgr.DeleteCurrentType();
DeleteType.Commit();
}
}
}
}
if (clearpara == true)
{
//清空族内所有参数条目
foreach (FamilyParameter fp in familyMgr.Parameters)
{
if (fp.Definition.ParameterGroup == BuiltInParameterGroup.PG_ELECTRICAL)
{
Transaction RemoveParameter = new Transaction(familyDoc, "RemoveParameter");
RemoveParameter.Start();
familyMgr.RemoveParameter(fp);
RemoveParameter.Commit();
}
}
}
//开始添加
Transaction addParameter = new Transaction(familyDoc, "AddParameters");
addParameter.Start();
string paraname = null;
BuiltInParameterGroup paragroup = BuiltInParameterGroup.PG_ELECTRICAL;;
ParameterType paraType = ParameterType.Text;;
bool isInstance = false;
string paravalue = null;
List <string> distinctparanames = new List <string>();
//判断xls表中与原有rfa文件内重复的条目 放入distinctparanames列表
for (int i = 0; i < xdt.Rows.Count; i++)
{
foreach (FamilyParameter fp in familyMgr.Parameters)
{
if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString())
{
distinctparanames.Add(fp.Definition.Name);
MessageBox.Show(fp.Definition.Name);
}
}
}
//遍历xls添加属性条目
for (int i = 0; i < xdt.Rows.Count; i++)
{
//获取表中条目名称判断是否重复 重复则继续下一次循环
paraname = xdt.Rows[i]["paraname"].ToString();
foreach (string disstr in distinctparanames)
{
if (disstr == paraname)
{
continue;
}
}
//通过的条目名称
if (xdt.Rows[i]["paragroup"] == null)
{
paragroup = BuiltInParameterGroup.PG_ELECTRICAL;
}
else
{
#region 参数分组对照 用于RevitAPI2016A
switch (xdt.Rows[i]["paragroup"].ToString())
{
case "PG_RELEASES_MEMBER_FORCES": paragroup = BuiltInParameterGroup.PG_RELEASES_MEMBER_FORCES; break;
case "PG_SECONDARY_END": paragroup = BuiltInParameterGroup.PG_SECONDARY_END; break;
case "PG_PRIMARY_END": paragroup = BuiltInParameterGroup.PG_PRIMARY_END; break;
case "PG_MOMENTS": paragroup = BuiltInParameterGroup.PG_MOMENTS; break;
case "PG_FORCES": paragroup = BuiltInParameterGroup.PG_FORCES; break;
case "PG_FABRICATION_PRODUCT_DATA": paragroup = BuiltInParameterGroup.PG_GEOMETRY_POSITIONING; break;
case "PG_REFERENCE": paragroup = BuiltInParameterGroup.PG_REFERENCE; break;
case "PG_GEOMETRY_POSITIONING": paragroup = BuiltInParameterGroup.PG_GEOMETRY_POSITIONING; break;
case "PG_DIVISION_GEOMETRY": paragroup = BuiltInParameterGroup.PG_DIVISION_GEOMETRY; break;
case "PG_SEGMENTS_FITTINGS": paragroup = BuiltInParameterGroup.PG_SEGMENTS_FITTINGS; break;
case "PG_CONTINUOUSRAIL_END_TOP_EXTENSION": paragroup = BuiltInParameterGroup.PG_CONTINUOUSRAIL_END_TOP_EXTENSION; break;
case "PG_CONTINUOUSRAIL_BEGIN_BOTTOM_EXTENSION": paragroup = BuiltInParameterGroup.PG_CONTINUOUSRAIL_BEGIN_BOTTOM_EXTENSION; break;
case "PG_STAIRS_WINDERS": paragroup = BuiltInParameterGroup.PG_STAIRS_WINDERS; break;
case "PG_STAIRS_SUPPORTS": paragroup = BuiltInParameterGroup.PG_STAIRS_SUPPORTS; break;
case "PG_STAIRS_OPEN_END_CONNECTION": paragroup = BuiltInParameterGroup.PG_STAIRS_OPEN_END_CONNECTION; break;
case "PG_RAILING_SYSTEM_SECONDARY_FAMILY_HANDRAILS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SECONDARY_FAMILY_HANDRAILS; break;
case "PG_TERMINTATION": paragroup = BuiltInParameterGroup.PG_TERMINTATION; break;
case "PG_STAIRS_TREADS_RISERS": paragroup = BuiltInParameterGroup.PG_STAIRS_TREADS_RISERS; break;
case "PG_STAIRS_CALCULATOR_RULES": paragroup = BuiltInParameterGroup.PG_STAIRS_CALCULATOR_RULES; break;
case "PG_SPLIT_PROFILE_DIMENSIONS": paragroup = BuiltInParameterGroup.PG_SPLIT_PROFILE_DIMENSIONS; break;
case "PG_LENGTH": paragroup = BuiltInParameterGroup.PG_LENGTH; break;
case "PG_NODES": paragroup = BuiltInParameterGroup.PG_NODES; break;
case "PG_ANALYTICAL_PROPERTIES": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_PROPERTIES; break;
case "PG_ANALYTICAL_ALIGNMENT": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_ALIGNMENT; break;
case "PG_SYSTEMTYPE_RISEDROP": paragroup = BuiltInParameterGroup.PG_SYSTEMTYPE_RISEDROP; break;
case "PG_LINING": paragroup = BuiltInParameterGroup.PG_LINING; break;
case "PG_INSULATION": paragroup = BuiltInParameterGroup.PG_INSULATION; break;
case "PG_OVERALL_LEGEND": paragroup = BuiltInParameterGroup.PG_OVERALL_LEGEND; break;
case "PG_VISIBILITY": paragroup = BuiltInParameterGroup.PG_VISIBILITY; break;
case "PG_SUPPORT": paragroup = BuiltInParameterGroup.PG_SUPPORT; break;
case "PG_RAILING_SYSTEM_SEGMENT_V_GRID": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_V_GRID; break;
case "PG_RAILING_SYSTEM_SEGMENT_U_GRID": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_U_GRID; break;
case "PG_RAILING_SYSTEM_SEGMENT_POSTS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_POSTS; break;
case "PG_RAILING_SYSTEM_SEGMENT_PATTERN_REMAINDER": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_PATTERN_REMAINDER; break;
case "PG_RAILING_SYSTEM_SEGMENT_PATTERN_REPEAT": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_SEGMENT_PATTERN_REPEAT; break;
case "PG_RAILING_SYSTEM_FAMILY_SEGMENT_PATTERN": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_SEGMENT_PATTERN; break;
case "PG_RAILING_SYSTEM_FAMILY_HANDRAILS": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_HANDRAILS; break;
case "PG_RAILING_SYSTEM_FAMILY_TOP_RAIL": paragroup = BuiltInParameterGroup.PG_RAILING_SYSTEM_FAMILY_TOP_RAIL; break;
case "PG_CONCEPTUAL_ENERGY_DATA_BUILDING_SERVICES": paragroup = BuiltInParameterGroup.PG_CONCEPTUAL_ENERGY_DATA_BUILDING_SERVICES; break;
case "PG_DATA": paragroup = BuiltInParameterGroup.PG_DATA; break;
case "PG_ELECTRICAL_CIRCUITING": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_CIRCUITING; break;
case "PG_GENERAL": paragroup = BuiltInParameterGroup.PG_GENERAL; break;
case "PG_FLEXIBLE": paragroup = BuiltInParameterGroup.PG_FLEXIBLE; break;
case "PG_ENERGY_ANALYSIS_CONCEPTUAL_MODEL": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_CONCEPTUAL_MODEL; break;
case "PG_ENERGY_ANALYSIS_DETAILED_MODEL": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_DETAILED_MODEL; break;
case "PG_ENERGY_ANALYSIS_DETAILED_AND_CONCEPTUAL_MODELS": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS_DETAILED_AND_CONCEPTUAL_MODELS; break;
case "PG_FITTING": paragroup = BuiltInParameterGroup.PG_FITTING; break;
case "PG_CONCEPTUAL_ENERGY_DATA": paragroup = BuiltInParameterGroup.PG_CONCEPTUAL_ENERGY_DATA; break;
case "PG_AREA": paragroup = BuiltInParameterGroup.PG_AREA; break;
case "PG_ADSK_MODEL_PROPERTIES": paragroup = BuiltInParameterGroup.PG_ADSK_MODEL_PROPERTIES; break;
case "PG_CURTAIN_GRID_V": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_V; break;
case "PG_CURTAIN_GRID_U": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_U; break;
case "PG_DISPLAY": paragroup = BuiltInParameterGroup.PG_DISPLAY; break;
case "PG_ANALYSIS_RESULTS": paragroup = BuiltInParameterGroup.PG_ANALYSIS_RESULTS; break;
case "PG_SLAB_SHAPE_EDIT": paragroup = BuiltInParameterGroup.PG_SLAB_SHAPE_EDIT; break;
case "PG_LIGHT_PHOTOMETRICS": paragroup = BuiltInParameterGroup.PG_LIGHT_PHOTOMETRICS; break;
case "PG_PATTERN_APPLICATION": paragroup = BuiltInParameterGroup.PG_PATTERN_APPLICATION; break;
case "PG_GREEN_BUILDING": paragroup = BuiltInParameterGroup.PG_GREEN_BUILDING; break;
case "PG_PROFILE_2": paragroup = BuiltInParameterGroup.PG_PROFILE_2; break;
case "PG_PROFILE_1": paragroup = BuiltInParameterGroup.PG_PROFILE_1; break;
case "PG_PROFILE": paragroup = BuiltInParameterGroup.PG_PROFILE; break;
case "PG_TRUSS_FAMILY_BOTTOM_CHORD": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_BOTTOM_CHORD; break;
case "PG_TRUSS_FAMILY_TOP_CHORD": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_TOP_CHORD; break;
case "PG_TRUSS_FAMILY_DIAG_WEB": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_DIAG_WEB; break;
case "PG_TRUSS_FAMILY_VERT_WEB": paragroup = BuiltInParameterGroup.PG_TRUSS_FAMILY_VERT_WEB; break;
case "PG_TITLE": paragroup = BuiltInParameterGroup.PG_TITLE; break;
case "PG_FIRE_PROTECTION": paragroup = BuiltInParameterGroup.PG_FIRE_PROTECTION; break;
case "PG_ROTATION_ABOUT": paragroup = BuiltInParameterGroup.PG_ROTATION_ABOUT; break;
case "PG_TRANSLATION_IN": paragroup = BuiltInParameterGroup.PG_TRANSLATION_IN; break;
case "PG_ANALYTICAL_MODEL": paragroup = BuiltInParameterGroup.PG_ANALYTICAL_MODEL; break;
case "PG_REBAR_ARRAY": paragroup = BuiltInParameterGroup.PG_REBAR_ARRAY; break;
case "PG_REBAR_SYSTEM_LAYERS": paragroup = BuiltInParameterGroup.PG_REBAR_SYSTEM_LAYERS; break;
case "PG_CURTAIN_GRID": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID; break;
case "PG_CURTAIN_MULLION_2": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_2; break;
case "PG_CURTAIN_MULLION_HORIZ": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_HORIZ; break;
case "PG_CURTAIN_MULLION_1": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_1; break;
case "PG_CURTAIN_MULLION_VERT": paragroup = BuiltInParameterGroup.PG_CURTAIN_MULLION_VERT; break;
case "PG_CURTAIN_GRID_2": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_2; break;
case "PG_CURTAIN_GRID_HORIZ": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_HORIZ; break;
case "PG_CURTAIN_GRID_1": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_1; break;
case "PG_CURTAIN_GRID_VERT": paragroup = BuiltInParameterGroup.PG_CURTAIN_GRID_VERT; break;
case "PG_IFC": paragroup = BuiltInParameterGroup.PG_IFC; break;
case "PG_AELECTRICAL": paragroup = BuiltInParameterGroup.PG_AELECTRICAL; break;
case "PG_ENERGY_ANALYSIS": paragroup = BuiltInParameterGroup.PG_ENERGY_ANALYSIS; break;
case "PG_STRUCTURAL_ANALYSIS": paragroup = BuiltInParameterGroup.PG_STRUCTURAL_ANALYSIS; break;
case "PG_MECHANICAL_AIRFLOW": paragroup = BuiltInParameterGroup.PG_MECHANICAL_AIRFLOW; break;
case "PG_MECHANICAL_LOADS": paragroup = BuiltInParameterGroup.PG_MECHANICAL_LOADS; break;
case "PG_ELECTRICAL_LOADS": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_LOADS; break;
case "PG_ELECTRICAL_LIGHTING": paragroup = BuiltInParameterGroup.PG_ELECTRICAL_LIGHTING; break;
case "PG_TEXT": paragroup = BuiltInParameterGroup.PG_TEXT; break;
case "PG_VIEW_CAMERA": paragroup = BuiltInParameterGroup.PG_VIEW_CAMERA; break;
case "PG_VIEW_EXTENTS": paragroup = BuiltInParameterGroup.PG_VIEW_EXTENTS; break;
case "PG_PATTERN": paragroup = BuiltInParameterGroup.PG_PATTERN; break;
case "PG_CONSTRAINTS": paragroup = BuiltInParameterGroup.PG_CONSTRAINTS; break;
case "PG_PHASING": paragroup = BuiltInParameterGroup.PG_PHASING; break;
case "PG_MECHANICAL": paragroup = BuiltInParameterGroup.PG_MECHANICAL; break;
case "PG_STRUCTURAL": paragroup = BuiltInParameterGroup.PG_STRUCTURAL; break;
case "PG_PLUMBING": paragroup = BuiltInParameterGroup.PG_PLUMBING; break;
case "PG_ELECTRICAL": paragroup = BuiltInParameterGroup.PG_ELECTRICAL; break;
case "PG_STAIR_STRINGERS": paragroup = BuiltInParameterGroup.PG_STAIR_STRINGERS; break;
case "PG_STAIR_RISERS": paragroup = BuiltInParameterGroup.PG_STAIR_RISERS; break;
case "PG_STAIR_TREADS": paragroup = BuiltInParameterGroup.PG_STAIR_TREADS; break;
case "PG_MATERIALS": paragroup = BuiltInParameterGroup.PG_MATERIALS; break;
case "PG_GRAPHICS": paragroup = BuiltInParameterGroup.PG_GRAPHICS; break;
case "PG_CONSTRUCTION": paragroup = BuiltInParameterGroup.PG_CONSTRUCTION; break;
case "PG_GEOMETRY": paragroup = BuiltInParameterGroup.PG_GEOMETRY; break;
case "PG_IDENTITY_DATA": paragroup = BuiltInParameterGroup.PG_IDENTITY_DATA; break;
case "INVALID": paragroup = BuiltInParameterGroup.INVALID; break;
}
#endregion
}
if (xdt.Rows[i]["paratype"] == null)
{
paraType = ParameterType.Text;
}
else
{
#region 参数类型对照 用于RevitAPI2016
switch (xdt.Rows[i]["paratype"].ToString())
{
case "Text": paraType = ParameterType.Text; break;
//case "Invalid": paraType = ParameterType.Invalid; break;
//case "Integer": paraType = ParameterType.Integer; break;
//case "Number": paraType = ParameterType.Number; break;
//case "Length": paraType = ParameterType.Length; break;
//case "Volume": paraType = ParameterType.Volume; break;
//case "Area": paraType = ParameterType.Area; break;
//case "Angle": paraType = ParameterType.Angle; break;
//case "URL": paraType = ParameterType.URL; break;
//case "Material": paraType = ParameterType.Material; break;
//case "YesNo": paraType = ParameterType.YesNo; break;
//case "Force": paraType = ParameterType.Force; break;
//case "NumberOfPoles": paraType = ParameterType.NumberOfPoles; break;
//case "AreaForce": paraType = ParameterType.AreaForce; break;
//case "Moment": paraType = ParameterType.Moment; break;
//case "FixtureUnit": paraType = ParameterType.FixtureUnit; break;
//case "FamilyType": paraType = ParameterType.FamilyType; break;
//case "LoadClassification": paraType = ParameterType.LoadClassification; break;
//case "Image": paraType = ParameterType.Image; break;
//case "HVACDensity": paraType = ParameterType.HVACDensity; break;
//case "HVACEnergy": paraType = ParameterType.HVACEnergy; break;
//case "HVACFriction": paraType = ParameterType.HVACFriction; break;
//case "HVACPower": paraType = ParameterType.HVACPower; break;
//case "HVACPowerDensity": paraType = ParameterType.HVACPowerDensity; break;
//case "HVACPressure": paraType = ParameterType.HVACPressure; break;
//case "HVACTemperature": paraType = ParameterType.HVACTemperature; break;
//case "HVACVelocity": paraType = ParameterType.HVACVelocity; break;
//case "HVACAirflow": paraType = ParameterType.HVACAirflow; break;
//case "HVACDuctSize": paraType = ParameterType.HVACDuctSize; break;
//case "HVACCrossSection": paraType = ParameterType.HVACCrossSection; break;
//case "HVACHeatGain": paraType = ParameterType.HVACHeatGain; break;
//case "ElectricalCurrent": paraType = ParameterType.ElectricalCurrent; break;
//case "ElectricalPotential": paraType = ParameterType.ElectricalPotential; break;
//case "ElectricalFrequency": paraType = ParameterType.ElectricalFrequency; break;
//case "ElectricalIlluminance": paraType = ParameterType.ElectricalIlluminance; break;
//case "ElectricalLuminousFlux": paraType = ParameterType.ElectricalLuminousFlux; break;
//case "ElectricalPower": paraType = ParameterType.ElectricalPower; break;
//case "HVACRoughness": paraType = ParameterType.HVACRoughness; break;
//case "ElectricalApparentPower": paraType = ParameterType.ElectricalApparentPower; break;
//case "ElectricalPowerDensity": paraType = ParameterType.ElectricalPowerDensity; break;
//case "PipingDensity": paraType = ParameterType.PipingDensity; break;
//case "PipingFlow": paraType = ParameterType.PipingFlow; break;
//case "PipingFriction": paraType = ParameterType.PipingFriction; break;
//case "PipingPressure": paraType = ParameterType.PipingPressure; break;
//case "PipingTemperature": paraType = ParameterType.PipingTemperature; break;
//case "PipingVelocity": paraType = ParameterType.PipingVelocity; break;
//case "PipingViscosity": paraType = ParameterType.PipingViscosity; break;
//case "PipeSize": paraType = ParameterType.PipeSize; break;
//case "PipingRoughness": paraType = ParameterType.PipingRoughness; break;
//case "Stress": paraType = ParameterType.Stress; break;
//case "UnitWeight": paraType = ParameterType.UnitWeight; break;
//case "ThermalExpansion": paraType = ParameterType.ThermalExpansion; break;
//case "LinearMoment": paraType = ParameterType.LinearMoment; break;
//case "ForcePerLength": paraType = ParameterType.ForcePerLength; break;
//case "ForceLengthPerAngle": paraType = ParameterType.ForceLengthPerAngle; break;
//case "LinearForcePerLength": paraType = ParameterType.LinearForcePerLength; break;
//case "LinearForceLengthPerAngle": paraType = ParameterType.LinearForceLengthPerAngle; break;
//case "AreaForcePerLength": paraType = ParameterType.AreaForcePerLength; break;
//case "PipingVolume": paraType = ParameterType.PipingVolume; break;
//case "HVACViscosity": paraType = ParameterType.HVACViscosity; break;
//case "HVACCoefficientOfHeatTransfer": paraType = ParameterType.HVACCoefficientOfHeatTransfer; break;
//case "HVACAirflowDensity": paraType = ParameterType.HVACAirflowDensity; break;
//case "Slope": paraType = ParameterType.Slope; break;
//case "HVACCoolingLoad": paraType = ParameterType.HVACCoolingLoad; break;
//case "HVACCoolingLoadDividedByArea": paraType = ParameterType.HVACCoolingLoadDividedByArea; break;
//case "HVACCoolingLoadDividedByVolume": paraType = ParameterType.HVACCoolingLoadDividedByVolume; break;
//case "HVACHeatingLoad": paraType = ParameterType.HVACHeatingLoad; break;
//case "HVACHeatingLoadDividedByArea": paraType = ParameterType.HVACHeatingLoadDividedByArea; break;
//case "Weight": paraType = ParameterType.Weight; break;
}
#endregion
}
if (xdt.Rows[i]["paratag"].ToString() == "是")
{
isInstance = true;
}
else if (xdt.Rows[i]["paratag"].ToString() == "否")
{
isInstance = false;
}
if (xdt.Rows[i]["paravalue"].ToString() == null)
{
paravalue = "NA";
}
else
{
paravalue = xdt.Rows[i]["paravalue"].ToString();
}
//bool checkDistinct = false;
//foreach (FamilyParameter fp in familyMgr.Parameters)
//{
// if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString())
// {
// checkDistinct = true;
// }
//}
//if (checkDistinct == true)
//{
// continue;
//}
//else
//{
try
{
FamilyParameter newParameter = familyMgr.AddParameter(paraname, paragroup, paraType, isInstance);
}
catch (Exception efec)
{
MessageBox.Show(efec.ToString());
continue;
}
//创建族参数(每个参数两秒)
//familyMgr.Set(newParameter, paravalue);
//}
}
try
{
for (int i = 0; i < xdt.Rows.Count; i++)
{
paraname = xdt.Rows[i]["paraname"].ToString();
foreach (FamilyParameter fp in familyMgr.Parameters)
{
StorageType fst = fp.StorageType;
if (fp.Definition.Name == xdt.Rows[i]["paraname"].ToString())
{
if (xdt.Rows[i]["paravalue"].ToString() == null && fst.ToString() == "String")
{
paravalue = "NA";
familyMgr.Set(fp, paravalue);
}
else
{
//paravalue = xdt.Rows[i]["paravalue"].ToString();
#region
switch (fst.ToString())
{
case "Integer": int paravint = Convert.ToInt32(xdt.Rows[i]["paravalue"].ToString()); familyMgr.Set(fp, paravint);; break;
case "Double": double paravdouble = Convert.ToDouble(xdt.Rows[i]["paravalue"].ToString()); familyMgr.Set(fp, paravdouble); break;
case "String": string paravstring = xdt.Rows[i]["paravalue"].ToString(); familyMgr.Set(fp, paravstring); break;
case "ElementId": ElementId paravid = new ElementId(Convert.ToInt32(xdt.Rows[i]["paravalue"].ToString())); familyMgr.Set(fp, paravid); break;
case "None": break;
}
#endregion
}
}
}
}
}
catch (Exception eeef)
{ /*MessageBox.Show(eeef.ToString());*/ }
SaveOptions opt = new SaveOptions();
addParameter.Commit();
}
return(familyDoc);
}
/// <summary>
/// Add Parameter
/// </summary>
/// <param name="name">Parameter Name</param>
/// <param name="label">Parameter Label</param>
/// <param name="maxLength">Maximum Length</param>
/// <param name="required">Set if value in the parameter required when added/apdated</param>
/// <param name="keyfield">Mark field as primary key, unique and required</param>
/// <param name="parType">Parameter type (integer, string, boolean etc.)</param>
public void AddParameter(string name, string label, int maxLength, bool required, bool keyfield, ParameterType parType)
{
if (_params == null)
{
_params = new List <ExtensionParameter>();
}
ExtensionParameter par = new ExtensionParameter(name);
par.Label = label;
par.MaxLength = maxLength;
par.Required = required;
par.KeyField = keyfield;
par.ParamType = parType;
_params.Add(par);
}
/// <summary>
/// Initializes a new instance of the <see cref="Parameter"/> class.
/// Constructor
/// </summary>
/// <param name="parameterName">
/// Name of parameter
/// </param>
/// <param name="parameterState">
/// State of parameter
/// </param>
/// <param name="parameterValue">
/// Value of parameter
/// </param>
/// <param name="parameterUnit">
/// Unit of parameter
/// </param>
/// <param name="parameterType">
/// Type of parameter
/// </param>
public Parameter(string parameterName, ParameterState parameterState, string parameterValue, string parameterUnit, ParameterType parameterType)
{
this.ParameterName = this.GetParameterName(parameterName);
this.ParameterState = parameterState;
this.ParameterValue = parameterValue;
this.ParameterUnit = parameterUnit;
this.ParameterType = parameterType;
}
private int ShowVarGUI(List <GVar> vars, List <ActionParameter> parameters, ParameterType parameterType, int variableID, int parameterID, bool isNew)
{
// Create a string List of the field's names (for the PopUp box)
List <string> labelList = new List <string>();
int i = 0;
int variableNumber = -1;
if (vars.Count > 0)
{
foreach (GVar _var in vars)
{
labelList.Add(_var.label);
// If a GlobalVar variable has been removed, make sure selected variable is still valid
if (_var.id == variableID)
{
variableNumber = i;
}
i++;
}
if (variableNumber == -1 && (parameters == null || parameters.Count == 0 || parameterID == -1))
{
// Wasn't found (variable was deleted?), so revert to zero
Debug.LogWarning("Previously chosen variable no longer exists!");
variableNumber = 0;
variableID = 0;
}
string label = "'From' variable:";
if (isNew)
{
label = "'To' variable:";
}
parameterID = Action.ChooseParameterGUI(label, parameters, parameterID, parameterType);
if (parameterID >= 0)
{
//variableNumber = 0;
variableNumber = Mathf.Min(variableNumber, vars.Count - 1);
variableID = -1;
}
else
{
variableNumber = EditorGUILayout.Popup(label, variableNumber, labelList.ToArray());
variableID = vars [variableNumber].id;
}
}
else
{
EditorGUILayout.HelpBox("No variables exist!", MessageType.Info);
variableID = -1;
variableNumber = -1;
}
if (isNew)
{
newParameterID = parameterID;
if (variableNumber >= 0)
{
newVarType = vars[variableNumber].type;
}
}
else
{
oldParameterID = parameterID;
if (variableNumber >= 0)
{
oldVarType = vars[variableNumber].type;
}
}
return(variableID);
}
public ParameterDefinition(String name)
{
_parameterType = ParameterType.Single;
_name = name;
}
public ParameterParam(DB.Parameter p) : this()
{
ParameterName = p.Definition.Name;
ParameterType = p.Definition.ParameterType;
ParameterGroup = p.Definition.ParameterGroup;
ParameterBinding = p.Element is DB.ElementType ? DBX.ParameterBinding.Type : DBX.ParameterBinding.Instance;
if (p.IsShared)
{
ParameterClass = DBX.ParameterClass.Shared;
ParameterSharedGUID = p.GUID;
}
else if (p.Id.TryGetBuiltInParameter(out var parameterBuiltInId))
{
ParameterClass = DBX.ParameterClass.BuiltIn;
ParameterBuiltInId = parameterBuiltInId;
}
else if (p.Element.Document.GetElement(p.Id) is DB.ParameterElement paramElement)
{
if (paramElement is DB.GlobalParameter)
{
ParameterClass = DBX.ParameterClass.Global;
}
else
{
switch (paramElement.get_Parameter(DB.BuiltInParameter.ELEM_DELETABLE_IN_FAMILY).AsInteger())
{
case 0: ParameterClass = DBX.ParameterClass.Family; break;
case 1: ParameterClass = DBX.ParameterClass.Project; break;
}
}
}
try { Name = $"{DB.LabelUtils.GetLabelFor(ParameterGroup)} : {ParameterName}"; }
catch (Autodesk.Revit.Exceptions.InvalidOperationException) { Name = ParameterName; }
NickName = Name;
MutableNickName = false;
try { Description = p.StorageType == DB.StorageType.ElementId ? "ElementId" : DB.LabelUtils.GetLabelFor(p.Definition.ParameterType); }
catch (Autodesk.Revit.Exceptions.InvalidOperationException)
{ Description = p.Definition.UnitType == DB.UnitType.UT_Number ? "Enumerate" : DB.LabelUtils.GetLabelFor(p.Definition.UnitType); }
if (string.IsNullOrEmpty(Description))
{
Description = ParameterType.ToString();
}
if (ParameterSharedGUID.HasValue)
{
Description = $"Shared parameter {ParameterSharedGUID.Value:B}\n{Description}";
}
else if (ParameterBuiltInId != DB.BuiltInParameter.INVALID)
{
Description = $"BuiltIn parameter {ParameterBuiltInId.ToStringGeneric()}\n{Description}";
}
else if (ParameterBinding != DBX.ParameterBinding.Unknown)
{
Description = $"{ParameterClass} parameter ({ParameterBinding})\n{Description}";
}
else
{
Description = $"{ParameterClass} parameter\n{Description}";
}
}
public void SelectByParameter(RhinoDoc doc, ParametersSelectorForm form)
{
Rhino.DocObjects.Tables.ObjectTable rhobjs = doc.Objects;
string paramName = form.GetParamName();
if (paramName != "")
{
// List to store all the objects that match.
List <Rhino.DocObjects.RhinoObject> matched = new List <Rhino.DocObjects.RhinoObject>();
string paramValue = form.GetParamValue();
// TODO Filter also by type of obj?
// rhobjs = filter( lambda x: va.IsColumn(x.Id) , Rhino.RhinoDoc.ActiveDoc.Objects)
if (paramValue != "") // Search by name and value.
{
// If the input param value can be converted to num then compare as num and as text.
if (Double.TryParse(paramValue, out double numValue))
{
int comparison = form.GetComparisonType();
if (comparison == 0) // Equality comparison.
{
foreach (Rhino.DocObjects.RhinoObject o in rhobjs)
{
Guid paramId = GetObjectParameterId(paramName, o.Id, true);
if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null)
{
ParameterType t = GetParameterType(paramId);
// First type number comparison.
if (IsDirectNumericalType(t) && numValue == Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type angle comparison.
else if (t == ParameterType.Angle && DegreeToRadian(numValue) == Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type percentage comparison.
else if (t == ParameterType.Percentage && (numValue / 100.0) == Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// If it is a number but as a string.
else if (GetParameterValue(paramId, o.Id) != null && paramValue == GetParameterValue(paramId, o.Id).ToString())
{
matched.Add(o);
}
}
}
}
else if (comparison == 1) // Less than comparison.
{
foreach (Rhino.DocObjects.RhinoObject o in rhobjs)
{
Guid paramId = GetObjectParameterId(paramName, o.Id, true);
if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null)
{
ParameterType t = GetParameterType(paramId);
// First type number comparison.
if (IsDirectNumericalType(t) && numValue > Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type angle comparison.
else if (t == ParameterType.Angle && DegreeToRadian(numValue) > Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type percentage comparison.
else if (t == ParameterType.Percentage && (numValue / 100.0) > Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
}
}
}
else if (comparison == 2) // Greater than comparison.
{
foreach (Rhino.DocObjects.RhinoObject o in rhobjs)
{
Guid paramId = GetObjectParameterId(paramName, o.Id, true);
if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null)
{
ParameterType t = GetParameterType(paramId);
// First type number comparison.
if (IsDirectNumericalType(t) && numValue < Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type angle comparison.
else if (t == ParameterType.Angle && DegreeToRadian(numValue) < Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
// Type percentage comparison.
else if (t == ParameterType.Percentage && (numValue / 100.0) < Convert.ToDouble(GetParameterValue(paramId, o.Id)))
{
matched.Add(o);
}
}
}
}
}
else // If it cannot be converted to num then only compare as bool and text.
{
int comparison = form.GetComparisonType();
if (comparison == 0) // Equality comparison.
{
foreach (Rhino.DocObjects.RhinoObject o in rhobjs)
{
Guid paramId = GetObjectParameterId(paramName, o.Id, true);
if (paramId != Guid.Empty && GetParameterValue(paramId, o.Id) != null)
{
ParameterType t = GetParameterType(paramId);
if (t == ParameterType.Boolean)
{
if ((string.Equals(paramValue, "yes", StringComparison.OrdinalIgnoreCase) ||
string.Equals(paramValue, "true", StringComparison.OrdinalIgnoreCase)) &&
"True" == GetParameterValue(paramId, o.Id).ToString())
{
matched.Add(o);
}
else if ((string.Equals(paramValue, "no", StringComparison.OrdinalIgnoreCase) ||
string.Equals(paramValue, "false", StringComparison.OrdinalIgnoreCase)) &&
"False" == GetParameterValue(paramId, o.Id).ToString())
{
matched.Add(o);
}
}
else if (paramValue == GetParameterValue(paramId, o.Id).ToString())
{
matched.Add(o);
}
}
}
}
}
}
else // Search only by parameter name.
{
foreach (Rhino.DocObjects.RhinoObject o in rhobjs)
{
Guid paramId = GetObjectParameterId(paramName, o.Id, true);
if (paramId != Guid.Empty)
{
matched.Add(o);
}
}
}
if (form.GetAddToSelection() == null || form.GetAddToSelection() == false)
{
rhobjs.UnselectAll();
}
// Select all the ones that matched.
if (matched.Count > 0)
{
foreach (Rhino.DocObjects.RhinoObject o in matched)
{
o.Select(true);
}
if (matched.Count == 1)
{
RhinoApp.WriteLine("1 object was selected.");
}
else
{
RhinoApp.WriteLine("{0} objects were selected.", matched.Count);
}
}
else
{
RhinoApp.WriteLine("No objects were found.");
}
}
}
/// <summary>
/// Parameterizes this <see cref="ShopifyOrderFilterOptions"/> class, with special handling for <see cref="Ids"/>.
/// </summary>
/// <param name="propName">The name of the property. Will match the property's <see cref="JsonPropertyAttribute"/> name —
/// rather than the real property name — where applicable. Use <paramref name="property"/>.Name to get the real name.</param>
/// <param name="value">The property's value.</param>
/// <param name="property">The property itself.</param>
/// <param name="type">The type of parameter to create.</param>
/// <returns>The new parameter.</returns>
public override Parameter ToSingleParameter(string propName, object value, PropertyInfo property, ParameterType type)
{
if (propName == "ids" || propName == "Ids")
{
//RestSharp does not automatically convert arrays into querystring params.
var param = new Parameter()
{
Name = propName,
Type = type,
Value = string.Join(",", value as IEnumerable <long>)
};
return(param);
}
return(base.ToSingleParameter(propName, value, property, type));
}
public ParameterDefinition(String name, String[] possibleValues) : this(name)
{
_parameterType = ParameterType.Enum;
_possibleValues = possibleValues;
}
