public IEnumerable <Attribute> GetMetaAttributes(AttributeTypeEnum type)
{
var atts = from att in this.Attributes
where type.ToString() == att.AttributeType
let displayOrder =
(from si in att.SchemaInfos from sd in si.SchemaDatas where sd.Active select sd.DisplayOrder)
.FirstOrDefault()
orderby displayOrder, att.AttributeName
select att;
return(atts.ToList());
}
/// <summary>
/// Method that creates an AF Attribute on an AF Element
/// </summary>
/// <param name="element">AFElement object</param>
/// <param name="type">Type of attribute to create</param>
/// <param name="name">name of the new attribute that will be created</param>
/// <param name="value">Depending on the type of attribute created, the value can be either a scalar value or the ConfigString Value</param>
public void CreateAttribute(AFElement element, AttributeTypeEnum type, string name, string value)
{
var piSystem = element.PISystem;
var attribute = element.Attributes.Add(name);
Logger.InfoFormat("Creating attribute {0}", (name));
switch (type)
{
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute1 -v 10 -t AttDouble
case AttributeTypeEnum.AttDouble:
attribute.Type = typeof(double);
attribute.SetValue(new AFValue(double.Parse(value)));
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v \\tst-srv\sinusoid -t AttPIPoint
case AttributeTypeEnum.AttPIPoint:
attribute.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(piSystem);
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "SELECT Name FROM Info WHERE Version = 1.5" -t AttTableLookup
case AttributeTypeEnum.AttTableLookup:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["Table Lookup"];
attribute.Type = typeof(string); // if a specific type is needed, you'll need to pass it and set it here.
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "\\optimus\CDT158|sinusoid" -t AttPIPointArray
case AttributeTypeEnum.AttPIPointArray:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["PI Point Array"];
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "B=double;[B*10]" -t AttFormula
case AttributeTypeEnum.AttFormula:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["Formula"];
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "Hello ;World" -t AttStringBuilder
case AttributeTypeEnum.AttStringBuilder:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["String Builder"];
attribute.ConfigString = value;
break;
}
Logger.Info("Checking in the changes");
element.CheckIn();
Logger.Info("Attibute Created");
}
public static dynamic GetTSObject(AttributeTypeEnum dynEnum)
{
var tsType = TSActivator.CreateInstance("Tekla.Structures.Model.Collaboration.ReferenceModelObjectAttribute.AttributeTypeEnum").GetType();
switch (dynEnum)
{
case AttributeTypeEnum.ATTRIBUTETYPE_INVALID:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_INVALID"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CSHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CSHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CIRCLEHOLLOWPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CIRCLEHOLLOWPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CIRCLEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_CIRCLEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ELLIPSEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ELLIPSEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ISHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ISHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_LSHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_LSHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_RECTANGLEHOLLOWPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_RECTANGLEHOLLOWPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_RECTANGLEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_RECTANGLEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_TSHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_TSHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_USHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_USHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ZSHAPEPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_IFC2X3_PARAMETRICOBJECT_ZSHAPEPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_PARAMETRICOBJECT_CUSTOMPROFILE:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_PARAMETRICOBJECT_CUSTOMPROFILE"));
case AttributeTypeEnum.ATTRIBUTETYPE_PARAMETRICOBJECT_OBB:
return(System.Enum.Parse(tsType, "ATTRIBUTETYPE_PARAMETRICOBJECT_OBB"));
default:
throw new DynamicAPIException(dynEnum.ToString() + "- enum value is not implemented");
}
}
public bool IsValidAttribute(string attrkey, string attrValue, out AttributeTypeEnum attrType)
{
attrType = AttributeType.GetType(attrValue);
if (typeStore.ContainsKey(attrkey))
{
return(typeStore[attrkey] == attrType);
}
typeStore.Add(attrkey, attrType);
return(true);
}
/// <summary>
/// Converts a AttributeTypeEnum value to a corresponding string value
/// </summary>
/// <param name="enumValue">The AttributeTypeEnum value to convert</param>
/// <returns>The representative string value</returns>
public static string ToValue(AttributeTypeEnum enumValue)
{
switch (enumValue)
{
//only valid enum elements can be used
//this is necessary to avoid errors
case AttributeTypeEnum.CLIENT:
case AttributeTypeEnum.INVOICE:
case AttributeTypeEnum.PAYMENT:
return(stringValues[(int)enumValue]);
//an invalid enum value was requested
default:
return(null);
}
}
public string GetAttributeByByCssSelector(string selector, AttributeTypeEnum type)
{
IWebElement element = GetElementByCssSelector(selector);
switch (type)
{
case AttributeTypeEnum.ImagePath:
return(GetElementByAttribute(element, "src"));
case AttributeTypeEnum.Link:
return(GetElementByAttribute(element, "href"));
case AttributeTypeEnum.Text:
default:
return(element?.Text);
}
}
/// <summary>
/// Get Attribute for specified Typ
/// </summary>
/// <returns><see cref="Attribute{ValueType}"/></returns>
public static IAttribute CreateTypedAttribute(string name, AttributeTypeEnum type, List <IValue> values = null)
{
var typeName = type.ToString();
var result = ((Func <IAttribute>)(() => {
switch (type)
{
case AttributeTypeEnum.Boolean:
return(new Attribute <bool?>(name, typeName));
case AttributeTypeEnum.DateTime:
return(new Attribute <DateTime?>(name, typeName));
case AttributeTypeEnum.Number:
return(new Attribute <decimal?>(name, typeName));
case AttributeTypeEnum.Entity:
return(new Attribute <EntityRelationship>(name, typeName)
{
Values = new List <IValue> {
Value.NullRelationship
}
});
// ReSharper disable RedundantCaseLabel
case AttributeTypeEnum.String:
case AttributeTypeEnum.Hyperlink:
case AttributeTypeEnum.Custom:
case AttributeTypeEnum.Undefined:
case AttributeTypeEnum.Empty:
// ReSharper restore RedundantCaseLabel
default:
return(new Attribute <string>(name, typeName));
}
}))();
if (values != null)
{
result.Values = values;
}
return(result);
}
/// <summary>
/// Method that creates an AF Attribute on an AF Element
/// </summary>
/// <param name="element">AFElement object</param>
/// <param name="type">Type of attribute to create</param>
/// <param name="name">name of the new attribute that will be created</param>
/// <param name="value">Depending on the type of attribute created, the value can be either a scalar value or the ConfigString Value</param>
public void CreateAttribute(AFElement element, AttributeTypeEnum type, string name, string value)
{
var piSystem = element.PISystem;
var attribute = element.Attributes.Add(name);
Logger.InfoFormat("Creating attribute {0}", (name));
switch (type)
{
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute1 -v 10 -t AttDouble
case AttributeTypeEnum.AttDouble:
attribute.Type = typeof(double);
attribute.SetValue(new AFValue(double.Parse(value)));
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v \\tst-srv\sinusoid -t AttPIPoint
case AttributeTypeEnum.AttPIPoint:
attribute.DataReferencePlugIn = AFDataReference.GetPIPointDataReference(piSystem);
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "SELECT Name FROM Info WHERE Version = 1.5" -t AttTableLookup
case AttributeTypeEnum.AttTableLookup:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["Table Lookup"];
attribute.Type = typeof (string); // if a specific type is needed, you'll need to pass it and set it here.
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "\\optimus\CDT158|sinusoid" -t AttPIPointArray
case AttributeTypeEnum.AttPIPointArray:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["PI Point Array"];
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "B=double;[B*10]" -t AttFormula
case AttributeTypeEnum.AttFormula:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["Formula"];
attribute.ConfigString = value;
break;
// AFCreateAttribute -e \\tst-srv\db1\AFSDKExamples\CreateAttributes -n Attribute2 -v "Hello ;World" -t AttStringBuilder
case AttributeTypeEnum.AttStringBuilder:
attribute.DataReferencePlugIn = piSystem.DataReferencePlugIns["String Builder"];
attribute.ConfigString = value;
break;
}
Logger.Info("Checking in the changes");
element.CheckIn();
Logger.Info("Attibute Created");
}
public AttributeDefinition(string name, AttributeTypeEnum type, AttributeFlagsEnum flags)
{
this.Name = name ?? throw new ArgumentNullException(nameof(name));
this.Type = type;
this.Flags = flags;
}
/// <summary>
/// Get an Import-Attribute
/// </summary>
private ImportAttribute(string staticName, string name, AttributeTypeEnum type, string notes, bool? visibleInEditUi, object defaultValue)
{
StaticName = staticName;
Type = type.ToString();
AttributeMetaData = new List<ImportEntity> { GetAttributeMetaData(name, notes, visibleInEditUi, HelpersToRefactor.SerializeValue(defaultValue)) };
}
//public static Attribute GetAttributeFromName(AryaDbDataContext db, string attributeName,
// bool createIfNotFound, AttributeTypeEnum attributeType = AttributeTypeEnum.NonMeta)
public static Attribute GetAttributeFromName(AryaDbDataContext db, string attributeName, bool createIfNotFound, AttributeTypeEnum attributeType = AttributeTypeEnum.NonMeta, bool useChache = true)
{
// select cache to use
//TODO: Very important please ask vivek for making this change.
if (!useChache)
{
NonMetaAttributeCache.Clear();
SchemaMetaAttributeCache.Clear();
SchemaMetaMetaAttributeCache.Clear();
TaxonomyMetaAttributeCache.Clear();
TaxonomyMetaMetaAttributeCache.Clear();
}
Dictionary <string, Attribute> attributeCache;
switch (attributeType)
{
case AttributeTypeEnum.SchemaMeta:
{
attributeCache = SchemaMetaAttributeCache;
break;
}
case AttributeTypeEnum.SchemaMetaMeta:
{
attributeCache = SchemaMetaMetaAttributeCache;
break;
}
case AttributeTypeEnum.TaxonomyMeta:
{
attributeCache = TaxonomyMetaAttributeCache;
break;
}
case AttributeTypeEnum.TaxonomyMetaMeta:
{
attributeCache = TaxonomyMetaMetaAttributeCache;
break;
}
case AttributeTypeEnum.Workflow:
{
attributeCache = WorkflowAttributeCache;
break;
}
default: //Sku, Global, Derived, Flag
{
attributeCache = NonMetaAttributeCache;
break;
}
}
// format attribute name
attributeName = attributeName.Trim();
var lowerAttributeName = attributeName.ToLower();
// try to find attribute in cache and make sure it is correct
if (attributeCache.ContainsKey(lowerAttributeName))
{
var attribute = attributeCache[lowerAttributeName];
if (attribute != null && !attribute.AttributeName.ToLower().Equals(lowerAttributeName))
{
attributeCache.Remove(lowerAttributeName);
}
else
{
return(attribute);
}
}
// if attribute is not cached, try to find it in the whole attribute file
Attribute newAttribute = null;
var attQuery = from attribute in db.Attributes
where attribute.AttributeName.ToLower().Equals(lowerAttributeName) && attribute.ProjectID == db.CurrentProject.ID
select attribute;
attQuery = attributeType == AttributeTypeEnum.NonMeta
? attQuery.Where(attr => NonMetaAttributeTypes.Contains(attr.AttributeType))
: attQuery.Where(attr => attr.AttributeType == attributeType.ToString());
var att = attQuery.FirstOrDefault();
// if found, return it
if (att != null)
{
newAttribute = att;
}
// if not found and creation is requested, create it
else if (createIfNotFound)
{
newAttribute = new Attribute(db)
{
AttributeName = attributeName,
AttributeType =
(attributeType == AttributeTypeEnum.NonMeta
? AttributeTypeEnum.Sku
: attributeType).ToString()
};
db.CurrentProject.Attributes.Add(newAttribute);
// db.SubmitChanges();
}
// if attribute exists, try to add it to the appropriate cache
if (newAttribute != null)
{
if (!attributeCache.Keys.Contains(lowerAttributeName))
{
attributeCache.Add(lowerAttributeName, newAttribute);
}
}
return(newAttribute);
}
public void AddOrUpdateRequiredAttribute(AttributeTypeEnum attributeTypeEnum, long level)
{
requiredAttributes[attributeTypeEnum] = level;
}
