private List <Room> HandleSync()
{
using (ProgressDialog pd = new ProgressDialog("Sync", 6))
{
pd.Show();
List <Room> syncedRooms = new List <Room>();
// get current revit rooms
pd.StartTask("Collecting Revit rooms");
IList <Element> collectedRooms = RevitMethods.GetElements(
_doc,
BuiltInCategory.OST_Rooms);
if (collectedRooms == null)
{
pd.Close();
return(null);
}
pd.Increment();
// get items from SP list
pd.StartTask("Fetching Sharepoint data");
SP.ListItemCollection allSpRooms = GetItemsFromSharepointList(
SharepointConstants.Links.spReadList,
SharepointConstants.Views.allItems);
if (allSpRooms == null)
{
pd.Close();
return(null);
}
pd.Increment();
// filter by current project
pd.StartTask("Retrieving rooms from current project");
IEnumerable <SP.ListItem> spRooms = SharepointMethods.GetItems(
allSpRooms,
SharepointConstants.ColumnHeaders.project_id,
_project[SharepointConstants.ColumnHeaders.ID].ToString());
if (spRooms == null)
{
pd.Close();
return(null);
}
pd.Increment();
// get the latest phase
pd.StartTask("Getting latest Revit phase");
Phase latestPhase = RevitMethods.GetLatestPhase(_doc);
if (latestPhase == null)
{
pd.Close();
return(null);
}
pd.Increment();
// check if room parameters exist
pd.StartTask("Checking Revit parameters");
bool roomParamsExist = RevitMethods.CheckParametersExist(
collectedRooms,
SharepointConstants.Dictionaries.newRevitRoomParameters);
pd.Increment();
// if they don't exist
if (!roomParamsExist)
{
// make new parameters
Dictionary <string, ExternalDefinition> roomParametersCreated = RevitMethods.CreateSharedParameters(
_doc,
_app,
SharepointConstants.Dictionaries.newRevitRoomParameters,
BuiltInCategory.OST_Rooms,
BuiltInParameterGroup.PG_REFERENCE);
if (roomParametersCreated == null)
{
pd.Close();
return(null);
}
// generate the rooms
pd.StartTask("Creating revit rooms");
syncedRooms = RevitMethods.CreateRooms(
_doc,
latestPhase,
spRooms,
roomParametersCreated);
pd.Increment();
}
else
{
// sync the existing rooms
pd.StartTask("Syncing revit rooms");
syncedRooms = RevitMethods.UpdateRooms(
_doc,
latestPhase,
collectedRooms,
spRooms,
SharepointConstants.Dictionaries.newRevitRoomParameters);
pd.Increment();
}
return(syncedRooms);
}
}
private List <Dictionary <string, string> > HandleUpload()
{
using (ProgressDialog pd = new ProgressDialog("Upload", 5))
{
pd.Show();
// collect rooms from the model, return false if there are none
pd.StartTask("Collecting placed rooms");
IList <SpatialElement> placedRooms = RevitMethods.GetPlacedRooms(_doc);
if (placedRooms == null)
{
pd.Close();
return(null);
}
pd.Increment();
// check if the custom room parameters exist
pd.StartTask("Checking room parameters");
bool roomParametersCheck = RevitMethods.CheckParametersExist(
placedRooms,
SharepointConstants.Dictionaries.newRevitRoomParameters);
if (roomParametersCheck == false)
{
pd.Close();
return(null);
}
pd.Increment();
// collect the room info for writing to sharepoint
pd.StartTask("Parsing room data");
List <Dictionary <string, string> > placedRoomsData = RevitMethods.ParseRoomData(
placedRooms,
SharepointConstants.Dictionaries.newRevitRoomParameters);
if (placedRoomsData == null)
{
pd.Close();
return(null);
}
pd.Increment();
// retrieve write list from sharepoint
pd.StartTask("Connecting to Sharepoint");
SP.List SPWriteList = SharepointMethods.GetListFromWeb(
_context,
SharepointConstants.Links.spWriteList);
if (SPWriteList == null)
{
pd.Close();
return(null);
}
pd.Increment();
// write the room data to the write list
pd.StartTask("Writing data to Sharepoint");
bool roomsUploaded = SharepointMethods.AddItemsToList(
_context,
SPWriteList,
placedRoomsData);
if (roomsUploaded == false)
{
pd.Close();
return(null);
}
pd.Increment();
// if we get to the end then return the written data
return(placedRoomsData);
}
}
/// <summary>
/// Collects model metrics and returns a dictionary
/// </summary>
/// <param name="doc">The active document</param>
/// <returns>Dictionary</returns>
public Dictionary <string, object> CollectModelData(Document doc, Application app)
{
/*
* the basic strategy is to use filtered element collectors to collect the relevant data.
* some helper functions are defined in order to collect more complicated metrics that require the use of several element collectors.
* examples: unused elements and redundant elements require helper functions
*/
IList <FailureMessage> warnings = doc.GetWarnings();
IList <Element> linkedRVT = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_RvtLinks).WhereElementIsNotElementType().ToList();
Dictionary <string, IList <Element> > nonRvtLinks = RevitMethods.NonRVTLinkCollector(doc);
IList <Element> linkedCAD = nonRvtLinks[RevitConstants.Strings.linkedCAD];
IList <Element> importedCAD = nonRvtLinks[RevitConstants.Strings.importedCAD];
IList <Element> importedSKP = nonRvtLinks[RevitConstants.Strings.importedSKP];
IList <Element> raster = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_RasterImages).WhereElementIsNotElementType().ToList();
IList <Element> sheets = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Sheets).WhereElementIsNotElementType().ToList();
IList <View> views = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Views).Cast <View>().Where(v => !v.IsTemplate).ToList();
IList <View> unplacedViews = RevitMethods.UnplacedViewCollector(doc, sheets);
IList <Element> modelGroups = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_IOSModelGroups).WhereElementIsNotElementType().ToList();
IList <Element> detailGroups = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_IOSDetailGroups).WhereElementIsNotElementType().ToList();
IList <Family> inPlaceFamilies = new FilteredElementCollector(doc).OfClass(typeof(Family)).Cast <Family>().Where(f => f.IsInPlace).ToList();
IList <Element> designOptionElements = new FilteredElementCollector(doc).WhereElementIsNotElementType().Where(e => e.DesignOption != null).ToList();
IList <Workset> worksets = new FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset).ToList();
IList <Element> rooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().ToList();
IList <SpatialElement> unplacedRooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().Cast <SpatialElement>().Where(r => r.Area == 0 && r.Location == null).ToList();
IList <SpatialElement> redundantRooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().Cast <SpatialElement>().Where(r => r.Area == 0 && r.Location != null).ToList();
IList <Element> redundantElements = RevitMethods.RedundantElementsCollector(warnings, doc);
int unusedElements = unplacedViews.Count + unplacedRooms.Count + RevitMethods.UnusedFamiliesCollector(doc).Count;
// collect model specific information
(string writeDate, string writeTime) = UtilityMethods.FormatDateTime();
(string modelPath, string modelName, string modelSize) = RevitMethods.GetModelInfo(doc);
string versionBuild = app.VersionBuild;
// save collected data in a dictionary
Dictionary <string, object> modelMetrics = new Dictionary <string, object>()
{
{ "Model Name", modelName },
{ "Model Path", modelPath },
{ "Model Size", modelSize },
{ "Warnings", warnings },
{ "Linked RVT Files", linkedRVT },
{ "Linked CAD Files", linkedCAD },
{ "Imported CAD Files", importedCAD },
{ "Imported SKP Files", importedSKP },
{ "Raster Images", raster },
{ "Sheets", sheets },
{ "Views", views },
{ "Unplaced Views", unplacedViews },
{ "Model Groups", modelGroups },
{ "Detail Groups", detailGroups },
{ "In-place Families", inPlaceFamilies },
{ "Elements in Design Options", designOptionElements },
{ "Worksets", worksets },
{ "Rooms", rooms },
{ "Unplaced Rooms", unplacedRooms },
{ "Redundant and Unenclosed Rooms", redundantRooms },
{ "Redundant Elements", redundantElements },
{ "Unused Elements", unusedElements },
{ "Write Date", writeDate },
{ "Write Time", writeTime },
{ "Version Build", versionBuild },
};
return(modelMetrics);
}
