/// <summary>
/// Deletes all of the specified DWG imports.
/// </summary>
/// <param name="imports">DWGs to be deleted.</param>
/// <returns>List of deleted DWGs.</returns>
public List <CadLinkTypeWrapper> Delete(List <CadLinkTypeWrapper> imports)
{
var deleted = new List <CadLinkTypeWrapper>();
using (var trans = new Transaction(_doc, "Delete Imports"))
{
trans.Start();
StatusBarManager.InitializeProgress("Deleting DWGs:", imports.Count);
foreach (var import in imports)
{
StatusBarManager.StepForward();
try
{
_doc.Delete(import.Id);
deleted.Add(import);
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
return(deleted);
}
/// <summary>
/// Method for deleting selected group types and all of their instances.
/// </summary>
/// <param name="app">UI Application.</param>
public void Delete(UIApplication app)
{
var doc = app.ActiveUIDocument.Document;
var groups = (List <GroupTypeWrapper>)Arg1;
var deleted = new List <GroupTypeWrapper>();
using (var trans = new Transaction(doc, "Delete Groups"))
{
trans.Start();
StatusBarManager.InitializeProgress("Deleting Groups...", groups.Count);
foreach (var g in groups)
{
StatusBarManager.StepForward();
try
{
doc.Delete(g.Id);
deleted.Add(g);
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
Messenger.Default.Send(new GroupsDeleted {
Groups = deleted
});
}
/// <summary>
/// Deletes selected styles from the model.
/// </summary>
/// <param name="styles">List of styles to delete.</param>
/// <returns>List of deleted styles.</returns>
public List <CategoryWrapper> Delete(List <CategoryWrapper> styles)
{
var deleted = new List <CategoryWrapper>();
using (var trans = new Transaction(_doc, "Delete Styles"))
{
trans.Start();
StatusBarManager.InitializeProgress("Deleting Styles:", styles.Count);
foreach (var style in styles)
{
StatusBarManager.StepForward();
try
{
_doc.Delete(style.Id);
deleted.Add(style);
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
return(deleted);
}
/// <summary>
/// Method for ungrouping selected group type and all of their instances.
/// Once all instances are ingrouped a Group Type will be deleted.
/// </summary>
/// <param name="app">UI Application.</param>
public void Ungroup(UIApplication app)
{
var doc = app.ActiveUIDocument.Document;
var groups = (List <GroupTypeWrapper>)Arg1;
var deleted = new List <GroupTypeWrapper>();
using (var trans = new Transaction(doc, "Ungroup Groups"))
{
trans.Start();
StatusBarManager.InitializeProgress("Ungrouping Groups...", groups.Count);
foreach (var g in groups)
{
StatusBarManager.StepForward();
var ungrouped = 0;
foreach (var id in g.Instances)
{
var instance = (Group)doc.GetElement(id);
if (instance == null)
{
continue;
}
try
{
instance.UngroupMembers();
ungrouped++;
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
if (ungrouped != g.Instances.Count)
{
continue;
}
try
{
doc.Delete(g.Id);
deleted.Add(g);
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
Messenger.Default.Send(new GroupsDeleted {
Groups = deleted
});
}
/// <summary>
///
/// </summary>
/// <param name="app"></param>
private void ClearOverrides(UIApplication app)
{
var doc = app.ActiveUIDocument.Document;
var dims = (List <DimensionWrapper>)Arg1;
var cleared = new List <DimensionWrapper>();
using (var trans = new Transaction(doc, "Remove Dimension Overrides"))
{
trans.Start();
StatusBarManager.InitializeProgress("Removing Overrides...", dims.Count);
foreach (var dw in dims)
{
StatusBarManager.StepForward();
try
{
var dim = (Dimension)doc.GetElement(dw.DimensionId);
if (dim == null)
{
return;
}
if (dim.NumberOfSegments == 0)
{
dim.ValueOverride = string.Empty;
cleared.Add(dw);
}
else
{
foreach (DimensionSegment s in dim.Segments)
{
if (s.GetHashCode() != dw.Hash)
{
continue;
}
s.ValueOverride = string.Empty;
cleared.Add(dw);
}
}
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
Messenger.Default.Send(new OverridesCleared {
Dimensions = cleared
});
}
/// <summary>
///
/// </summary>
/// <param name="app"></param>
private void ReplaceAndDeleteDimensionTypes(UIApplication app)
{
var doc = app.ActiveUIDocument.Document;
var dims = (List <DimensionTypeWrapper>)Arg1;
var repalcementDim = (DimensionTypeWrapper)Arg2;
var deleted = new List <DimensionTypeWrapper>();
using (var trans = new Transaction(doc, "Delete Dimension Types"))
{
trans.Start();
var replace = dims.ToDictionary(x => x.Id, x => x);
var replacement = (DimensionType)doc.GetElement(repalcementDim.Id);
var allDims = new FilteredElementCollector(doc)
.OfClass(typeof(Dimension))
.WhereElementIsNotElementType()
.Where(x => replace.ContainsKey(x.GetTypeId()))
.Cast <Dimension>()
.ToList();
// (Konrad) We need to first replace all instances that use the Types
// that will be deleted.
StatusBarManager.InitializeProgress("Replacing Types...", allDims.Count);
foreach (var d in allDims)
{
StatusBarManager.StepForward();
d.DimensionType = replacement;
}
StatusBarManager.FinalizeProgress();
// (Konrad) We can then safely delete the dimension type
StatusBarManager.InitializeProgress("Deleting Types...", dims.Count);
foreach (var dt in dims)
{
try
{
doc.Delete(dt.Id);
deleted.Add(dt);
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
Messenger.Default.Send(new DimensionsDeleted {
Dimensions = deleted
});
}
/// <summary>
///
/// </summary>
/// <param name="dims"></param>
/// <returns></returns>
public List <DimensionWrapper> ClearOverrides(List <DimensionWrapper> dims)
{
var result = new List <DimensionWrapper>();
using (var trans = new Transaction(_doc, "Clear Dimension Overrides"))
{
trans.Start();
StatusBarManager.InitializeProgress("Removing Overrides...", dims.Count);
foreach (var dw in dims)
{
StatusBarManager.StepForward();
try
{
var dim = (Dimension)_doc.GetElement(dw.DimensionId);
if (dim == null)
{
return(null);
}
if (dim.NumberOfSegments == 0)
{
dim.ValueOverride = string.Empty;
result.Add(dw);
}
else
{
foreach (DimensionSegment s in dim.Segments)
{
if (s.GetHashCode() != dw.Hash)
{
continue;
}
s.ValueOverride = string.Empty;
result.Add(dw);
}
}
}
catch (Exception e)
{
Log.AppendLog(LogMessageType.EXCEPTION, e.Message);
}
}
StatusBarManager.FinalizeProgress();
trans.Commit();
}
return(result);
}
private async void OnRunSimulation()
{
Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
var modelName = Dragonfly ? "Dragonfly" : "Honeybee";
StatusBarManager.InitializeProgress($"Exporting {modelName} Model...", 100, true);
var modelPath = await Task.Run(() => ProcessExport());
StatusBarManager.SetStatus("Start Simulation...");
var result = await Task.Run(() => Model.RunSimulation(Dragonfly, modelPath));
if (result == "Success!")
{
ShowResults();
}
StatusBarManager.FinalizeProgress(true);
StatusBarManager.SetStatus(result);
StatusBarManager.LogButton.Visibility = Visibility.Visible;
}
public Tuple <List <SpatialObjectWrapper>, List <LevelWrapper> > GetSpatialObjects(bool dragonfly)
{
var allLevels = new HashSet <LevelWrapper>();
var storedObjects = AppSettings.Instance.StoredSettings.EnergyModelSettings.Rooms;
var spatialObjects = new FilteredElementCollector(Doc)
.OfClass(typeof(SpatialElement))
.WhereElementIsNotElementType()
.Cast <SpatialElement>()
//.Where(x => (x is Room || x is Space) && x.Area > 0 && (x.Name.Contains("2-180")))
//.Where(x => (x is Room || x is Space) && x.Area > 0 && (x.Name.Contains("2-180") || x.Name.Contains("2-178")))
.Where(x => (x is Room || x is Space) && x.Area > 0)
.OrderBy(x => x.Level.Elevation)
.ToList();
var modelName = dragonfly ? "Dragonfly" : "Honeybee";
StatusBarManager.InitializeProgress($"Exporting {modelName} Model.", spatialObjects.Count);
var result = new List <SpatialObjectWrapper>();
foreach (var se in spatialObjects)
{
var timer = Stopwatch.StartNew();
StatusBarManager.StepForward($"Processing Room: {se.Name}.");
if (!storedObjects.Any())
{
result.Add(new SpatialObjectWrapper(se, dragonfly));
continue;
}
var index = storedObjects.FindIndex(y => y.Room2D?.Identifier == $"Room_{se.UniqueId}");
if (index == -1)
{
result.Add(new SpatialObjectWrapper(se, dragonfly));
continue;
}
var storedSo = storedObjects[index];
var so = new SpatialObjectWrapper(se, dragonfly);
so.IsConstructionSetOverriden = storedSo.IsConstructionSetOverriden;
so.IsProgramTypeOverriden = storedSo.IsProgramTypeOverriden;
so.Room2D.FloorToCeilingHeight = storedSo.Room2D.FloorToCeilingHeight;
so.Room2D.IsTopExposed = storedSo.Room2D.IsTopExposed;
so.Room2D.IsGroundContact = storedSo.Room2D.IsGroundContact;
so.Room2D.Properties.Energy.ConstructionSet = storedSo.Room2D.Properties.Energy.ConstructionSet;
so.Room2D.Properties.Energy.ProgramType = storedSo.Room2D.Properties.Energy.ProgramType;
allLevels.Add(so.Level);
result.Add(so);
_logger.Info($"Processed {so.Name} in {timer.Elapsed.TotalSeconds}s.");
}
if (dragonfly)
{
DF_AssignBoundaryConditions(result);
}
else
{
HB_AssignBoundaryConditions(result);
}
StatusBarManager.FinalizeProgress(true);
return(new Tuple <List <SpatialObjectWrapper>, List <LevelWrapper> >(result, allLevels.ToList()));
}
/// <summary>
/// Publishes information about linked models/images/object styles in the model.
/// </summary>
public void PublishData()
{
try
{
if (!MonitorUtilities.IsUpdaterOn(Project, Config, UpdaterGuid))
{
return;
}
if (string.IsNullOrEmpty(FamiliesId))
{
return;
}
var unusedFamilies = 0;
var oversizedFamilies = 0;
var inPlaceFamilies = 0;
var families = new FilteredElementCollector(Doc)
.OfClass(typeof(Family))
.Cast <Family>()
.ToList();
var config = MissionControlSetup.Configurations.ContainsKey(CentralPath)
? MissionControlSetup.Configurations[CentralPath]
: null;
var familyNameCheck = new List <string> {
"HOK_I", "HOK_M"
}; //defaults
if (config != null)
{
familyNameCheck = config.Updaters.First(x => string.Equals(x.UpdaterId,
Properties.Resources.HealthReportTrackerGuid, StringComparison.OrdinalIgnoreCase)).UserOverrides.FamilyNameCheck.Values;
}
//var count = 0;
var famOutput = new List <FamilyItem>();
StatusBarManager.InitializeProgress("Exporting Family Info:", families.Count);
foreach (var family in families)
{
// (Konrad) Uncomment for Debug.
//count++;
//if (count > 5) continue;
if (StatusBarManager.Cancel)
{
StatusBarManager.CancelProgress();
return;
}
StatusBarManager.StepForward();
var sizeCheck = false;
var instanceCheck = false;
var nameCheck = false;
var instances = CountFamilyInstances(family);
if (instances == 0)
{
unusedFamilies++;
instanceCheck = true;
}
if (family.IsInPlace)
{
inPlaceFamilies++;
}
long size = 0;
var refPlanes = 0;
var arrays = 0;
var voids = 0;
var nestedFamilies = 0;
var parameters = 0;
var sizeStr = "0Kb";
var images = 0;
try
{
var famDoc = Doc.EditFamily(family);
var storedPath = famDoc.PathName;
if (File.Exists(storedPath))
{
size = new FileInfo(storedPath).Length;
}
else
{
if (string.IsNullOrWhiteSpace(famDoc.Title))
{
continue; // could cause an exception
}
var myDocPath = IsCitrixMachine(Environment.MachineName)
? "B:\\Temp"
: Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var path = myDocPath + "\\temp_" + famDoc.Title;
if (path.IndexOfAny(Path.GetInvalidPathChars()) != -1)
{
continue; // could cause an exception
}
if (File.Exists(path))
{
TryToDelete(path);
}
famDoc.SaveAs(path);
size = new FileInfo(path).Length;
TryToDelete(path);
}
refPlanes = new FilteredElementCollector(famDoc)
.OfClass(typeof(ReferencePlane))
.GetElementCount();
var filter = new LogicalOrFilter(new List <ElementFilter>
{
new ElementClassFilter(typeof(LinearArray)),
new ElementClassFilter(typeof(RadialArray))
});
arrays = new FilteredElementCollector(famDoc)
.WherePasses(filter)
.GetElementCount();
images = new FilteredElementCollector(famDoc)
.OfClass(typeof(ImageType))
.WhereElementIsElementType()
.GetElementCount();
voids = new FilteredElementCollector(famDoc)
.OfClass(typeof(Extrusion))
.Cast <Extrusion>()
.Count(x => !x.IsSolid);
nestedFamilies = new FilteredElementCollector(famDoc)
.OfClass(typeof(Family))
.GetElementCount();
#if RELEASE2015
//(Konrad) Since Revit 2015 API doesn't support this we will just skip it.
parameters = 0;
#else
parameters = new FilteredElementCollector(famDoc)
.OfClass(typeof(ParameterElement))
.GetElementCount();
#endif
famDoc.Close(false);
sizeStr = StringUtilities.BytesToString(size);
if (size > 1000000)
{
oversizedFamilies++; // >1MB
sizeCheck = true;
}
}
catch (Exception ex)
{
Log.AppendLog(LogMessageType.EXCEPTION, ex.Message);
Log.AppendLog(LogMessageType.ERROR, "Failed to retrieve size, refPlanes, arrays, voids...");
}
if (!familyNameCheck.Any(family.Name.Contains))
{
nameCheck = true;
}
var famItem = new FamilyItem
{
Name = family.Name,
ElementId = family.Id.IntegerValue,
Size = sizeStr,
SizeValue = size,
Instances = instances,
ArrayCount = arrays,
RefPlaneCount = refPlanes,
VoidCount = voids,
NestedFamilyCount = nestedFamilies,
ParametersCount = parameters,
ImageCount = images,
Tasks = new List <FamilyTask>()
};
if (nameCheck || sizeCheck || instanceCheck)
{
famItem.IsFailingChecks = true;
}
else
{
famItem.IsFailingChecks = false;
}
famOutput.Add(famItem);
}
if (!ServerUtilities.GetByCentralPath(CentralPath, "families/centralpath", out FamilyData famStat))
{
Log.AppendLog(LogMessageType.ERROR, "Failed to retrieve Families data.");
return;
}
var famDict = new Dictionary <string, FamilyItem>();
if (famStat != null)
{
famDict = famStat.Families.ToDictionary(x => x.Name, x => x);
}
// (Konrad) I know it's not efficient to iterate this list yet again, but
// I want to minimize the amount of time between publishing families and
// retrieving them from database to avoid someone addind tasks to DB while
// we are exporting and hence losing them after the export.
foreach (var family in famOutput)
{
if (famDict.ContainsKey(family.Name))
{
family.Tasks.AddRange(famDict[family.Name].Tasks);
famDict.Remove(family.Name);
}
}
foreach (var item in famDict.Values.ToList())
{
item.IsDeleted = true;
famOutput.Add(item);
}
var familyStats = new FamilyData
{
CentralPath = CentralPath.ToLower(),
TotalFamilies = famOutput.Count,
UnusedFamilies = unusedFamilies,
InPlaceFamilies = inPlaceFamilies,
OversizedFamilies = oversizedFamilies,
CreatedBy = Environment.UserName.ToLower(),
CreatedOn = DateTime.UtcNow,
Families = famOutput
};
if (!ServerUtilities.Put(familyStats, "families/" + famStat.Id))
{
Log.AppendLog(LogMessageType.ERROR, "Failed to publish Families data.");
}
StatusBarManager.FinalizeProgress();
}
catch (Exception ex)
{
Log.AppendLog(LogMessageType.EXCEPTION, ex.Message);
}
}