public override void UpdateSender(string args)
{
var client = JsonConvert.DeserializeObject <dynamic>(args);
var index = clients.FindIndex(cl => (string)cl._id == (string)client._id);
clients[index] = client;
var speckleStream = speckleStreams.FirstOrDefault(st => st.StreamId == (string)client.streamId);
speckleStream.Name = (string)client.name;
var request = new Request
{
Operation = Operation.SaveClientState,
Data = JsonConvert.SerializeObject(clients)
};
var response = dataPipeClient.SendRequest(request);
if (response.StatusCode != 200)
{
return;
}
request.Operation = Operation.SaveStreamState;
request.Data = JsonConvert.SerializeObject(speckleStreams);
response = dataPipeClient.SendRequest(request);
ISelectionFilter filter = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(client.filter), GetFilterType(client.filter.Type.ToString()));
GetSelectionFilterObjects(filter, client._id.ToString(), client.streamId.ToString());
}
//--------------------------------------------------------------------------------------------------
public SelectSubshapeAction(object owner, SubshapeTypes subshapeTypes, InteractiveEntity sourceEntity = null, ISelectionFilter selectionFilter = null)
: base(owner)
{
_SubshapeTypes = subshapeTypes;
_SourceEntity = sourceEntity;
_SelectionFilter = selectionFilter;
}
// Useful methods can go here.
//////////////// Pick elements by rectangle with filter /////////////////////////////////////
public IList <Element> PickRectangle(UIDocument uiDoc, ISelectionFilter selFilter, string message)
{
// Change PickElementsByRectangle to PickObject for single select
IList <Element> list = uiDoc.Selection.PickElementsByRectangle(selFilter, message);
return(list);
}
private List <string> GetObjectsFromFilter(ISelectionFilter filter, ISpeckleConverter converter)
{
switch (filter.Slug)
{
case "all":
return(Doc.ConvertibleObjects(converter));
case "layer":
var layerObjs = new List <string>();
foreach (var layerName in filter.Selection)
{
AcadDb.TypedValue[] layerType = new AcadDb.TypedValue[1] {
new AcadDb.TypedValue((int)AcadDb.DxfCode.LayerName, layerName)
};
PromptSelectionResult prompt = Doc.Editor.SelectAll(new SelectionFilter(layerType));
if (prompt.Status == PromptStatus.OK)
{
layerObjs.AddRange(prompt.Value.GetHandles());
}
}
return(layerObjs);
default:
RaiseNotification("Filter type is not supported in this app. Why did the developer implement it in the first place?");
return(new List <string>());
}
}
public void Export(ISelectionFilter selectionFilter, ITimeEntryFilter timeEntryFilter)
{
var entityTransferObject = GetTransferObject(selectionFilter, timeEntryFilter);
_dataService.ExcelExportCompleted += _dataService_ExcelExportCompleted;
_dataService.CreateExcelSheet(entityTransferObject);
}
private List <string> GetObjectsFromFilter(ISelectionFilter filter, ISpeckleConverter converter)
{
var selection = new List <string>();
switch (filter.Slug)
{
case "manual":
return(GetSelectedObjects());
case "all":
return(Doc.ConvertibleObjects(converter));
case "layer":
foreach (var layerName in filter.Selection)
{
TypedValue[] layerType = new TypedValue[1] {
new TypedValue((int)DxfCode.LayerName, layerName)
};
PromptSelectionResult prompt = Doc.Editor.SelectAll(new SelectionFilter(layerType));
if (prompt.Status == PromptStatus.OK)
{
selection.AddRange(prompt.Value.GetHandles());
}
}
return(selection);
}
return(selection);
}
public override void UpdateSender(string args)
{
var client = JsonConvert.DeserializeObject <dynamic>(args);
var index = ClientListWrapper.clients.FindIndex(cl => (string)cl._id == (string)client._id);
ClientListWrapper.clients[index] = client;
var myStream = LocalState.FirstOrDefault(st => st.StreamId == (string)client.streamId);
myStream.Name = (string)client.name;
Queue.Add(new Action(() =>
{
using (Transaction t = new Transaction(CurrentDoc.Document, "Update Speckle Sender"))
{
t.Start();
SpeckleStateManager.WriteState(CurrentDoc.Document, LocalState);
SpeckleClientsStorageManager.WriteClients(CurrentDoc.Document, ClientListWrapper);
t.Commit();
}
}));
Executor.Raise();
ISelectionFilter filter = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(client.filter), GetFilterType(client.filter.Type.ToString()));
GetSelectionFilterObjects(filter, client._id.ToString(), client.streamId.ToString());
SpeckleTelemetry.RecordStreamUpdated("Revit");
}
public override void AddSender(string args)
{
var client = JsonConvert.DeserializeObject <dynamic>(args);
clients.Add(client);
var speckleStream = new SpeckleStream()
{
StreamId = (string)client.streamId, Objects = new List <SpeckleObject>()
};
speckleStreams.Add(speckleStream);
var request = new Request
{
Operation = Operation.SaveClientState,
Data = JsonConvert.SerializeObject(clients)
};
var response = dataPipeClient.SendRequest(request);
if (response.StatusCode != 200)
{
return;
}
request.Operation = Operation.SaveStreamState;
request.Data = JsonConvert.SerializeObject(speckleStreams);
response = dataPipeClient.SendRequest(request);
ISelectionFilter filter = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(client.filter), GetFilterType(client.filter.Type.ToString()));
GetSelectionFilterObjects(filter, client._id.ToString(), client.streamId.ToString());
}
private void ComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
System.Windows.Controls.ComboBox cBox = sender as System.Windows.Controls.ComboBox;
CustomCat ddItem = cBox.SelectedItem as CustomCat;
Category cat = ddItem.cat;
selFilter =
SelFilter.GetElementFilter(
new ElementCategoryFilter(cat.Id));
this.SelectButton.IsEnabled = true;
}
//--------------------------------------------------------------------------------------------------
public SelectSubshapeTool(SubshapeType subshapeType, Shape shape, string id, string statusText,
SelectedFunc selectedFunc, ISelectionFilter selectionFilter = null)
{
_SubshapeType = subshapeType;
_TargetShape = shape;
_TargetBody = shape.Body;
_StatusText = statusText;
_SelectionFilter = selectionFilter;
Id = id;
Debug.Assert(_TargetShape != null);
_SelectedFunc = selectedFunc;
Debug.Assert(_SelectedFunc != null);
}
private ISearchFilterTransferObject GetTransferObject(ISelectionFilter selectionFilter, ITimeEntryFilter timeEntryFilter)
{
var entityTransferObject = new SearchFilterTransferObject();
entityTransferObject.CustomerIds = selectionFilter.Customers.Select(c => c.Id).ToList();
entityTransferObject.ProjectIds = selectionFilter.Projects.Select(p => p.Id).ToList();
entityTransferObject.TaskIds = selectionFilter.Tasks.Select(t => t.Id).ToList();
if (timeEntryFilter != null)
{
entityTransferObject.Users = timeEntryFilter.Users.Select(u => u.Id).ToList();
entityTransferObject.DateFrom = timeEntryFilter.DateFrom;
entityTransferObject.DateTo = timeEntryFilter.DateTo;
}
return(entityTransferObject);
}
private void GetSubTasks(Task parentTask, List <TimeEntry> timeEntries, ISelectionFilter filter)
{
foreach (var subTask in parentTask.SubTasks)
{
if (filter.HasTask(subTask))
{
foreach (var timeEntry in subTask.TimeEntries)
{
if (filter.HasTimeEntry(timeEntry))
{
timeEntries.Add(timeEntry);
}
}
}
GetSubTasks(subTask, timeEntries, filter);
}
}
public override void AddSender(string args)
{
var client = JsonConvert.DeserializeObject <dynamic>(args);
ClientListWrapper.clients.Add(client);
// TODO: Add stream to LocalState (do we actually need to??? hm...).
var myStream = new SpeckleStream()
{
StreamId = (string)client.streamId, Objects = new List <SpeckleObject>()
};
//foreach( dynamic obj in client.objects )
//{
// var SpkObj = new SpeckleObject() { };
// SpkObj.Properties[ "revitUniqueId" ] = obj.id.ToString();
// SpkObj.Properties[ "__type" ] = "Sent Object";
// myStream.Objects.Add( SpkObj );
//}
LocalState.Add(myStream);
Queue.Add(new Action(() =>
{
using (Transaction t = new Transaction(CurrentDoc.Document, "Adding Speckle Sender"))
{
t.Start();
SpeckleStateManager.WriteState(CurrentDoc.Document, LocalState);
SpeckleClientsStorageManager.WriteClients(CurrentDoc.Document, ClientListWrapper);
t.Commit();
}
}));
Executor.Raise();
ISelectionFilter filter = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(client.filter), GetFilterType(client.filter.Type.ToString()));
GetSelectionFilterObjects(filter, client._id.ToString(), client.streamId.ToString());
SpeckleTelemetry.RecordStreamCreated("Revit");
}
public Guid CreateWorkSheet(ISelectionFilter selectionFilter)
{
try
{
var dataSet = CreateXmlData(selectionFilter);
var excelStream = CreateExcelStream(dataSet);
var exportId = Guid.NewGuid();
var serverMapPath = HttpContext.Current.Server.MapPath(_appSettings.ExcelExportPath);
var excelFilePath = string.Concat(serverMapPath, "\\", exportId, ".xls");
using (var fileWriter = new StreamWriter(excelFilePath, false, Encoding.Unicode))
{
fileWriter.Write(excelStream);
}
return(exportId);
}
catch (Exception ex)
{
throw;
}
}
public Result Execute(ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument _uidoc = uiapp.ActiveUIDocument;
Autodesk.Revit.ApplicationServices.Application _app = uiapp.Application;
Autodesk.Revit.DB.Document _doc = _uidoc.Document;
BuiltInCategory bicFamilyA = BuiltInCategory.OST_DuctTerminal;
BuiltInCategory bicFamilyB = BuiltInCategory.OST_DataDevices;
BuiltInCategory bicFamilyC = BuiltInCategory.OST_MechanicalEquipment;
//BuiltInCategory bicFamilyC = BuiltInCategory.OST_Sprinklers;
ICollection <BuiltInCategory> categories = new[] { bicFamilyA, bicFamilyB, bicFamilyC };
ElementFilter myPCatFilter = new ElementMulticategoryFilter(categories);
ISelectionFilter myPickFilter = SelFilter.GetElementFilter(myPCatFilter);
bool keepOnTruckn = true;
FormMsgWPF formMsg = new FormMsgWPF();
formMsg.Show();
using (TransactionGroup pickGrp = new TransactionGroup(_doc)) {
pickGrp.Start("CmdCycleType");
bool firstTime = true;
//string strCats= "";
//foreach (BuiltInCategory iCat in categories) {
// strCats = strCats + iCat.ToString().Replace("OST_", "") + ", ";
//}
string strCats = FamilyUtils.BICListMsg(categories);
formMsg.SetMsg("Pick the " + strCats + " to check its type.", "Type Cycle:");
while (keepOnTruckn)
{
try {
Reference pickedElemRef = _uidoc.Selection.PickObject(ObjectType.Element, myPickFilter, "Pick the " + bicFamilyA.ToString() + " to cycle its types. (Press ESC to cancel)");
Element pickedElem = _doc.GetElement(pickedElemRef.ElementId);
FamilyInstance fi = pickedElem as FamilyInstance;
FamilySymbol fs = fi.Symbol;
var famTypesIds = fs.Family.GetFamilySymbolIds().OrderBy(e => _doc.GetElement(e).Name).ToList();
int thisIndx = famTypesIds.FindIndex(e => e == fs.Id);
int nextIndx = thisIndx;
if (!firstTime)
{
nextIndx = nextIndx + 1;
if (nextIndx >= famTypesIds.Count)
{
nextIndx = 0;
}
}
else
{
firstTime = false;
}
if (pickedElem != null)
{
using (Transaction tp = new Transaction(_doc, "PlunkOMatic:SetParam")) {
tp.Start();
if (pickedElem != null)
{
fi.Symbol = _doc.GetElement(famTypesIds[nextIndx]) as FamilySymbol;
formMsg.SetMsg("Currently:\n" + fi.Symbol.Name + "\n\nPick again to cycle its types.", "Type Cycling");
}
tp.Commit();
}
}
else
{
keepOnTruckn = false;
}
} catch (Exception) {
keepOnTruckn = false;
//throw;
}
}
pickGrp.Assimilate();
}
formMsg.Close();
return(Result.Succeeded);
}
// NOTE: This is actually triggered when clicking "Push!"
// TODO: Orchestration
// Create buckets, send sequentially, notify ui re upload progress
// NOTE: Problems with local context and cache: we seem to not sucesffuly pass through it
// perhaps we're not storing the right sent object (localcontext.addsentobject)
public override void PushSender(string args)
{
var client = JsonConvert.DeserializeObject <dynamic>(args);
//if it's a category or property filter we need to refresh the list of objects
//if it's a selection filter just use the objects that were stored previously
ISelectionFilter filter = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(client.filter), GetFilterType(client.filter.Type.ToString()));
IEnumerable <SpeckleObject> objects = new List <SpeckleObject>();
objects = GetSelectionFilterObjects(filter, client._id.ToString(), client.streamId.ToString());
var apiClient = new SpeckleApiClient((string)client.account.RestApi)
{
AuthToken = (string)client.account.Token
};
var convertedObjects = new List <SpeckleObject>();
var placeholders = new List <SpeckleObject>();
var units = CurrentDoc.Document.GetUnits().GetFormatOptions(UnitType.UT_Length).DisplayUnits.ToString().ToLowerInvariant().Replace("dut_", "");
InjectScaleInKits(GetScale(units)); // this is used for feet to sane units conversion.
int i = 0;
long currentBucketSize = 0;
var errorMsg = "";
var failedToConvert = 0;
var errors = new List <SpeckleError>();
foreach (var obj in objects)
{
NotifyUi("update-client", JsonConvert.SerializeObject(new
{
_id = (string)client._id,
loading = true,
isLoadingIndeterminate = false,
loadingProgress = 1f * i++ / objects.Count() * 100,
loadingBlurb = string.Format("Converting and uploading objects: {0} / {1}", i, objects.Count())
}));
var id = 0;
Element revitElement = null;
try
{
revitElement = CurrentDoc.Document.GetElement((string)obj.Properties["revitUniqueId"]);
id = revitElement.Id.IntegerValue;
}
catch (Exception e)
{
errors.Add(new SpeckleError {
Message = "Could not retrieve element", Details = e.Message
});
continue;
}
try
{
var conversionResult = SpeckleCore.Converter.Serialise(new List <object>()
{
revitElement
});
var byteCount = Converter.getBytes(conversionResult).Length;
currentBucketSize += byteCount;
if (byteCount > 2e6)
{
errors.Add(new SpeckleError {
Message = "Element is too big to be sent", Details = $"Element {id} is bigger than 2MB, it will be skipped"
});
continue;
}
convertedObjects.AddRange(conversionResult);
if (currentBucketSize > 5e5 || i >= objects.Count()) // aim for roughly 500kb uncompressed
{
LocalContext.PruneExistingObjects(convertedObjects, apiClient.BaseUrl);
try
{
var chunkResponse = apiClient.ObjectCreateAsync(convertedObjects).Result.Resources;
int m = 0;
foreach (var objConverted in convertedObjects)
{
objConverted._id = chunkResponse[m++]._id;
placeholders.Add(new SpecklePlaceholder()
{
_id = objConverted._id
});
if (objConverted.Type != "Placeholder")
{
LocalContext.AddSentObject(objConverted, apiClient.BaseUrl);
}
}
}
catch (Exception e)
{
errors.Add(new SpeckleError {
Message = $"Failed to send {convertedObjects.Count} objects", Details = e.Message
});
}
currentBucketSize = 0;
convertedObjects = new List <SpeckleObject>(); // reset the chunkness
}
}
catch (Exception e)
{
failedToConvert++;
errors.Add(new SpeckleError {
Message = $"Failed to convert {revitElement.Name}", Details = $"Element id: {id}"
});
//NotifyUi("update-client", JsonConvert.SerializeObject(new
//{
// _id = (string)client._id,
// errors = "Failed to convert " + failedConvert + " objects."
//}));
}
}
if (errors.Any())
{
if (failedToConvert > 0)
{
errorMsg += string.Format("Failed to convert {0} objects ",
failedToConvert,
failedToConvert == 1 ? "" : "s");
}
else
{
errorMsg += string.Format("There {0} {1} error{2} ",
errors.Count() == 1 ? "is" : "are",
errors.Count(),
errors.Count() == 1 ? "" : "s");
}
errorMsg += "<nobr>" + Globals.GetRandomSadFace() + "</nobr>";
}
var myStream = new SpeckleStream()
{
Objects = placeholders
};
var ug = UnitUtils.GetUnitGroup(UnitType.UT_Length);
var baseProps = new Dictionary <string, object>();
baseProps["units"] = units;
baseProps["unitsDictionary"] = GetAndClearUnitDictionary();
myStream.BaseProperties = baseProps;
//myStream.BaseProperties = JsonConvert.SerializeObject(baseProps);
NotifyUi("update-client", JsonConvert.SerializeObject(new
{
_id = (string)client._id,
loading = true,
isLoadingIndeterminate = true,
loadingBlurb = "Updating stream."
}));
var response = apiClient.StreamUpdateAsync((string)client.streamId, myStream).Result;
var plural = objects.Count() == 1 ? "" : "s";
NotifyUi("update-client", JsonConvert.SerializeObject(new
{
_id = (string)client._id,
loading = false,
loadingBlurb = "",
message = $"Done sending {objects.Count()} object{plural}.",
errorMsg,
errors
}));
SpeckleTelemetry.RecordStreamUpdated("Revit");
}
/// <summary>
/// Given the filter in use by a stream returns the document elements that match it.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
private List <Element> GetSelectionFilterObjects(ISelectionFilter filter)
{
var doc = CurrentDoc.Document;
var selection = new List <Element>();
switch (filter.Name)
{
case "Category":
var catFilter = filter as ListSelectionFilter;
var bics = new List <BuiltInCategory>();
var categories = ConnectorRevitUtils.GetCategories(doc);
IList <ElementFilter> elementFilters = new List <ElementFilter>();
foreach (var cat in catFilter.Selection)
{
elementFilters.Add(new ElementCategoryFilter(categories[cat].Id));
}
var categoryFilter = new LogicalOrFilter(elementFilters);
selection = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.WherePasses(categoryFilter).ToList();
return(selection);
case "View":
var viewFilter = filter as ListSelectionFilter;
var views = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfClass(typeof(View))
.Where(x => viewFilter.Selection.Contains(x.Name));
foreach (var view in views)
{
var ids = selection.Select(x => x.UniqueId);
var viewElements = new FilteredElementCollector(doc, view.Id)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Where(x => !ids.Contains(x.UniqueId)) //exclude elements already added from other views
.ToList();
selection.AddRange(viewElements);
}
return(selection);
case "Project Info":
var projectInfoFilter = filter as ListSelectionFilter;
if (projectInfoFilter.Selection.Contains("Project Info"))
{
selection.Add(doc.ProjectInformation);
}
if (projectInfoFilter.Selection.Contains("Views 2D"))
{
selection.AddRange(new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfCategory(BuiltInCategory.OST_Views)
.Cast <View>()
.Where(x => x.ViewType == ViewType.CeilingPlan ||
x.ViewType == ViewType.FloorPlan ||
x.ViewType == ViewType.Elevation ||
x.ViewType == ViewType.Section)
.ToList());
}
if (projectInfoFilter.Selection.Contains("Views 3D"))
{
selection.AddRange(new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfCategory(BuiltInCategory.OST_Views)
.Cast <View>()
.Where(x => x.ViewType == ViewType.ThreeD)
.ToList());
}
if (projectInfoFilter.Selection.Contains("Levels"))
{
selection.AddRange(new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfCategory(BuiltInCategory.OST_Levels).ToList());
}
if (projectInfoFilter.Selection.Contains("Families & Types"))
{
//get all the elementtypes of the categories we support
var allCategoryFilter = new LogicalOrFilter(ConnectorRevitUtils.GetCategories(doc).Select(x => new ElementCategoryFilter(x.Value.Id)).Cast <ElementFilter>().ToList());
selection.AddRange(new FilteredElementCollector(doc)
.WhereElementIsElementType()
.WherePasses(allCategoryFilter).ToList());
}
return(selection);
case "Parameter":
try
{
var propFilter = filter as PropertySelectionFilter;
var query = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Where(fi => fi.LookupParameter(propFilter.PropertyName) != null);
propFilter.PropertyValue = propFilter.PropertyValue.ToLowerInvariant();
switch (propFilter.PropertyOperator)
{
case "equals":
query = query.Where(fi =>
GetStringValue(fi.LookupParameter(propFilter.PropertyName)) == propFilter.PropertyValue);
break;
case "contains":
query = query.Where(fi =>
GetStringValue(fi.LookupParameter(propFilter.PropertyName)).Contains(propFilter.PropertyValue));
break;
case "is greater than":
query = query.Where(fi => UnitUtils.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName).DisplayUnitType) >
double.Parse(propFilter.PropertyValue));
break;
case "is less than":
query = query.Where(fi => UnitUtils.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName).DisplayUnitType) <
double.Parse(propFilter.PropertyValue));
break;
}
selection = query.ToList();
}
catch (Exception e)
{
Log.CaptureException(e);
}
return(selection);
}
return(selection);
}
/// <summary>
/// Given the filter in use by a stream returns the document elements that match it
/// </summary>
/// <returns></returns>
private IEnumerable <SpeckleObject> GetSelectionFilterObjects(ISelectionFilter filter, string clientId, string streamId)
{
var doc = CurrentDoc.Document;
IEnumerable <SpeckleObject> objects = new List <SpeckleObject>();
var selectionIds = new List <string>();
if (filter.Name == "Selection")
{
var selFilter = filter as ElementsSelectionFilter;
selectionIds = selFilter.Selection;
}
else if (filter.Name == "Category")
{
var catFilter = filter as ListSelectionFilter;
var bics = new List <BuiltInCategory>();
var categories = Globals.GetCategories(doc);
IList <ElementFilter> elementFilters = new List <ElementFilter>();
foreach (var cat in catFilter.Selection)
{
elementFilters.Add(new ElementCategoryFilter(categories[cat].Id));
}
LogicalOrFilter categoryFilter = new LogicalOrFilter(elementFilters);
selectionIds = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.WherePasses(categoryFilter)
.Select(x => x.UniqueId).ToList();
}
else if (filter.Name == "View")
{
var viewFilter = filter as ListSelectionFilter;
var views = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfClass(typeof(View))
.Where(x => viewFilter.Selection.Contains(x.Name));
foreach (var view in views)
{
var ids = new FilteredElementCollector(doc, view.Id)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Select(x => x.UniqueId).ToList();
selectionIds = selectionIds.Union(ids).ToList();
}
}
else if (filter.Name == "Parameter")
{
try
{
var propFilter = filter as PropertySelectionFilter;
var query = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Where(fi => fi.LookupParameter(propFilter.PropertyName) != null);
propFilter.PropertyValue = propFilter.PropertyValue.ToLowerInvariant();
switch (propFilter.PropertyOperator)
{
case "equals":
query = query.Where(fi => GetStringValue(fi.LookupParameter(propFilter.PropertyName)) == propFilter.PropertyValue);
break;
case "contains":
query = query.Where(fi => GetStringValue(fi.LookupParameter(propFilter.PropertyName)).Contains(propFilter.PropertyValue));
break;
case "is greater than":
query = query.Where(fi => UnitUtils.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName).DisplayUnitType) > double.Parse(propFilter.PropertyValue));
break;
case "is less than":
query = query.Where(fi => UnitUtils.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName).DisplayUnitType) < double.Parse(propFilter.PropertyValue));
break;
default:
break;
}
selectionIds = query.Select(x => x.UniqueId).ToList();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
// LOCAL STATE management
objects = selectionIds.Select(id =>
{
var temp = new SpeckleObject();
temp.Properties["revitUniqueId"] = id;
temp.Properties["__type"] = "Sent Object";
return(temp);
});
var myStream = LocalState.FirstOrDefault(st => st.StreamId == streamId);
myStream.Objects.Clear();
myStream.Objects.AddRange(objects);
var myClient = ClientListWrapper.clients.FirstOrDefault(cl => (string)cl._id == (string)clientId);
myClient.objects = JsonConvert.DeserializeObject <dynamic>(JsonConvert.SerializeObject(myStream.Objects));
// Persist state and clients to revit file
Queue.Add(new Action(() =>
{
using (Transaction t = new Transaction(CurrentDoc.Document, "Update local storage"))
{
t.Start();
SpeckleStateManager.WriteState(CurrentDoc.Document, LocalState);
SpeckleClientsStorageManager.WriteClients(CurrentDoc.Document, ClientListWrapper);
t.Commit();
}
}));
Executor.Raise();
var plural = objects.Count() == 1 ? "" : "s";
if (objects.Count() != 0)
{
NotifyUi("update-client", JsonConvert.SerializeObject(new
{
_id = clientId,
expired = true,
objects = myClient.objects,
//message = $"You have added {objects.Count()} object{plural} to this sender."
}));
}
return(objects);
}
/// <summary>
/// constructs a not-Filter
/// </summary>
/// <param name="filter"> </param>
public LogicalNotFilter(ISelectionFilter filter)
{
m_filter = filter;
}
private List <string> GetObjectsFromFilter(ISelectionFilter filter, ISpeckleConverter converter, ProgressViewModel progress)
{
var selection = new List <string>();
switch (filter.Slug)
{
case "all":
return(Model.ConvertibleObjects(converter));
case "level":
foreach (var levelName in filter.Selection)
{
var levelCache = Model.GetFileLevelCache();
var levelHandle = levelCache.GetLevelByName(levelName);
var levelId = levelHandle.LevelId;
var graphicElements = Model.GetGraphicElements();
var elementEnumerator = (ModelElementsEnumerator)graphicElements.GetEnumerator();
var objs = graphicElements.Where(el => el.LevelId == levelId).Select(el => el.ElementId.ToString()).ToList();
selection.AddRange(objs);
}
return(selection);
case "elementType":
foreach (var typeName in filter.Selection)
{
MSElementType selectedType = MSElementType.None;
switch (typeName)
{
case "Arc":
selectedType = MSElementType.Arc;
break;
case "Ellipse":
selectedType = MSElementType.Ellipse;
break;
case "Line":
selectedType = MSElementType.Line;
break;
case "Spline":
selectedType = MSElementType.BsplineCurve;
break;
case "Line String":
selectedType = MSElementType.LineString;
break;
case "Complex Chain":
selectedType = MSElementType.ComplexString;
break;
case "Shape":
selectedType = MSElementType.Shape;
break;
case "Complex Shape":
selectedType = MSElementType.ComplexShape;
break;
case "Mesh":
selectedType = MSElementType.MeshHeader;
break;
case "Surface":
selectedType = MSElementType.BsplineSurface;
break;
default:
break;
}
var graphicElements = Model.GetGraphicElements();
var elementEnumerator = (ModelElementsEnumerator)graphicElements.GetEnumerator();
var objs = graphicElements.Where(el => el.ElementType == selectedType).Select(el => el.ElementId.ToString()).ToList();
selection.AddRange(objs);
}
return(selection);
#if (OPENROADS || OPENRAIL)
case "civilElementType":
foreach (var typeName in filter.Selection)
{
switch (typeName)
{
case "Alignment":
var alignments = GeomModel.Alignments;
if (alignments != null)
{
if (alignments.Count() > 0)
{
selection.Add("Alignment");
}
}
break;
case "Corridor":
var corridors = GeomModel.Corridors;
if (corridors != null)
{
if (corridors.Count() > 0)
{
selection.Add("Corridor");
}
}
break;
default:
break;
}
}
return(selection);
#endif
default:
progress.Report.LogConversionError(new Exception("Filter type is not supported in this app. Why did the developer implement it in the first place?"));
return(selection);
}
}
//--------------------------------------------------------------------------------------------------
public void SetSelectionFilter(ISelectionFilter filter)
{
_SelectionFilter = filter;
_UpdateFilter();
}
public static Result PickObjects(this UIDocument doc, out IList <DB.Reference> reference, ObjectType objectType, ISelectionFilter selectionFilter)
{
return(Pick(out reference, () => doc.Selection.PickObjects(objectType, selectionFilter)));
}
public static Result PickObjects(this UIDocument doc, out IList <DB.Reference> reference, ObjectType objectType, ISelectionFilter selectionFilter, string statusPrompt, IList <DB.Reference> pPreSelected)
{
return(Pick(out reference, () => doc.Selection.PickObjects(objectType, selectionFilter, statusPrompt, pPreSelected)));
}
private List <string> GetSelectionFilterObjects(ISelectionFilter filter)
{
var doc = Model;
var selection = new List <string>();
switch (filter.Slug)
{
case "manual":
return(GetSelectedObjects());
case "all":
if (ConnectorETABSUtils.ObjectIDsTypesAndNames == null)
{
ConnectorETABSUtils.GetObjectIDsTypesAndNames(Model);
}
selection.AddRange(ConnectorETABSUtils.ObjectIDsTypesAndNames
.Select(pair => pair.Key).ToList());
return(selection);
case "type":
var typeFilter = filter as ListSelectionFilter;
if (ConnectorETABSUtils.ObjectIDsTypesAndNames == null)
{
ConnectorETABSUtils.GetObjectIDsTypesAndNames(Model);
}
foreach (var type in typeFilter.Selection)
{
selection.AddRange(ConnectorETABSUtils.ObjectIDsTypesAndNames
.Where(pair => pair.Value.Item1 == type)
.Select(pair => pair.Key)
.ToList());
}
return(selection);
case "group":
//Clear objects first
Model.SelectObj.ClearSelection();
var groupFilter = filter as ListSelectionFilter;
foreach (var group in groupFilter.Selection)
{
Model.SelectObj.Group(group);
}
return(GetSelectedObjects());
/// ETABS doesn't list fields of different objects.
/// For "param" search, maybe search over the name of
/// methods of each type?
//case "param":
// try
// {
// if (ConnectorETABSUtils.ObjectTypes.Count == 0)
// {
// var _ = ConnectorETABSUtils.GetObjectTypesAndNames(Model);
// }
// var propFilter = filter as PropertySelectionFilter;
// var query = new FilteredElementCollector(doc)
// .WhereElementIsNotElementType()
// .WhereElementIsNotElementType()
// .WhereElementIsViewIndependent()
// .Where(x => x.IsPhysicalElement())
// .Where(fi => fi.LookupParameter(propFilter.PropertyName) != null);
// propFilter.PropertyValue = propFilter.PropertyValue.ToLowerInvariant();
// switch (propFilter.PropertyOperator)
// {
// case "equals":
// query = query.Where(fi =>
// GetStringValue(fi.LookupParameter(propFilter.PropertyName)) == propFilter.PropertyValue);
// break;
// case "contains":
// query = query.Where(fi =>
// GetStringValue(fi.LookupParameter(propFilter.PropertyName)).Contains(propFilter.PropertyValue));
// break;
// case "is greater than":
// query = query.Where(fi => RevitVersionHelper.ConvertFromInternalUnits(
// fi.LookupParameter(propFilter.PropertyName).AsDouble(),
// fi.LookupParameter(propFilter.PropertyName)) >
// double.Parse(propFilter.PropertyValue));
// break;
// case "is less than":
// query = query.Where(fi => RevitVersionHelper.ConvertFromInternalUnits(
// fi.LookupParameter(propFilter.PropertyName).AsDouble(),
// fi.LookupParameter(propFilter.PropertyName)) <
// double.Parse(propFilter.PropertyValue));
// break;
// }
// selection = query.ToList();
// }
// catch (Exception e)
// {
// Log.CaptureException(e);
// }
// return selection;
}
return(selection);
}
public static Result PickObject(this UIDocument doc, out DB.Reference reference, ObjectType objectType, ISelectionFilter selectionFilter, string statusPrompt)
{
return(Pick(out reference, () => doc.Selection.PickObject(objectType, selectionFilter, statusPrompt)));
}
private DataSet CreateXmlData(ISelectionFilter filter)
{
var dataSet = new DataSet();
var timeEntries = new List <TimeEntry>();
var customers = filter.Customers;
foreach (var customer in customers)
{
foreach (var project in customer.Projects)
{
if (filter.HasProject(project))
{
foreach (var task in project.Tasks)
{
if (filter.HasTask(task))
{
foreach (var timeEntry in task.TimeEntries)
{
if (filter.HasTimeEntry(timeEntry))
{
timeEntries.Add(timeEntry);
}
}
}
GetSubTasks(task, timeEntries, filter);
}
}
}
}
using (var stream = new StringWriter())
{
using (var writer = new XmlTextWriter(stream))
{
writer.WriteStartDocument(true);
writer.WriteStartElement("data");
foreach (var timeEntry in timeEntries)
{
writer.WriteStartElement("Table");
writer.WriteElementString("StartTime", String.Format("{0} {1}", timeEntry.StartTime.ToShortDateString(), timeEntry.StartTime.ToShortTimeString()));
writer.WriteElementString("EndTime", String.Format("{0} {1}", timeEntry.EndTime.ToShortDateString(), timeEntry.EndTime.ToShortTimeString()));
writer.WriteElementString("Customer", timeEntry.Task.Project.Customer.Name);
writer.WriteElementString("Project", timeEntry.Task.Project.Name);
writer.WriteElementString("Task", timeEntry.Task.Name);
writer.WriteElementString("Consultant", timeEntry.User.Name);
writer.WriteElementString("Billable", timeEntry.Billable.ToString());
writer.WriteElementString("Description", timeEntry.Description);
writer.WriteElementString("Timespent", timeEntry.TimeSpent.ToString("N2"));
writer.WriteElementString("BillableTime", timeEntry.BillableTime.ToString("N2"));
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndDocument();
//stream.Position = 0;
//var xml = System.Text.Encoding.UTF8.GetString(stream.GetBuffer());
var stringReader = new StringReader(stream.ToString());
dataSet.ReadXml(stringReader);
return(dataSet);
}
}
}
/// <summary>
/// Given the filter in use by a stream returns the document elements that match it.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
private List <Element> GetSelectionFilterObjects(ISelectionFilter filter)
{
var doc = CurrentDoc.Document;
var selection = new List <Element>();
switch (filter.Slug)
{
case "all":
selection.AddRange(doc.SupportedElements()); // includes levels
selection.Add(doc.ProjectInformation);
selection.AddRange(doc.Views2D());
selection.AddRange(doc.Views3D());
selection.AddRange(doc.SupportedTypes());
return(selection);
case "category":
var catFilter = filter as ListSelectionFilter;
var bics = new List <BuiltInCategory>();
var categories = ConnectorRevitUtils.GetCategories(doc);
IList <ElementFilter> elementFilters = new List <ElementFilter>();
foreach (var cat in catFilter.Selection)
{
elementFilters.Add(new ElementCategoryFilter(categories[cat].Id));
}
var categoryFilter = new LogicalOrFilter(elementFilters);
selection = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.WherePasses(categoryFilter).ToList();
return(selection);
case "view":
var viewFilter = filter as ListSelectionFilter;
var views = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfClass(typeof(View))
.Where(x => viewFilter.Selection.Contains(x.Name));
foreach (var view in views)
{
var ids = selection.Select(x => x.UniqueId);
var viewElements = new FilteredElementCollector(doc, view.Id)
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Where(x => !ids.Contains(x.UniqueId)) //exclude elements already added from other views
.ToList();
selection.AddRange(viewElements);
}
return(selection);
case "project-info":
var projectInfoFilter = filter as ListSelectionFilter;
if (projectInfoFilter.Selection.Contains("Project Info"))
{
selection.Add(doc.ProjectInformation);
}
if (projectInfoFilter.Selection.Contains("Views 2D"))
{
selection.AddRange(doc.Views2D());
}
if (projectInfoFilter.Selection.Contains("Views 3D"))
{
selection.AddRange(doc.Views3D());
}
if (projectInfoFilter.Selection.Contains("Levels"))
{
selection.AddRange(doc.Levels());
}
if (projectInfoFilter.Selection.Contains("Families & Types"))
{
selection.AddRange(doc.SupportedTypes());
}
return(selection);
case "param":
try
{
var propFilter = filter as PropertySelectionFilter;
var query = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.WhereElementIsNotElementType()
.WhereElementIsViewIndependent()
.Where(x => x.IsPhysicalElement())
.Where(fi => fi.LookupParameter(propFilter.PropertyName) != null);
propFilter.PropertyValue = propFilter.PropertyValue.ToLowerInvariant();
switch (propFilter.PropertyOperator)
{
case "equals":
query = query.Where(fi =>
GetStringValue(fi.LookupParameter(propFilter.PropertyName)) == propFilter.PropertyValue);
break;
case "contains":
query = query.Where(fi =>
GetStringValue(fi.LookupParameter(propFilter.PropertyName)).Contains(propFilter.PropertyValue));
break;
case "is greater than":
query = query.Where(fi => RevitVersionHelper.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName)) >
double.Parse(propFilter.PropertyValue));
break;
case "is less than":
query = query.Where(fi => RevitVersionHelper.ConvertFromInternalUnits(
fi.LookupParameter(propFilter.PropertyName).AsDouble(),
fi.LookupParameter(propFilter.PropertyName)) <
double.Parse(propFilter.PropertyValue));
break;
}
selection = query.ToList();
}
catch (Exception e)
{
Log.CaptureException(e);
}
return(selection);
}
return(selection);
}
public Result Execute(ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument _uidoc = uiapp.ActiveUIDocument;
Autodesk.Revit.ApplicationServices.Application _app = uiapp.Application;
Autodesk.Revit.DB.Document _doc = _uidoc.Document;
string parmTogN = "SHOW SYM";
BuiltInCategory bicFamily = BuiltInCategory.OST_DataDevices;
BuiltInCategory bicFamilyTag = BuiltInCategory.OST_DataDeviceTags;
ICollection <BuiltInCategory> categories = new[] { bicFamily, bicFamilyTag };
ElementFilter myPCatFilter = new ElementMulticategoryFilter(categories);
ISelectionFilter myPickFilter = SelFilter.GetElementFilter(myPCatFilter);
bool keepOnTruckn = true;
FormMsgWPF formMsgWPF = new FormMsgWPF();
formMsgWPF.Show();
while (keepOnTruckn)
{
try {
formMsgWPF.SetMsg("Pick the Sensor to toggle symbol visibility.", "Sensor Symbol Toggle");
Reference pickedElemRef = _uidoc.Selection.PickObject(ObjectType.Element, myPickFilter, "Pick the Sensor to toggle symbol visibility. (Press ESC to cancel)");
Element pickedElem = _doc.GetElement(pickedElemRef.ElementId);
// get tagged element instead if user picked the tag
if (pickedElem.GetType() == typeof(IndependentTag))
{
IndependentTag _tag = (IndependentTag)pickedElem;
pickedElem = _doc.GetElement(_tag.TaggedLocalElementId);
}
if (pickedElem != null)
{
Transaction tp = new Transaction(_doc, "PlunkOMatic:SetParam");
tp.Start();
//TaskDialog.Show("Debug", pickedElem.ToString());
if (pickedElem != null)
{
Parameter parForTog = pickedElem.LookupParameter(parmTogN);
if (null != parForTog)
{
if (parForTog.AsInteger() == 1)
{
parForTog.Set(0);
}
else
{
parForTog.Set(1);
}
}
}
tp.Commit();
}
else
{
keepOnTruckn = false;
}
} catch (Exception) {
keepOnTruckn = false;
//throw;
}
}
formMsgWPF.Close();
return(Result.Succeeded);
}
public Result Execute(ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument _uidoc = uiapp.ActiveUIDocument;
Autodesk.Revit.ApplicationServices.Application _app = uiapp.Application;
Autodesk.Revit.DB.Document _doc = _uidoc.Document;
PlunkOClass plunkThis = new PlunkOClass(commandData.Application);
string wsName = "MECH HVAC";
string FamilyName = "M_BAS SENSOR";
string FamilySymbolName = "THERMOSTAT";
string pName = "STAT ZONE NUMBER";
string FamilyTagName = "M_EQIP_BAS_SENSOR_TAG";
string FamilyTagNameSymb = "SENSOR";
bool oneShot = true;
bool hasLeader = false;
BuiltInCategory bicTagBeing = BuiltInCategory.OST_MechanicalEquipmentTags;
BuiltInCategory bicFamily = BuiltInCategory.OST_DataDevices;
BuiltInCategory _bicMechItem = BuiltInCategory.OST_MechanicalEquipment;
Element elemPlunked;
bool keepOnTruckn = true;
while (keepOnTruckn)
{
try {
Result result = plunkThis.PlunkThisFamilyType(FamilyName, FamilySymbolName, wsName, bicFamily, out elemPlunked, oneShot);
FormMsgWPF formMsg = new FormMsgWPF();
if ((result == Result.Succeeded) & (elemPlunked != null))
{
formMsg.Show();
formMsg.SetMsg("Now Select the Mech Unit for this sensor.", "Sensor For MEQ");
Transaction tp = new Transaction(_doc, "PlunkOMatic:OrientGuts ");
tp.Start();
plunkThis.OrientTheInsides(elemPlunked);
tp.Commit();
ICollection <BuiltInCategory> categories = new[] { _bicMechItem };
ElementFilter myPCatFilter = new ElementMulticategoryFilter(categories);
ISelectionFilter myPickFilter = SelFilter.GetElementFilter(myPCatFilter);
try {
Reference pickedElemRef = _uidoc.Selection.PickObject(ObjectType.Element, myPickFilter, "Select the Mech Unit for this sensor.");
Element pickedElem = _doc.GetElement(pickedElemRef.ElementId);
formMsg.SetMsg("Now place the unit text at the sensor.", "Sensor For MEQ");
plunkThis.AddThisTag(pickedElem, FamilyTagName, FamilyTagNameSymb, pName, bicTagBeing, hasLeader);
formMsg.Close();
} catch (Exception) {
formMsg.Close();
keepOnTruckn = false;
//throw;
}
}
else
{
formMsg.Close();
keepOnTruckn = false;
}
} catch (Autodesk.Revit.Exceptions.OperationCanceledException) {
keepOnTruckn = false;
// TaskDialog.Show("Where", "here " );
}
}
return(Result.Succeeded);
}
public Result Execute(ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument _uidoc = uiapp.ActiveUIDocument;
Autodesk.Revit.ApplicationServices.Application _app = uiapp.Application;
Autodesk.Revit.DB.Document _doc = _uidoc.Document;
PlunkOClass plunkThis = new PlunkOClass(commandData.Application);
string wsName = "MECH HVAC";
string FamilyName = "M_BAS SENSOR";
string FamilySymbolName = "THERMOSTAT";
string FamilyTagName = "M_EQIP_BAS_SENSOR_TAG";
string FamilyTagNameSymb = "TAG NUMBER ONLY";
string FamilyTagName2 = "M_DEVICE_BAS_TAG_SYM";
string FamilyTagNameSymb2 = "M-DATA-SENSOR";
bool hasLeader = false;
bool oneShot = true;
BuiltInCategory bicTagBeing = BuiltInCategory.OST_MechanicalEquipmentTags;
BuiltInCategory bicTagBeing2 = BuiltInCategory.OST_DataDeviceTags;
BuiltInCategory bicFamily = BuiltInCategory.OST_DataDevices;
BuiltInCategory bicMechItem = BuiltInCategory.OST_MechanicalEquipment;
Element elemPlunked;
bool keepOnTruckn = true;
while (keepOnTruckn)
{
try {
Result result = plunkThis.PlunkThisFamilyType(FamilyName, FamilySymbolName, wsName, bicFamily, out elemPlunked, oneShot);
FormMsgWPF formMsg = new FormMsgWPF();
if ((result == Result.Succeeded) & (elemPlunked != null))
{
plunkThis.AddThisTag(elemPlunked, FamilyTagName2, FamilyTagNameSymb2, "Offset Stat", bicTagBeing2, true);
formMsg.Show();
formMsg.SetMsg("Now Select the Mech Unit for this sensor.", "Offset Sensor For MEQ");
Transaction tp = new Transaction(_doc, "PlunkOMatic:SymVis");
tp.Start();
Parameter parForVis = elemPlunked.LookupParameter("SHOW SYM");
if (null != parForVis)
{
parForVis.Set(0);
}
plunkThis.OrientTheInsides(elemPlunked); // left in in case type is changed later
tp.Commit();
ICollection <BuiltInCategory> categories = new[] { bicMechItem };
ElementFilter myPCatFilter = new ElementMulticategoryFilter(categories);
ISelectionFilter myPickFilter = SelFilter.GetElementFilter(myPCatFilter);
try {
Reference pickedElemRef = _uidoc.Selection.PickObject(ObjectType.Element, myPickFilter, "Select the Mech Unit for this sensor.");
Element pickedElem = _doc.GetElement(pickedElemRef.ElementId);
formMsg.SetMsg("Now place the unit text at the sensor.", "Offset Sensor For MEQ");
plunkThis.AddThisTag(pickedElem, FamilyTagName, FamilyTagNameSymb, "Offset Stat", bicTagBeing, hasLeader);
formMsg.Close();
} catch (Exception) {
formMsg.Close();
keepOnTruckn = false;
//throw;
}
}
else
{
formMsg.Close();
keepOnTruckn = false;
}
} catch (Exception) {
keepOnTruckn = false;
//throw;
}
}
return(Result.Succeeded);
}
