public static void LoadWSOFile(string filePath, MainViewModel viewModel)
{
// Load user's current options and make a copy.
BuildModel(viewModel, false);
IVisitorWithContext visitor = new XmlReadVisitor();
UIOptionRootType optionsRoot = new UIOptionRootType();
optionsRoot.Accept(visitor, filePath);
foreach (var cat in optionsRoot.Categories)
{
foreach (var subCat in cat.SubCategories)
{
foreach (var opt in subCat.Options)
{
if (opt is UIOptionGroupType)
{
LoadGroup(viewModel, opt);
}
IOption targetOpt = viewModel.FindOption(opt.Name);
if (targetOpt != null)
{
LoadOption(targetOpt, opt);
}
}
}
}
// We need to pass the OptionsRoot object to somebody who can display it in UI
}
void IVisitor.Visit(UIOptionRootType optionsRoot)
{
foreach (UIOptionCategoryType category in optionsRoot.Categories)
{
category.Accept(this);
}
}
/// <summary>
///
/// </summary>
/// <param name="optionsRoot">The options root object</param>
/// <param name="context">The file name for XML Document</param>
void IVisitorWithContext.Visit(UIOptionRootType optionsRoot, object context)
{
XmlDocument xmlDoc = new XmlDocument();
Stream stream = context as Stream;
if (stream == null)
{
xmlDoc.Load((string) context);
}
else
{
xmlDoc.Load(stream);
}
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("ws", "http://schemas.workshare.com/Workshare.OptionMap.xsd");
string xpath = "ws:OptionMap/ws:Category";
XmlNodeList categories = xmlDoc.SelectNodes(xpath, nsmgr);
foreach (XmlNode node in categories)
{
UIOptionCategoryType category = new UIOptionCategoryType();
optionsRoot.Categories.Add(category);
category.Accept(this, node);
}
}
public void Visit(UIOptionRootType optionsRoot, object context)
{
MainViewModel vwModel = context as MainViewModel;
for (int i = optionsRoot.Categories.Count - 1; i >= 0; i--)
{
Category vwCat = (from cat in vwModel.Categories
where cat.Name.Equals(optionsRoot.Categories[i].Name, StringComparison.InvariantCultureIgnoreCase)
select cat).FirstOrDefault();
if (vwCat == null) // option category doesn't exist in ViewModel
{
if (_bTrimUnchanged)
{
optionsRoot.Categories.RemoveAt(i);
}
continue;
}
else
{
optionsRoot.Categories[i].Accept(this, vwCat);
}
if (_bTrimUnchanged && optionsRoot.Categories[i].SubCategories.Count == 0)
{
optionsRoot.Categories.RemoveAt(i);
}
}
}
public static UIOptionRootType ReadTestXML()
{
IVisitorWithContext readVisitor = new DefaultXmlReadVisitor();
UIOptionRootType optionsRoot = new UIOptionRootType();
readVisitor.Visit(optionsRoot, _testFilePath);
return optionsRoot;
}
private void VisitRootInternal(UIOptionRootType optionsRoot)
{
//Create the Workshare Category
_admFileWriter.StartWorkshareCategory();
foreach (UIOptionCategoryType category in optionsRoot.Categories)
{
category.Accept(this);
}
_admFileWriter.EndWorkshareCategory();
}
/// <summary>
/// Load option model from default xml
/// </summary>
/// <param name = "optRoot"></param>
public static UIOptionRootType DefaultXmlToOptionModel()
{
IVisitorWithContext readVisitor = new DefaultXmlReadVisitor();
UIOptionRootType optionsRoot = new UIOptionRootType();
using (Stream s = GetDefaultXml())
{
optionsRoot.Accept(readVisitor, s);
}
return optionsRoot;
}
/// <summary>
///
/// </summary>
/// <param name="optionsRoot">The root object</param>
/// <param name="context">File path for the generated XML document</param>
void IVisitorWithContext.Visit(UIOptionRootType optionsRoot, object context)
{
_xmlDoc.RemoveAll();
XmlNode rootNode = _xmlDoc.CreateNode(XmlNodeType.Element, "OptionsRoot", this._namespaceURI);
foreach (UIOptionCategoryType category in optionsRoot.Categories)
{
category.Accept(this, rootNode);
}
_xmlDoc.AppendChild(rootNode);
_xmlDoc.Save((string) context);
}
/// <summary>
///
/// </summary>
/// <param name="optionsRoot">The options root object</param>
/// <param name="context">The file name for XML Document</param>
void IVisitorWithContext.Visit(UIOptionRootType optionsRoot, object context)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load((string) context);
XmlNode rootNode = xmlDoc.SelectSingleNode("OptionsRoot");
foreach (XmlNode node in rootNode.ChildNodes)
{
UIOptionCategoryType category = new UIOptionCategoryType();
optionsRoot.Categories.Add(category);
category.Accept(this, node);
}
}
void IVisitor.Visit(UIOptionRootType optionsRoot)
{
if (this._registryTarget == RegistryTargetEnum.HKLM || this._registryTarget == RegistryTargetEnum.Both)
{
_localRegistryTarget = RegistryTargetEnum.HKLM;
VisitRootInternal(optionsRoot);
}
if (this._registryTarget == RegistryTargetEnum.HKCU || this._registryTarget == RegistryTargetEnum.Both)
{
_localRegistryTarget = RegistryTargetEnum.HKCU;
VisitRootInternal(optionsRoot);
}
this._regFileWriter.Flush();
}
void IVisitor.Visit(UIOptionRootType optionsRoot)
{
try
{
OptionApi.AdminEnter();
using (UserReadVisitor uservisitor = new UserReadVisitor())
{
optionsRoot.Accept(uservisitor);
}
}
finally
{
OptionApi.AdminExit();
}
}
public void MergeDefaults(UIOptionRootType defaultOptions)
{
foreach (UIOptionCategoryType defaultCat in defaultOptions.Categories)
{
UIOptionCategoryType existingCat = Categories.Find(cat => defaultCat.Name == cat.Name);
if (existingCat != null)
{
existingCat.MergeDefaults(defaultCat);
}
else
{
Categories.Add(defaultCat);
}
}
// remove all categories we have loaded that aren't in the default options...
Categories.RemoveAll(cat => defaultOptions.Categories.Find(dcat => dcat.Name == cat.Name) == null);
}
void IVisitor.Visit(UIOptionRootType optionsRoot)
{
if (this._registryTarget == RegistryTargetEnum.HKLM || this._registryTarget == RegistryTargetEnum.Both)
{
this._localRegistryTarget = RegistryTargetEnum.HKLM;
_admFileWriter.WriteHKLMHeader();
VisitRootInternal(optionsRoot);
}
if (this._registryTarget == RegistryTargetEnum.HKCU || this._registryTarget == RegistryTargetEnum.Both)
{
this._localRegistryTarget = RegistryTargetEnum.HKCU;
_admFileWriter.WriteHKCUHeader();
VisitRootInternal(optionsRoot);
}
this._admFileWriter.Flush();
//this._admFileWriter.Dispose();
}
public void TestXmlReader()
{
IVisitorWithContext readVisitor = new XmlReadVisitor();
UIOptionRootType optionsRoot = new UIOptionRootType();
optionsRoot.Accept(readVisitor, _xmlInputPath);
Assert.AreEqual(3, optionsRoot.Categories.Count);
Assert.AreEqual(3, optionsRoot.Categories[0].SubCategories.Count);
Assert.AreEqual(3, optionsRoot.Categories[1].SubCategories.Count);
Assert.AreEqual(3, optionsRoot.Categories[2].SubCategories.Count);
Assert.AreEqual(24, optionsRoot.Categories[0].SubCategories[0].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[0].SubCategories[1].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[0].SubCategories[2].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[1].SubCategories[0].Options.Count);
Assert.AreEqual(3, optionsRoot.Categories[1].SubCategories[1].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[1].SubCategories[2].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[2].SubCategories[0].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[2].SubCategories[1].Options.Count);
Assert.AreEqual(4, optionsRoot.Categories[2].SubCategories[2].Options.Count);
}
public void TestDefaultXmlReader_FromStream()
{
IVisitorWithContext readVisitor = new DefaultXmlReadVisitor();
UIOptionRootType optionsRoot = new UIOptionRootType();
Stream stream = File.OpenRead(_testFilePath);
optionsRoot.Accept(readVisitor, stream);
Assert.AreEqual(3, optionsRoot.Categories.Count);
Assert.AreEqual(3, optionsRoot.Categories[0].SubCategories.Count);
Assert.AreEqual(3, optionsRoot.Categories[1].SubCategories.Count);
Assert.AreEqual(3, optionsRoot.Categories[2].SubCategories.Count);
Assert.AreEqual(24, optionsRoot.Categories[0].SubCategories[0].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[0].SubCategories[1].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[0].SubCategories[2].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[1].SubCategories[0].Options.Count);
Assert.AreEqual(3, optionsRoot.Categories[1].SubCategories[1].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[1].SubCategories[2].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[2].SubCategories[0].Options.Count);
Assert.AreEqual(2, optionsRoot.Categories[2].SubCategories[1].Options.Count);
Assert.AreEqual(4, optionsRoot.Categories[2].SubCategories[2].Options.Count);
}
private static void FilterReviewCategories(UIOptionRootType optionsRoot)
{
string[] reviewCategories = new string[] { "Review" };
if (!EnabledFeatures.ReviewEnabled)
{
DeleteCategoriesBasedOnFilter(optionsRoot, reviewCategories);
}
}
private static void DeleteOptionFromOptionsRoot(UIOptionRootType optionRoot, OptionBaseType option)
{
UIOptionCategoryType cat = optionRoot.Categories.Find(a => a.Name == option.CategoryRef);
if (cat != null)
{
UIOptionSubCategoryType subcat = cat.SubCategories.Find(b => b.Name == option.SubCategoryRef);
if (subcat != null)
{
int index = GetOptionIndexInSubCategory(subcat, option.Name);
if (index != -1)
{
subcat.Options.RemoveAt(index);
}
}
}
}
private static void FilterCompareCategories(UIOptionRootType optionsRoot)
{
string[] compareCategories = new string[] { "Compare" };
if (!EnabledFeatures.CompareEnabled)
{
DeleteCategoriesBasedOnFilter(optionsRoot, compareCategories);
}
}
private static void FilterProtectCategories(UIOptionRootType optionsRoot)
{
string[] protectCategories = new string[] { "Protect" };
if (!EnabledFeatures.SecurityEnabled)
{
DeleteCategoriesBasedOnFilter(optionsRoot, protectCategories);
}
else
{
UIOptionCategoryType ProtectCategory = optionsRoot.Categories.Find(a => a.Name == "Protect");
if (ProtectCategory == null)
return;
FilterSecureFileTransfer(ProtectCategory);
}
}
internal static void UpdateOptionModelWithCurrent(UIOptionRootType optionsRoot, bool bAdmin)
{
OptionMapper mapper = new OptionMapper(optionsRoot);
mapper.UpdateOptionModelWithCurrent(bAdmin);
}
// This is used only to update the 'internal' sub category onto the viewModel with the internalSubCategory
internal static void UpdateInternalSubCategory(MainViewModel viewModel, UIOptionRootType optionsRoot,
UIOptionSubCategoryType internalSubCategory)
{
if ((internalSubCategory == null) || (internalSubCategory.Name != "Internal"))
{
return;
}
OptionMapper mapper = new OptionMapper(optionsRoot);
UIOptionCategoryType internalCat = optionsRoot.Categories.Find(cat => cat.Name == "Internal");
mapper.UpdateInternalSubCategory(viewModel, internalCat, internalSubCategory);
}
private static void FilterDMS(UIOptionRootType optionsRoot)
{
UIOptionCategoryType dmsCategory = optionsRoot.Categories.Find(a => a.Name == "DMS");
if (dmsCategory == null)
return;
FilterHummingbird(dmsCategory);
FilterInterwoven(dmsCategory);
FilterSharePoint(dmsCategory);
FilterNetDocuments(dmsCategory);
}
internal static void OptionModelToUIModel(MainViewModel viewModel, UIOptionRootType optionsRoot)
{
OptionMapper mapper = new OptionMapper(optionsRoot);
mapper.OptionModelToUIModel(viewModel);
}
public OptionMapper(UIOptionRootType optionsRoot)
{
_optionsRoot = optionsRoot;
}
public static void UIModelToOptionModel(UIOptionRootType optionsRoot, MainViewModel model, bool bTrimUnchanged,
bool bDeploymentIconOnly = false)
{
IVisitorWithContext ctxVisitor = new ViewModelToOptionModelVisitor(bTrimUnchanged, bDeploymentIconOnly);
optionsRoot.Accept(ctxVisitor, model);
}
public OptionMapper()
{
_optionsRoot = DefaultXmlToOptionModel();
}
public void Visit(UIOptionRootType optionsRoot)
{
throw new NotImplementedException();
}
private static void DeleteCategoriesBasedOnFilter(UIOptionRootType optionsRoot, string[] categoriesFilter)
{
foreach (string catname in categoriesFilter)
{
optionsRoot.Categories.RemoveAt(optionsRoot.Categories.FindIndex(a => a.Name == catname));
}
}
private void VisitRootInternal(UIOptionRootType optionsRoot)
{
this._regFileWriter.WriteHeader();
foreach (UIOptionCategoryType category in optionsRoot.Categories)
{
category.Accept(this);
}
}
private static void FilterCategories(UIOptionRootType optionsRoot)
{
FilterCompareCategories(optionsRoot);
FilterProtectCategories(optionsRoot);
FilterReviewCategories(optionsRoot);
FilterDMS(optionsRoot);
}
