/// <summary>
///
/// </summary>
/// <param name="vaultAlias"></param>
/// <param name="objType"></param>
/// <param name="keyDef">唯一标识的属性定义ID</param>
/// <param name="objCount">期望的对象个数</param>
/// <returns>所有存在的对象</returns>
private Dictionary <string, List <ObjVer> > GetElements(VaultAliases vaultAlias, int objType, int keyDef, int objCount)
{
var dict = new Dictionary <string, List <ObjVer> >();
var res = SearchObjects(vaultAlias, objType, objCount);
var guidDef = keyDef;//_aliases.PdDict[PD.Guid];
var objVers = new ObjVers();
foreach (ObjectVersion ver in res)
{
objVers.Add(-1, ver.ObjVer);
}
var vault = vaultAlias.Vault;
var mm = vault.ObjectPropertyOperations.GetPropertiesOfMultipleObjects(objVers);
var hasDict = new Dictionary <string, List <ObjVer> >();
for (var i = 0; i < mm.Count; i++)
{
var j = i + 1;
var guid = mm[j].SearchForProperty(guidDef).GetValueAsLocalizedText();
if (dict.ContainsKey(guid))
{
dict[guid].Add(objVers[j]);
}
else
{
dict.Add(guid, new List <ObjVer> {
objVers[j]
});
}
}
return(dict);
}
public static void AddProperties(this ViewElement view, PropertyValues pvs, VaultAliases vaultAlias, int levelId, int modeId)
{
view.AddBasicProperties(pvs, vaultAlias, modeId);
var vtPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.ViewType]
};
vtPV.Value.SetValue(MFDataType.MFDatatypeInteger, view.ViewType);
pvs.Add(-1, vtPV);
if (view.ViewDiscipline != null)
{
var vdPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.ViewDisc]
};
vdPV.Value.SetValue(MFDataType.MFDatatypeInteger, view.ViewDiscipline.Value);
pvs.Add(-1, vdPV);
}
if (view.GenLevel != null)
{
if (levelId <= 0)
{
throw new Exception("必须指定楼层");
}
var glPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Level]
};
glPV.Value.SetValue(MFDataType.MFDatatypeLookup, levelId);
pvs.Add(-1, glPV);
}
}
public static PropertyValues UpdateMaterial(this MaterialElement mat, VaultAliases vaultAlias, int modelId)
{
var pvs = new PropertyValues();
AddProperties(mat, pvs, vaultAlias, modelId);
return(pvs);
}
public static PropertyValues UpdateFamily(this ElementFamily fam, VaultAliases vaultAlias, int cateId, int modelId)
{
var pvs = new PropertyValues();
AddProperties(fam, pvs, vaultAlias, cateId, modelId);
return(pvs);
}
public static PropertyValues UpdateView(this ViewElement view, VaultAliases vaultAlias, int levelId, int modelId)
{
var pvs = new PropertyValues();
AddProperties(view, pvs, vaultAlias, levelId, modelId);
return(pvs);
}
public static PropertyValues UpdatePartType(this ElementType elemType, VaultAliases vaultAlias, int modelId)
{
var pvs = new PropertyValues();
AddProperties(elemType, pvs, vaultAlias, modelId);
return(pvs);
}
public static PropertyValues UpdateFloor(this LevelElement level, VaultAliases vaultAlias, int modelId)
{
var pvs = new PropertyValues();
AddProperties(level, pvs, vaultAlias, modelId);
return(pvs);
}
public static ObjVer CreateMaterial(this MaterialElement mat, VaultAliases vaultAlias, int modelId, AccessControlList acl)
{
var objTypeId = vaultAlias.ObDict[OB.Material];
var classId = vaultAlias.CsDict[CS.Material];
var pvs = new PropertyValues();
AddProperties(mat, pvs, vaultAlias, modelId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
public static PropertyValues UpdatePart(this Element elem, VaultAliases vaultAlias
, int cateId, int typeId, int matId, int levelId, int famId, int modelId, string modelUrl, int?unitId, int?floorId, int?discId)
{
var pvs = new PropertyValues();
AddProperties(elem, pvs, vaultAlias, cateId, typeId, matId, levelId, famId, modelId, modelUrl, unitId, floorId, discId);
return(pvs);
}
public static ObjVer CreateFamily(this ElementFamily fam, VaultAliases vaultAlias, int cateId, int modelId, AccessControlList acl)
{
var objTypeId = vaultAlias.ObDict[OB.Family];
var classId = vaultAlias.CsDict[CS.Family];
var pvs = new PropertyValues();
AddProperties(fam, pvs, vaultAlias, cateId, modelId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
public static ObjVer CreatePart(this Element elem, VaultAliases vaultAlias
, int cateId, int typeId, int matId, int levelId, int famId, int modelId, AccessControlList acl, string modelUrl, int?unitId, int?floorId, int?discId)
{
var objTypeId = vaultAlias.ObDict[OB.Part];
var classId = vaultAlias.CsDict[CS.Part];
var pvs = new PropertyValues();
AddProperties(elem, pvs, vaultAlias, cateId, typeId, matId, levelId, famId, modelId, modelUrl, unitId, floorId, discId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
public static ObjVer CreateView(this ViewElement view, VaultAliases vaultAlias, int levelId, int modelId, AccessControlList acl)
{
var objTypeId = vaultAlias.ObDict[OB.View];
var classId = vaultAlias.CsDict[CS.View];
var pvs = new PropertyValues();
AddProperties(view, pvs, vaultAlias, levelId, modelId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
public static PropertyValues UpdateCategory(this ElementCategory cate, VaultAliases vaultAlias, int modelId)
{
if (cate == null)
{
return(null);
}
var pvs = new PropertyValues();
AddProperties(cate, pvs, vaultAlias, modelId);
return(pvs);
}
public static ObjVer CreateCategory(this ElementCategory cate, VaultAliases vaultAlias, int modelId, AccessControlList acl)
{
if (cate == null)
{
return(null);
}
var objTypeId = vaultAlias.ObDict[OB.Category];
var classId = vaultAlias.CsDict[CS.Category];
var pvs = new PropertyValues();
AddProperties(cate, pvs, vaultAlias, modelId);
return(BaseElementExtensions.CreateBasicObject(objTypeId, classId, pvs, vaultAlias.Vault, acl));
}
private MfModel(Model model, Vault vault)
{
_model = model;
_name = model.Name;
_filePath = model.Filepath;
_vault = vault;
if (vault != null)
{
_clientVault = false;
}
if (vault != null)
{
_aliases = VaultAliases.GetAliases(_vault);
}
}
public static void AddProperties(this ElementFamily fam, PropertyValues pvs, VaultAliases vaultAlias, int cateId, int modelId)
{
fam.AddBasicProperties(pvs, vaultAlias, modelId);
var catePV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.PartCategory]
};
catePV.Value.SetValue(MFDataType.MFDatatypeLookup, cateId);
pvs.Add(-1, catePV);
if (fam.Parameters.Count > 0)
{
var pPV = BaseElementExtensions.CreateParameterProp(fam.Parameters, vaultAlias);
pvs.Add(-1, pPV);
}
}
private void Initialize()
{
if (_inited)
{
return;
}
if (_clientVault)
{
if (!ClientUtils.IsInMf(_filePath))
{
throw new Exception("文件未在云系统中！");
}
if (_vault == null)
{
var obj = ClientUtils.GetObjectFromURL(_filePath);
_vault = obj.Vault;
_obj = obj.VersionData;
}
}
else
{
if (_vault == null)
{
throw new Exception("服务端必须指定文档库");
}
var objID = new ObjID();
objID.SetIDs((int)MFBuiltInObjectType.MFBuiltInObjectTypeDocument, _model.Id);
var objAndProps = _vault.ObjectOperations.GetLatestObjectVersionAndProperties(objID, true);
_obj = objAndProps.VersionData;
}
_name = _obj.Title;
if (_aliases == null)
{
_aliases = VaultAliases.GetAliases(_vault);
}
if (!_aliases.IsValid)
{
throw new Exception("文档库缺少必须的元数据！");
}
_inited = true;
}
/// <summary>
/// 根据类型和所属模型搜索构件、类别、类型、楼层、材料等
/// </summary>
/// <param name="aliases"></param>
/// <param name="objType"></param>
/// <param name="objCount">期望的对象个数</param>
/// <returns></returns>
private ObjectSearchResults SearchObjects(VaultAliases aliases, int objType, int objCount)
{
var scs = new SearchConditions();
var typeSc = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
typeSc.Expression.DataStatusValueType = MFStatusType.MFStatusTypeObjectTypeID;
typeSc.TypedValue.SetValue(MFDataType.MFDatatypeLookup, objType);
scs.Add(-1, typeSc);
var ownerSc = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
ownerSc.Expression.DataPropertyValuePropertyDef = aliases.PdDict[PD.OwnedModel];
ownerSc.TypedValue.SetValue(MFDataType.MFDatatypeLookup, Model.Id);
scs.Add(-1, ownerSc);
var delSc = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
delSc.Expression.DataStatusValueType = MFStatusType.MFStatusTypeDeleted;
delSc.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
scs.Add(-1, delSc);
var vault = aliases.Vault;
if (objCount < MaxSearchCount)
{
return(vault.ObjectSearchOperations.SearchForObjectsByConditions(scs, MFSearchFlags.MFSearchFlagNone,
false));
}
else
{
return(vault.ObjectSearchOperations.SearchForObjectsByConditionsEx(scs, MFSearchFlags.MFSearchFlagNone,
false, objCount * 3, 120));
}
}
internal static ObjectSearchResults GetParts(Vault vault, VaultAliases aliases, string guid)
{
var partObjTypeId = aliases.ObDict[OB.Part];
var guidPropId = aliases.PdDict[PD.Guid];
var scs = new SearchConditions();
var typeSC = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
typeSC.Expression.DataStatusValueType = MFStatusType.MFStatusTypeObjectTypeID;
typeSC.TypedValue.SetValue(MFDataType.MFDatatypeLookup, partObjTypeId);
scs.Add(-1, typeSC);
var ifcSC = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
ifcSC.Expression.DataPropertyValuePropertyDef = guidPropId;
ifcSC.TypedValue.SetValue(MFDataType.MFDatatypeText, guid);
scs.Add(-1, ifcSC);
var delSC = new SearchCondition {
ConditionType = MFConditionType.MFConditionTypeEqual
};
delSC.Expression.DataStatusValueType = MFStatusType.MFStatusTypeDeleted;
delSC.TypedValue.SetValue(MFDataType.MFDatatypeBoolean, false);
scs.Add(-1, delSC);
var res = vault.ObjectSearchOperations.SearchForObjectsByConditions(scs, MFSearchFlags.MFSearchFlagNone,
false);
return(res);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="vaultAlias"></param>
/// <param name="objType"></param>
/// <param name="keyDef"></param>
/// <param name="objs">要处理的对象列表</param>
/// <param name="objDict">已处理的对象词典</param>
/// <param name="objList">所有的对象集合</param>
/// <param name="createFunc"></param>
/// <param name="updateFunc"></param>
private void OperateElements <T>(VaultAliases vaultAlias, int objType, int keyDef, List <T> objs, Dictionary <string, int> objDict
, List <string> objList, Func <T, ObjVer> createFunc, Func <T, PropertyValues> updateFunc) where T : BaseElement
{
var ts = GetTrace <T>();
var vault = vaultAlias.Vault;
try
{
var objsHas = GetElements(vaultAlias, objType, keyDef, objList.Count); //获取已有的对象词典
List <T> createObjs, updateObjs;
var updateDict = new Dictionary <string, ObjVer>();
if (objsHas.Count > 0)
{
createObjs = new List <T>();
updateObjs = new List <T>();
var delObjs = SplitElements(objs, objsHas, objList, createObjs, updateObjs, updateDict);
if (delObjs.Count > 0)
{
foreach (var ov in delObjs)
{
vault.ObjectOperations.DeleteObject(ov.ObjID);
}
}
}
else
{
createObjs = objs;
updateObjs = new List <T>();
}
//var objVers = new ObjVers();
if (updateObjs.Count > 0)
{
ts.TraceInformation("UpdateElementsWithParams: " + updateObjs.Count);
try
{
var uObjGrp = GroupArrays(updateObjs, MaxCount);
foreach (var ug in uObjGrp)
{
var objsU = UpdateElementsWithParams(vault, ug, objDict, updateDict, updateFunc);
var res = vault.ObjectPropertyOperations.SetPropertiesOfMultipleObjects(objsU);
var objVers = new ObjVers();
foreach (ObjectVersionAndProperties vp in res)
{
objVers.Add(-1, vp.ObjVer);
}
vault.ObjectOperations.CheckInMultipleObjects(objVers);
}
}
catch (Exception ex)
{
ts.TraceEvent(TraceEventType.Error, 0, "UpdateElementsWithParams：" + updateObjs.Count + "; 错误：" + ex.Message);
throw;
}
}
if (createObjs.Count > 0)
{
ts.TraceInformation("CreateElementsWithParams: " + createObjs.Count);
try
{
var cObjGrp = GroupArrays(createObjs, MaxCount);
foreach (var ug in cObjGrp)
{
var objsC = CreateElementsWithParams(ug, objDict, createFunc);
var objVers = new ObjVers();
foreach (ObjVer v in objsC)
{
objVers.Add(-1, v);
}
vault.ObjectOperations.CheckInMultipleObjects(objVers);
}
}
catch (Exception ex)
{
ts.TraceEvent(TraceEventType.Error, 0, "CreateElementsWithParams：" + createObjs.Count + "; 错误：" + ex.Message);
throw;
}
}
}
catch (Exception ex)
{
ts.TraceEvent(TraceEventType.Error, 0, "需要创建或更新的对象个数：" + objs.Count + "; 错误：" + ex.Message);
throw;
}
finally
{
ts.Close();
}
}
public static void AddProperties(this LevelElement level, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
level.AddBasicProperties(pvs, vaultAlias, modelId);
var elevPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Elevation]
};
elevPV.Value.SetValue(MFDataType.MFDatatypeText, level.Elevation);
pvs.Add(-1, elevPV);
}
public static void AddProperties(this ElementType elemType, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
elemType.AddBasicProperties(pvs, vaultAlias, modelId);
if (elemType.Parameters.Count > 0)
{
var pPV = BaseElementExtensions.CreateParameterProp(elemType.Parameters, vaultAlias);
pvs.Add(-1, pPV);
}
}
public MfModelDicts Run(VaultAliases aliases)
{
if (Model == null)
{
throw new Exception("未指定模型！");
}
var modelId = Model.Id;
var list = GetLists();
var idKey = aliases.PdDict[PD.Id];
var guidKey = aliases.PdDict[PD.Guid];
//处理构件类型
if (Model.Types.Count > 0)
{
var typeId = aliases.ObDict[OB.PartType];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
OperateElements(aliases, typeId, guidKey, Model.Types, Dicts.Types, list.Types
, t => t.CreatePartType(aliases, modelId, acl), t => t.UpdatePartType(aliases, modelId));
}
//处理类别
if (Model.Categories.Count > 0)
{
var typeId = aliases.ObDict[OB.Category];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
OperateElements(aliases, typeId, idKey, Model.Categories, Dicts.Cates, list.Cates
, c => c.CreateCategory(aliases, modelId, acl), c => c.UpdateCategory(aliases, modelId));
}
//处理楼层
if (Model.Levels.Count > 0)
{
var typeId = aliases.ObDict[OB.Level];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
OperateElements(aliases, typeId, guidKey, Model.Levels, Dicts.Floors, list.Floors
, fl => fl.CreateFloor(aliases, modelId, acl), fl => fl.UpdateFloor(aliases, modelId));
}
//处理材料
if (Model.Materials.Count > 0)
{
var typeId = aliases.ObDict[OB.Material];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
OperateElements(aliases, typeId, guidKey, Model.Materials, Dicts.Mats, list.Mats
, m => m.CreateMaterial(aliases, modelId, acl), m => m.UpdateMaterial(aliases, modelId));
}
//处理视图
if (Model.Views.Count > 0)
{
var typeId = aliases.ObDict[OB.View];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
Func <ViewElement, ObjVer> viewCreateFunc = v =>
{
var lId = 0;
if (v.GenLevel != null)
{
lId = Dicts.Floors[v.GenLevel];
}
var vId = v.CreateView(aliases, lId, modelId, acl);
return(vId);
};
Func <ViewElement, PropertyValues> viewUpdateFunc = v =>
{
var lId = 0;
if (v.GenLevel != null)
{
lId = Dicts.Floors[v.GenLevel];
}
var vId = v.UpdateView(aliases, lId, modelId);
return(vId);
};
OperateElements(aliases, typeId, guidKey,
Model.Views, Dicts.Views, list.Views, viewCreateFunc, viewUpdateFunc);
}
//处理族
if (Model.Families.Count > 0)
{
var typeId = aliases.ObDict[OB.Family];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(typeId);
var acl = objType.AccessControlList;
Func <ElementFamily, ObjVer> famCreateFunc = f =>
{
var cateId = 0;
if (f.Category != null)
{
cateId = Dicts.Cates[f.Category.GetKey()];
}
return(f.CreateFamily(aliases, cateId, modelId, acl));
};
Func <ElementFamily, PropertyValues> famUpdateFunc = f =>
{
var cateId = 0;
if (f.Category != null)
{
cateId = Dicts.Cates[f.Category.GetKey()];
}
return(f.UpdateFamily(aliases, cateId, modelId));
};
OperateElements(aliases, typeId, guidKey,
Model.Families, Dicts.Fams, list.Fams, famCreateFunc, famUpdateFunc);
}
//处理构件
if (Model.Elements.Count > 0)
{
var partObjId = aliases.ObDict[OB.Part];
var objType = aliases.Vault.ObjectTypeOperations.GetObjectType(partObjId);
var acl = objType.AccessControlList;
Func <Element, ObjVer> partCreateFunc = p =>
{
int cateId = Dicts.Cates[p.Category.GetKey()];
int typeId = Dicts.Types[p.ElemType];
int matId = 0;
if (p.Material != null)
{
matId = Dicts.Mats[p.Material];
}
int levelId = 0;
if (p.Level != null)
{
levelId = Dicts.Floors[p.Level];
}
int famId = 0;
if (p.Family != null)
{
famId = Dicts.Fams[p.Family];
}
return(p.CreatePart(aliases, cateId, typeId, matId, levelId, famId, modelId, acl, ModelUrl, UnitId, FloorId, DiscId));
};
Func <Element, PropertyValues> partUpdateFunc = p =>
{
int cateId = Dicts.Cates[p.Category.GetKey()];
int typeId = Dicts.Types[p.ElemType];
int matId = 0;
if (p.Material != null)
{
matId = Dicts.Mats[p.Material];
}
int levelId = 0;
if (p.Level != null)
{
levelId = Dicts.Floors[p.Level];
}
int famId = 0;
if (p.Family != null)
{
famId = Dicts.Fams[p.Family];
}
return(p.UpdatePart(aliases, cateId, typeId, matId, levelId, famId, modelId, ModelUrl, UnitId, FloorId, DiscId));
};
var log = GetTrace <Element>();
try
{
log.TraceInformation("类别词典：" + Dicts.Cates.Count);
log.TraceInformation("类型词典：" + Dicts.Types.Count);
log.TraceInformation("材料词典：" + Dicts.Mats.Count);
log.TraceInformation("楼层词典：" + Dicts.Floors.Count);
log.TraceInformation("族词典： " + Dicts.Fams.Count);
log.TraceInformation("构件个数： " + Model.Elements.Count);
OperateElements(aliases, partObjId, guidKey,
Model.Elements, Dicts.Elems, list.Elems, partCreateFunc, partUpdateFunc);
}
catch (Exception ex)
{
log.TraceEvent(TraceEventType.Error, 0, "构件个数：" + Model.Elements.Count + "; " + ex.Message);
throw;
}
finally
{
log.Close();
}
}
return(Dicts);
}
public static void AddProperties(this Element elem, PropertyValues pvs, VaultAliases vaultAlias
, int cateId, int typeId, int matId, int levelId, int famId, int modelId, string modelUrl, int?unitId, int?floorId, int?discId)
{
elem.AddBasicProperties(pvs, vaultAlias, modelId);
if (elem.IfcId != null)
{
var ifcPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.IfcId]
};
ifcPV.Value.SetValue(MFDataType.MFDatatypeText, elem.IfcId);
pvs.Add(-1, ifcPV);
if (!String.IsNullOrEmpty(modelUrl))
{
var urlPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.ModelUrl]
};
urlPV.Value.SetValue(MFDataType.MFDatatypeMultiLineText, modelUrl + "&ifcguid=" + elem.IfcId);
pvs.Add(-1, urlPV);
}
}
var catePV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.PartCategory]
};
catePV.Value.SetValue(MFDataType.MFDatatypeLookup, cateId);
pvs.Add(-1, catePV);
var typePV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.PartType]
};
typePV.Value.SetValue(MFDataType.MFDatatypeLookup, typeId);
pvs.Add(-1, typePV);
if (matId > 0)
{
var matPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Material]
};
matPV.Value.SetValue(MFDataType.MFDatatypeLookup, matId);
pvs.Add(-1, matPV);
}
if (levelId > 0)
{
var levelPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Level]
};
levelPV.Value.SetValue(MFDataType.MFDatatypeLookup, levelId);
pvs.Add(-1, levelPV);
}
if (elem.Parameters.Count > 0)
{
var pPV = BaseElementExtensions.CreateParameterProp(elem.Parameters, vaultAlias);
pvs.Add(-1, pPV);
}
if (elem.Family != null)
{
var pPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.OwnedFamily]
};
pPV.Value.SetValue(MFDataType.MFDatatypeLookup, famId);
pvs.Add(-1, pPV);
}
if (unitId != null)
{
var pPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.ModelUnitAt]
};
pPV.Value.SetValue(MFDataType.MFDatatypeLookup, unitId.Value);
pvs.Add(-1, pPV);
}
if (floorId != null)
{
var pPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.FloorAt]
};
pPV.Value.SetValue(MFDataType.MFDatatypeLookup, floorId.Value);
pvs.Add(-1, pPV);
}
if (discId != null)
{
var pPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.DiscAt]
};
pPV.Value.SetValue(MFDataType.MFDatatypeLookup, discId.Value);
pvs.Add(-1, pPV);
}
}
public static void AddBasicProperties(this ElementWithGuid elem, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
var idPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Id]
};
idPV.Value.SetValue(MFDataType.MFDatatypeInteger, elem.Id);
pvs.Add(-1, idPV);
var guidPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Guid]
};
guidPV.Value.SetValue(MFDataType.MFDatatypeText, elem.Guid);
pvs.Add(-1, guidPV);
var namePV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Name]
};
namePV.Value.SetValue(MFDataType.MFDatatypeText, elem.Name);
pvs.Add(-1, namePV);
var modelPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.OwnedModel]
};
modelPV.Value.SetValue(MFDataType.MFDatatypeLookup, modelId);
pvs.Add(-1, modelPV);
}
public static void AddProperties(this ElementCategory cate, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
if (cate == null)
{
return;
}
var idPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Id]
};
idPV.Value.SetValue(MFDataType.MFDatatypeInteger, cate.Id);
pvs.Add(-1, idPV);
var namePV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.Name]
};
namePV.Value.SetValue(MFDataType.MFDatatypeText, cate.Name);
pvs.Add(-1, namePV);
var modelPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.OwnedModel]
};
modelPV.Value.SetValue(MFDataType.MFDatatypeLookup, modelId);
pvs.Add(-1, modelPV);
}
public static PropertyValue CreateParameterProp(List <ElementParameter> parameters, VaultAliases vaultAlias)
{
parameters.Sort();
var pPV = new PropertyValue {
PropertyDef = vaultAlias.PdDict[PD.ParamList]
};
pPV.Value.SetValue(MFDataType.MFDatatypeMultiLineText,
String.Join("\r\n", parameters.Select(c => c.ToString())));
return(pPV);
}
public static VaultAliases GetAliases(Vault vault)
{
var va = new VaultAliases {
Vault = vault
};
try
{
var ocId = MfAlias.GetObjType(vault, OB.Category);
va.ObDict.Add(OB.Category, ocId);
var cateObjType = vault.ObjectTypeOperations.GetObjectType(ocId);
va.Categories = cateObjType.DefaultPropertyDef;
var ofId = MfAlias.GetObjType(vault, OB.Level);
va.ObDict.Add(OB.Level, ofId);
var floorObjType = vault.ObjectTypeOperations.GetObjectType(ofId);
va.Levels = floorObjType.DefaultPropertyDef;
var opId = MfAlias.GetObjType(vault, OB.Part);
va.ObDict.Add(OB.Part, opId);
var partObjType = vault.ObjectTypeOperations.GetObjectType(opId);
va.Parts = partObjType.DefaultPropertyDef;
var parttId = MfAlias.GetObjType(vault, OB.PartType);
va.ObDict.Add(OB.PartType, parttId);
var parttObjType = vault.ObjectTypeOperations.GetObjectType(parttId);
va.PartTypes = parttObjType.DefaultPropertyDef;
var famId = MfAlias.GetObjType(vault, OB.Family);
va.ObDict.Add(OB.Family, famId);
var famObjType = vault.ObjectTypeOperations.GetObjectType(famId);
va.PartFamilies = famObjType.DefaultPropertyDef;
var matId = MfAlias.GetObjType(vault, OB.Material);
va.ObDict.Add(OB.Material, matId);
var matObjType = vault.ObjectTypeOperations.GetObjectType(matId);
va.Materials = matObjType.DefaultPropertyDef;
var viewId = MfAlias.GetObjType(vault, OB.View);
va.ObDict.Add(OB.View, viewId);
var viewObjType = vault.ObjectTypeOperations.GetObjectType(viewId);
va.Views = viewObjType.DefaultPropertyDef;
var olId = MfAlias.GetObjType(vault, OB.Floor);
va.ObDict.Add(OB.Floor, olId);
var mduId = MfAlias.GetObjType(vault, OB.ModelUnit);
va.ObDict.Add(OB.ModelUnit, mduId);
var mdiId = MfAlias.GetObjType(vault, OB.ModelDisc);
va.ObDict.Add(OB.ModelDisc, mdiId);
var ccId = MfAlias.GetObjectClass(vault, CS.Category);
va.CsDict.Add(CS.Category, ccId);
var cfId = MfAlias.GetObjectClass(vault, CS.Level);
va.CsDict.Add(CS.Level, cfId);
var cpId = MfAlias.GetObjectClass(vault, CS.Part);
va.CsDict.Add(CS.Part, cpId);
var cpfId = MfAlias.GetObjectClass(vault, CS.PartType);
va.CsDict.Add(CS.PartType, cpfId);
var cFamId = MfAlias.GetObjectClass(vault, CS.Family);
va.CsDict.Add(CS.Family, cFamId);
var cppId = MfAlias.GetObjectClass(vault, CS.View);
va.CsDict.Add(CS.View, cppId);
var cmatId = MfAlias.GetObjectClass(vault, CS.Material);
va.CsDict.Add(CS.Material, cmatId);
var cfamPartId = MfAlias.GetObjectClass(vault, CS.FamilyPart);
va.CsDict.Add(CS.FamilyPart, cfamPartId);
var ifcModelId = MfAlias.GetObjectClass(vault, CS.IfcModel, false);
va.CsDict.Add(CS.IfcModel, ifcModelId);
//var cparamId = MfAlias.GetObjectClass(vault, CS.Parameter);
//va.CsDict.Add(CS.Parameter, cparamId);
var docbId = MfAlias.GetObjectClass(vault, CS.DocBimModel);
va.CsDict.Add(CS.DocBimModel, docbId);
var clId = MfAlias.GetObjectClass(vault, CS.Floor);
va.CsDict.Add(CS.Floor, clId);
var cmduId = MfAlias.GetObjectClass(vault, CS.ModelUnit);
va.CsDict.Add(CS.ModelUnit, cmduId);
var cmdiId = MfAlias.GetObjectClass(vault, CS.ModelDisc);
va.CsDict.Add(CS.ModelDisc, cmdiId);
///////
var fpId = MfAlias.GetPropDef(vault, PD.OwnedFamily);
va.PdDict.Add(PD.OwnedFamily, fpId);
var glId = MfAlias.GetPropDef(vault, PD.Level);
va.PdDict.Add(PD.Level, glId);
var guidId = MfAlias.GetPropDef(vault, PD.Guid);
va.PdDict.Add(PD.Guid, guidId);
var idId = MfAlias.GetPropDef(vault, PD.Id);
va.PdDict.Add(PD.Id, idId);
var pdMatId = MfAlias.GetPropDef(vault, PD.Material);
va.PdDict.Add(PD.Material, pdMatId);
var pnId = MfAlias.GetPropDef(vault, PD.Name);
va.PdDict.Add(PD.Name, pnId);
var pdCateId = MfAlias.GetPropDef(vault, PD.PartCategory);
va.PdDict.Add(PD.PartCategory, pdCateId);
var pdTypeId = MfAlias.GetPropDef(vault, PD.PartType);
va.PdDict.Add(PD.PartType, pdTypeId);
var vdId = MfAlias.GetPropDef(vault, PD.ViewDisc);
va.PdDict.Add(PD.ViewDisc, vdId);
var vtId = MfAlias.GetPropDef(vault, PD.ViewType);
va.PdDict.Add(PD.ViewType, vtId);
var elevId = MfAlias.GetPropDef(vault, PD.Elevation);
va.PdDict.Add(PD.Elevation, elevId);
var plId = MfAlias.GetPropDef(vault, PD.ParamList);
va.PdDict.Add(PD.ParamList, plId);
var omId = MfAlias.GetPropDef(vault, PD.OwnedModel);
va.PdDict.Add(PD.OwnedModel, omId);
var ofpId = MfAlias.GetPropDef(vault, PD.FamParamList);
va.PdDict.Add(PD.FamParamList, ofpId);
var ifcId = MfAlias.GetPropDef(vault, PD.IfcId);
va.PdDict.Add(PD.IfcId, ifcId);
var modelId = MfAlias.GetPropDef(vault, PD.ModelUrl, false);
va.PdDict.Add(PD.ModelUrl, modelId);
var docObjType =
vault.ObjectTypeOperations.GetBuiltInObjectType(MFBuiltInObjectType.MFBuiltInObjectTypeDocument);
va.Documents = docObjType.DefaultPropertyDef;
var pmnId = MfAlias.GetPropDef(vault, PD.ModelName, false);
va.PdDict.Add(PD.ModelName, pmnId);
var pmuaId = MfAlias.GetPropDef(vault, PD.ModelUnitAt, false);
va.PdDict.Add(PD.ModelUnitAt, pmuaId);
var pfaId = MfAlias.GetPropDef(vault, PD.FloorAt, false);
va.PdDict.Add(PD.FloorAt, pfaId);
var pdaId = MfAlias.GetPropDef(vault, PD.DiscAt, false);
va.PdDict.Add(PD.DiscAt, pdaId);
if (va.ObDict[OB.ModelUnit] != -1)
{
var muObjType = vault.ObjectTypeOperations.GetObjectType(va.ObDict[OB.ModelUnit]);
va.OwnerModelUnit = muObjType.OwnerPropertyDef;
}
if (va.ObDict[OB.Floor] != -1)
{
var flObjType = vault.ObjectTypeOperations.GetObjectType(va.ObDict[OB.Floor]);
va.OwnerFloor = flObjType.OwnerPropertyDef;
}
if (va.ObDict[OB.ModelDisc] != -1)
{
var mdObjType = vault.ObjectTypeOperations.GetObjectType(va.ObDict[OB.ModelDisc]);
va.OwnerModelDisc = mdObjType.OwnerPropertyDef;
}
va.IsValid = true;
}
catch (Exception ex)
{
throw;
va.IsValid = false;
}
return(va);
}
public static void AddProperties(this MaterialElement mat, PropertyValues pvs, VaultAliases vaultAlias, int modelId)
{
mat.AddBasicProperties(pvs, vaultAlias, modelId);
if (mat.Parameters.Count > 0)
{
var pPV = BaseElementExtensions.CreateParameterProp(mat.Parameters, vaultAlias);
pvs.Add(-1, pPV);
}
}
