/// <summary>
/// 创建工作集
/// </summary>
/// <param name="doc">当前文档</param>
/// <param name="worksetName">输入工作集名称</param>
/// <returns>新的工作集</returns>
public Workset CreateWorksets(Document doc, string worksetName)
{
Workset newWorksets = null;
if (WorksetTable.IsWorksetNameUnique(doc, worksetName))
{
using (Transaction trans = new Transaction(doc, "创建工作集"))
{
trans.Start();
newWorksets = Workset.Create(doc, worksetName);
trans.Commit();
}
}
//判定是否有重名的工作集
else
{
FilteredWorksetCollector worksetCollector = new FilteredWorksetCollector(doc);
IList <Workset> worksetsList = worksetCollector.OfKind(WorksetKind.UserWorkset).ToWorksets();
foreach (Workset workset in worksetsList)
{
if (workset.Name.Contains(worksetName))
{
return(workset);
}
}
}
return(newWorksets);
}
public static Workset GetOrCreateWorkset(Document doc, string worksetName)
{
IList <Workset> userWorksets = new FilteredWorksetCollector(doc)
.OfKind(WorksetKind.UserWorkset)
.ToWorksets();
bool checkNotExists = WorksetTable.IsWorksetNameUnique(doc, worksetName);
if (!checkNotExists)
{
Debug.WriteLine("Workset exists: " + worksetName);
Workset wset = new FilteredWorksetCollector(doc)
.OfKind(WorksetKind.UserWorkset)
.ToWorksets()
.Where(w => w.Name == worksetName)
.First();
return(wset);
}
else
{
Debug.WriteLine("Create workset: " + worksetName);
Workset wset = Workset.Create(doc, worksetName);
return(wset);
}
}
/// <summary>
/// Determines whether a given name is already used in the document.
/// </summary>
/// <param name="name">A workset name</param>
/// <returns name="bool">True if workset name is unique in the document, false if already used.</returns>
public static bool IsWorksetNameUnique(string name)
{
//Get Revit Document object
revitDoc doc = DocumentManager.Instance.CurrentDBDocument;
return(WorksetTable.IsWorksetNameUnique(doc, name));
}
private static Workset GetWorkSet(Document doc)
{
Workset workSet = null;
if (doc.IsWorkshared)
{
string workSetName = "WorkSetName";
if (WorksetTable.IsWorksetNameUnique(doc, workSetName))
{
using (Transaction tran = new Transaction(doc, "[ToolSet] Create Work Set For ToolSet"))
{
tran.Start();
workSet = Workset.Create(doc, workSetName);
tran.Commit();
}
}
else
{
IList <Workset> list = new FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset).ToWorksets();
foreach (var item in list)
{
if (item.Name.Contains(workSetName))
{
return(item);
}
}
}
}
return(workSet);
}
public static IDictionary ByName(
string name,
[DefaultArgument("true")] bool visible,
[DefaultArgument("\"\"")] string alias
)
{
//Get Revit Document object
revitDoc doc = DocumentManager.Instance.CurrentDBDocument;
Workset workset = null;
bool created = false;
//Only create workset if it's name isn't an empty string
if (name != null && name != "")
{
//Verify that each workset isn't already in the document
//If the workset is unique, create it
if (WorksetTable.IsWorksetNameUnique(doc, name))
{
//If the alias is already in the document
if (alias != null && WorksetTable.IsWorksetNameUnique(doc, alias) == false)
{
workset = GetByName(alias);
Rename(workset, name);
created = true;
}
else
{
using (Autodesk.Revit.DB.Transaction trans = new Autodesk.Revit.DB.Transaction(doc))
{
trans.Start("Create Workset");
workset = new Workset(doc, revitWorkset.Create(doc, name));
trans.Commit();
}
SetDefaultVisibility(workset, visible);
created = true;
}
}
// If the workset is already in the document, retrieve the workset
else
{
workset = GetByName(name);
created = false;
}
}
return(new Dictionary <string, object>
{
{ "workset", workset },
{ "created", created }
});
}
public static List <string> GetUsedNames(Document CurrentDoc, List <string> SelectedWorksets)
{
List <string> usedNames = new List <string>();
foreach (string s in SelectedWorksets)
{
if (!WorksetTable.IsWorksetNameUnique(CurrentDoc, s))
{
usedNames.Add(s);
}
}
return(usedNames);
}
private void button1_Click(object sender, EventArgs e)
{
if (selectedWorksetNames.Count == 0)
{
TaskDialog.Show("Error", "No worksets selected.");
return;
}
// Document doc = extCommandData.Application.ActiveUIDocument.Document;
using (Transaction t = new Transaction(doc, "Making Worksets"))
{
try
{
t.Start();
// Workset workset1 = new FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset).Where(w => w.Name == "Workset1").FirstOrDefault();
// WorksetId workset1Id = workset1?.Id;
for (int i = 0; i < selectedWorksetNames.Count; i++)
{
if (WorksetTable.IsWorksetNameUnique(doc, selectedWorksetNames[i].ToString()))
{
/*
* if (i == 0 && workset1Id != null)
* {
* WorksetTable.RenameWorkset(doc, workset1Id, selectedWorksetNames[i].ToString());
* }
* else
* {
* Workset.Create(doc, selectedWorksetNames[i].ToString());
* }
*/
Workset.Create(doc, selectedWorksetNames[i].ToString());
}
else
{
TaskDialog.Show("Error", $"Duplicate workset name already exists in project: {selectedWorksetNames[i]}");
}
}
t.Commit();
TaskDialog.Show("Success", $"{selectedWorksetNames.Count} worksets created.");
}
catch (Exception error)
{
t.RollBack();
TaskDialog.Show("Error", error.ToString());
}
}
this.Close();
}
public static void ApplyWorksetModifications(Document doc, List <WorksetParameter> worksets, ref TransactionLog log)
{
using (Transaction t = new Transaction(doc))
{
if (t.Start("Add Worksets to Model.") == TransactionStatus.Started)
{
foreach (var w in worksets)
{
if (w.IsModified)
{
if (w.IsExisting && w.Id >= 0)
{
if (WorksetTable.IsWorksetNameUnique(doc, w.Name))
{
WorksetTable.RenameWorkset(doc, new WorksetId(w.Id), w.Name);
}
var defaultVisibilitySettings = WorksetDefaultVisibilitySettings.GetWorksetDefaultVisibilitySettings(doc);
defaultVisibilitySettings.SetWorksetVisibility(new WorksetId(w.Id), w.VisibleInAllViews);
log.AddSuccess(w.ToString());
}
else
{
Workset newWorkset = null;
if (WorksetTable.IsWorksetNameUnique(doc, w.Name))
{
newWorkset = Workset.Create(doc, w.Name);
}
else
{
log.AddFailure(w.ToString());
continue;
}
if (newWorkset != null)
{
var defaultVisibilitySettings = WorksetDefaultVisibilitySettings.GetWorksetDefaultVisibilitySettings(doc);
defaultVisibilitySettings.SetWorksetVisibility(newWorkset.Id, w.VisibleInAllViews);
log.AddSuccess(w.ToString());
}
}
}
}
t.Commit();
}
}
}
/// <summary>
/// 创建工作集
/// </summary>
/// <param name="doc"></param>
/// <returns></returns>
public Workset CreateWorkset(Document doc)
{
Workset workset = null;
if (doc.IsWorkshared)
{
string worksetName = "New Workset";
if (WorksetTable.IsWorksetNameUnique(doc, worksetName))
{
using (Transaction worksetTransaction = new Transaction(doc, "Set preview view id"))
{
worksetTransaction.Start();
workset = Workset.Create(doc, worksetName);
worksetTransaction.Commit();
}
}
}
return(workset);
}
private Workset CreateWorkset(Document document)
{
Workset newWorkset = null;
// Worksets can only be created in a document with worksharing enabled
if (document.IsWorkshared)
{
string worksetName = "Workset4";
string worksetName1 = "Workset5";
string worksetName2 = "Workset6";
// Workset name must not be in use by another workset
if (WorksetTable.IsWorksetNameUnique(document, worksetName))
{
using (Transaction worksetTransaction = new Transaction(document, "Set preview view id"))
{
worksetTransaction.Start();
newWorkset = Workset.Create(document, worksetName);
worksetTransaction.Commit();
}
}
if (WorksetTable.IsWorksetNameUnique(document, worksetName1))
{
using (Transaction worksetTransaction = new Transaction(document, "Set preview view id"))
{
worksetTransaction.Start();
newWorkset = Workset.Create(document, worksetName1);
worksetTransaction.Commit();
}
}
if (WorksetTable.IsWorksetNameUnique(document, worksetName2))
{
using (Transaction worksetTransaction = new Transaction(document, "Set preview view id"))
{
worksetTransaction.Start();
newWorkset = Workset.Create(document, worksetName2);
worksetTransaction.Commit();
}
}
}
return(newWorkset);
}
public static IDictionary Rename(Workset workset, string name)
{
//Get Revit Document object
revitDoc doc = DocumentManager.Instance.CurrentDBDocument;
Workset renamedWorkset = null;
bool renamed = false;
if (name != null && workset != null)
{
//Verify that the existing workset is in the document.
//If the workset is unique, create it
if (WorksetTable.IsWorksetNameUnique(doc, workset.internalWorkset.Name) == false)
{
// Verify that the new name doesn't already exist
if (WorksetTable.IsWorksetNameUnique(doc, name) == true)
{
//Only rename workset if it's name isn't an empty string
if (name != "")
{
using (Autodesk.Revit.DB.Transaction trans = new Autodesk.Revit.DB.Transaction(doc))
{
trans.Start("Rename Workset");
WorksetTable.RenameWorkset(doc, workset.internalId, name);
workset.internalName = workset.internalWorkset.Name;
renamedWorkset = workset;
renamed = true;
trans.Commit();
}
}
}
}
}
return(new Dictionary <string, object>
{
{ "workset", renamedWorkset },
{ "renamed", renamed }
});
}
public Workset GetWorkset(Document doc)
{
IList <Workset> userWorksets = new FilteredWorksetCollector(doc)
.OfKind(WorksetKind.UserWorkset)
.ToWorksets();
bool checkNotExists = WorksetTable.IsWorksetNameUnique(doc, WorksetName);
if (!checkNotExists)
{
Workset wset = new FilteredWorksetCollector(doc)
.OfKind(WorksetKind.UserWorkset)
.ToWorksets()
.Where(w => w.Name == WorksetName)
.First();
return(wset);
}
else
{
Workset wset = Workset.Create(doc, WorksetName);
return(wset);
}
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
Document doc = commandData.Application.ActiveUIDocument.Document;
if (!doc.IsWorkshared)
{
message = "Файл не является файлом совместной работы";
return(Result.Failed);;
}
//считываю список рабочих наборов
string dllPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string folder = System.IO.Path.GetDirectoryName(dllPath);
System.Windows.Forms.OpenFileDialog dialog = new System.Windows.Forms.OpenFileDialog();
dialog.InitialDirectory = folder;
dialog.Multiselect = false;
dialog.Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*";
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return(Result.Cancelled);
}
string xmlFilePath = dialog.FileName;
InfosStorage storage = new InfosStorage();
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(typeof(InfosStorage));
using (StreamReader r = new StreamReader(xmlFilePath))
{
storage = (InfosStorage)serializer.Deserialize(r);
}
if (storage.LinkedFilesPrefix == null)
{
storage.LinkedFilesPrefix = "#";
}
using (Transaction t = new Transaction(doc))
{
t.Start("Создание рабочих наборов");
//назначаю рабочие наборы в случае, если указана категория
foreach (WorksetByCategory wb in storage.worksetsByCategory)
{
Workset wset = wb.GetWorkset(doc);
List <BuiltInCategory> cats = wb.revitCategories;
if (cats == null)
{
continue;
}
if (cats.Count == 0)
{
continue;
}
foreach (BuiltInCategory bic in cats)
{
List <Element> elems = new FilteredElementCollector(doc)
.OfCategory(bic)
.WhereElementIsNotElementType()
.ToElements()
.ToList();
foreach (Element elem in elems)
{
WorksetBy.SetWorkset(elem, wset);
}
}
}
//назначаю рабочие наборы по именам семейств
List <FamilyInstance> famIns = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.OfClass(typeof(FamilyInstance))
.Cast <FamilyInstance>()
.ToList();
foreach (WorksetByFamily wb in storage.worksetsByFamily)
{
Workset wset = wb.GetWorkset(doc);
List <string> families = wb.FamilyNames;
if (families == null)
{
continue;
}
if (families.Count == 0)
{
continue;
}
foreach (string familyName in families)
{
List <FamilyInstance> curFamIns = famIns
.Where(f => f.Symbol.FamilyName.StartsWith(familyName))
.ToList();
foreach (FamilyInstance fi in curFamIns)
{
WorksetBy.SetWorkset(fi, wset);
}
}
}
//назначаю рабочие наборы по именам типов
List <Element> allElems = new FilteredElementCollector(doc)
.WhereElementIsNotElementType()
.Cast <Element>()
.ToList();
foreach (WorksetByType wb in storage.worksetsByType)
{
Workset wset = wb.GetWorkset(doc);
List <string> typeNames = wb.TypeNames;
if (typeNames == null)
{
continue;
}
if (typeNames.Count == 0)
{
continue;
}
foreach (string typeName in typeNames)
{
foreach (Element elem in allElems)
{
ElementId typeId = elem.GetTypeId();
if (typeId == null || typeId == ElementId.InvalidElementId)
{
continue;
}
ElementType elemType = doc.GetElement(typeId) as ElementType;
if (elemType == null)
{
continue;
}
if (elemType.Name.StartsWith(typeName))
{
WorksetBy.SetWorkset(elem, wset);
}
}
}
}
//назначаю рабочие наборы по значению параметров
foreach (WorksetByParameter wb in storage.worksetsByParameter)
{
Workset wset = wb.GetWorkset(doc);
string paramName = wb.ParameterName;
string paramValue = wb.ParameterValue;
List <Element> elemsFilterByParam = allElems
.Where(e => e.LookupParameter(paramName).AsString().Equals(paramValue)).ToList();
foreach (Element elem in elemsFilterByParam)
{
WorksetBy.SetWorkset(elem, wset);
}
}
//назначаю рабочие наборы для связанных файлов
List <RevitLinkInstance> links = new FilteredElementCollector(doc)
.OfClass(typeof(RevitLinkInstance))
.Cast <RevitLinkInstance>()
.ToList();
foreach (RevitLinkInstance rli in links)
{
RevitLinkType linkFileType = doc.GetElement(rli.GetTypeId()) as RevitLinkType;
if (linkFileType == null)
{
continue;
}
if (linkFileType.IsNestedLink)
{
continue;
}
string linkWorksetName1 = rli.Name.Split(':')[0];
string linkWorksetName2 = linkWorksetName1.Substring(0, linkWorksetName1.Length - 5);
string linkWorksetName = storage.LinkedFilesPrefix + linkWorksetName2;
bool checkExists = WorksetTable.IsWorksetNameUnique(doc, linkWorksetName);
if (!checkExists)
{
continue;
}
Workset.Create(doc, linkWorksetName);
Workset linkWorkset = new FilteredWorksetCollector(doc)
.OfKind(WorksetKind.UserWorkset)
.ToWorksets()
.Where(w => w.Name == linkWorksetName)
.First();
WorksetBy.SetWorkset(rli, linkWorkset);
WorksetBy.SetWorkset(linkFileType, linkWorkset);
}
t.Commit();
}
List <string> emptyWorksetsNames = WorksetTool.GetEmptyWorksets(doc);
if (emptyWorksetsNames.Count > 0)
{
string msg = "Обнаружены пустые рабочие наборы! Их можно удалить вручную:\n";
foreach (string s in emptyWorksetsNames)
{
msg += s + "\n";
}
TaskDialog.Show("Отчёт", msg);
}
return(Result.Succeeded);
}
