private XElement CreateSanityCheckingCells(Core.WorkbookModel n)
{
var root = new XElement("sanityCheckingCells");
foreach (var cell in n.SanityCheckingCells)
{
root.Add(new XElement("location", NullCheck(new CellLocation(DataModel.Instance.CurrentWorkbook.Workbook, cell.Location).Location)));
}
return(root);
}
private XElement CreateOutputCells(Core.WorkbookModel n)
{
var root = new XElement("outputCells");
foreach (var cell in n.OutputCells)
{
var cellElement = new XElement("outputCell");
cellElement.Add(new XElement("name", NullCheck(new CellLocation(DataModel.Instance.CurrentWorkbook.Workbook, cell.Location).ShortLocation)));
}
return(root);
}
private string GetDocumentProperty(Core.WorkbookModel n, string propertyName)
{
var properties = (Microsoft.Office.Core.DocumentProperties)n.Workbook.BuiltinDocumentProperties;
string value;
try
{
value = properties[propertyName].Value.ToString();
}
catch (Exception e)
{
value = String.Empty;
Console.WriteLine(e.Message);
}
return(value);
}
public object Visit(Core.WorkbookModel n)
{
var root = new XElement("SIF.Scenario");
root.Add(new XAttribute("Title", NullCheck(n.Title)));
root.Add(new XAttribute("Spreadsheet", NullCheck(n.Spreadsheet)));
root.Add(new XAttribute("PolicyPath", NullCheck(n.PolicyPath)));
//save scenarios
foreach (var scen in n.Scenarios)
{
if (scen != null)
{
root.Add(scen.Accept(this) as XElement);
}
}
return(root);
}
public object Visit(Core.WorkbookModel n)
{
if (this.root == null)
{
return(false);
}
foreach (var scenarioElement in root.Elements())
{
if (scenarioElement.Name != "Scenario")
{
continue;
}
var newScenario = new Scenario();
newScenario.Accept(new XMLToScenarioVisitor(scenarioElement));
n.Scenarios.Add(newScenario);
}
return(true);
}
private XElement CreateSanityRules(Core.WorkbookModel n)
{
var root = new XElement("sanityRules");
XElement checking = CreateSanityCheckingCells(n);
if (!checking.HasElements)
{
return(null);
}
root.Add(checking);
root.Add(CreateSanityValueCells(n));
root.Add(CreateSanityConstraintCells(n));
root.Add(CreateSanityExplanationCells(n));
root.Add(new XElement("sanityWarnings", n.SanityWarnings));
return(root);
}
public XMLToCellDefinitionVisitor(XElement root, Core.WorkbookModel wb)
{
this.root = root;
this.wb = wb;
}
public object Visit(Core.WorkbookModel n)
{
if (root == null)
{
return(false);
}
//get input cells
var inputCellsElement = root.Element(XName.Get("inputCells"));
if (inputCellsElement != null)
{
foreach (var c in inputCellsElement.Elements())
{
var inputCell = new Core.Cell();
inputCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.InputCells.Add(inputCell.ToInputCell());
}
}
//get intermediate cells
var intermediateCellsElement = root.Element(XName.Get("intermediateCells"));
if (intermediateCellsElement != null)
{
foreach (var c in intermediateCellsElement.Elements())
{
var intermediateCell = new Core.Cell();
intermediateCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.IntermediateCells.Add(intermediateCell.ToIntermediateCell());
}
}
//get result cells
var resultCellsElement = root.Element(XName.Get("resultCells"));
if (resultCellsElement != null)
{
foreach (var c in resultCellsElement.Elements())
{
var resultCell = new Core.Cell();
resultCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.OutputCells.Add(resultCell.ToOutputCell());
}
}
//get sanity value cells
var sanityValueCellsElement = root.Element(XName.Get("sanityValueCells"));
if (sanityValueCellsElement != null)
{
foreach (var c in sanityValueCellsElement.Elements())
{
var sanityValueCell = new Core.Cell();
sanityValueCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.SanityValueCells.Add(sanityValueCell.ToSanityValueCell());
}
}
//get sanity value cells
var sanityConstraintCellsElement = root.Element(XName.Get("sanityConstraintCells"));
if (sanityConstraintCellsElement != null)
{
foreach (var c in sanityConstraintCellsElement.Elements())
{
var sanityConstraintCell = new Core.Cell();
sanityConstraintCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.SanityConstraintCells.Add(sanityConstraintCell.ToSanityConstraintCell());
}
}
//get sanity Explanation cells
var sanityExplanationCellsElement = root.Element(XName.Get("sanityExplanationCells"));
if (sanityExplanationCellsElement != null)
{
foreach (var c in sanityExplanationCellsElement.Elements())
{
var sanityExplanationCell = new Core.Cell();
sanityExplanationCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.SanityExplanationCells.Add(sanityExplanationCell.ToSanityExplanationCell());
}
}
//get sanity Checking cells
var sanityCheckingCellsElement = root.Element(XName.Get("sanityCheckingCells"));
if (sanityCheckingCellsElement != null)
{
foreach (var c in sanityCheckingCellsElement.Elements())
{
var sanityCheckingCell = new Core.Cell();
sanityCheckingCell.Accept(new XMLToCellDefinitionVisitor(c, n));
n.SanityCheckingCells.Add(sanityCheckingCell.ToSanityCheckingCell());
}
}
return(true);
}
public XMLToCellDefinitionVisitor(XElement root, Core.WorkbookModel wb)
{
this.root = root;
this.wb = wb;
}
public void Start(Core.WorkbookModel wb)
{
if (this.newScenario != null)
{
return;
}
lock (syncScenario)
{
if (this.newScenario != null)
{
return;
}
this.newScenario = new Scenario()
{
Title = "Untiteled Scenario - " + DateTime.Now.ToString(),
CrationDate = DateTime.Now,
Author = this.GetDocumentProperty(wb, "Last Author")
};
}
this.workbook = wb.Workbook;
var workingList = wb.InputCells.Union(wb.IntermediateCells).Union(wb.OutputCells).ToList();
//sort working list column first
#region sort
workingList.Sort(delegate(Core.Cell x, Core.Cell y)
{
//sort by worksheet
var xSheet = workbook.Sheets[Cells.CellManager.Instance.ParseWorksheetName(x.Location)] as Worksheet;
var ySheet = workbook.Sheets[Cells.CellManager.Instance.ParseWorksheetName(x.Location)] as Worksheet;
if (xSheet.Index < ySheet.Index)
{
return(-1);
}
else if (xSheet.Index > ySheet.Index)
{
return(1);
}
else
{
//sort by column
var xRange = xSheet.Range[Cells.CellManager.Instance.ParseCellLocation(x.Location)];
var yRange = ySheet.Range[Cells.CellManager.Instance.ParseCellLocation(y.Location)];
if (xRange.Column < yRange.Column)
{
return(-1);
}
else if (xRange.Column > yRange.Column)
{
return(1);
}
else
{
//sort by row
if (xRange.Row < yRange.Row)
{
return(-1);
}
else if (xRange.Row > yRange.Row)
{
return(1);
}
else
{
return(0);
}
}
}
});
#endregion
CreateScenarioDataFieldContainer containerFirst = null;
CreateScenarioDataFieldContainer containerBefore = null;
foreach (var c in workingList)
{
//create cell data
CellData cellData;
#region create cell data
if (c is Cells.InputCell)
{
cellData = new InputCellData();
cellData.Location = c.Location;
cellData.SifLocation = c.SifLocation;
newScenario.Inputs.Add(cellData as InputCellData);
}
else if (c is Cells.IntermediateCell)
{
cellData = new IntermediateCellData();
cellData.Location = c.Location;
cellData.SifLocation = c.SifLocation;
newScenario.Intermediates.Add(cellData as IntermediateCellData);
}
else if (c is Cells.OutputCell)
{
cellData = new ResultCellData();
cellData.Location = c.Location;
cellData.SifLocation = c.SifLocation;
newScenario.Results.Add(cellData as ResultCellData);
}
else
{
//abort
lock (syncScenario)
{
//clear this object
this.containers.Clear();
this.workbook = null;
this.newScenario = null;
return;
}
}
#endregion
//get worksheet
var currentWorksheet = workbook.Sheets[Cells.CellManager.Instance.ParseWorksheetName(c.Location)] as Worksheet;
var vsto = Globals.Factory.GetVstoObject(currentWorksheet);
//create container
var container = new CreateScenarioDataFieldContainer();
container.createScenarioDataField.DataContext = cellData;
containers.Add(container);
//register for focus handling
#region focus handling
if (c == workingList.First())
{
containerFirst = container;
}
else if (containerBefore != null)
{
containerBefore.createScenarioDataField.RegisterNextFocusField(container.createScenarioDataField);
}
containerBefore = container;
#endregion
//create control
var control = vsto.Controls.AddControl(
container,
currentWorksheet.Range[Cells.CellManager.Instance.ParseCellLocation(c.Location)],
Guid.NewGuid().ToString());
control.Placement = Microsoft.Office.Interop.Excel.XlPlacement.xlMove;
}
//set focus to first control
if (containerFirst != null)
{
containerFirst.createScenarioDataField.SetFocus();
}
}
/// <summary>
/// Create the sprudel xml document
/// </summary>
/// <param name="n">WorkbookModel</param>
/// <returns>complete sprudel xml as XElement</returns>
public object Visit(Core.WorkbookModel n)
{
PolicyConfigurationModel settings = n.PolicySettings;
var root = new XElement("policyList");
var dynamicPolicy = new XElement("dynamicPolicy");
//attributes
dynamicPolicy.Add(new XAttribute("name", NullCheck(n.Title) + " Inspection"));
dynamicPolicy.Add(new XAttribute("description", this.GetDocumentProperty(n, "Comments")));
dynamicPolicy.Add(new XAttribute("author", this.GetDocumentProperty(n, "Author")));
//rules
var rules = new XElement("rules");
foreach (var scenario in n.Scenarios)
{
rules.Add(scenario.Accept(this) as XElement);
}
dynamicPolicy.Add(rules);
//spreadsheet file path
dynamicPolicy.Add(new XElement("spreadsheetFilePath", NullCheck(n.Spreadsheet)));
//input cells
dynamicPolicy.Add(CreateInputCells(n));
//output cells
dynamicPolicy.Add(CreateOutputCells(n));
// TODO: don't add when no scenario is present
root.Add(dynamicPolicy);
XElement sanityRules = CreateSanityRules(n);
if (sanityRules != null)
{
root.Add(sanityRules);
}
if ((settings.ReadingDirection && type == InspectionType.MANUAL) ||
(settings.ReadingDirection && settings.ReadingDirectionAutomatic))
{
XElement readingDirection = createReadingDirection();
root.Add(readingDirection);
}
if ((settings.NoConstantsInFormulas && type == InspectionType.MANUAL) ||
(settings.NoConstantsInFormulas && settings.NoConstantsInFormulasAutomatic))
{
XElement constants = createNoConstants();
root.Add(constants);
}
if ((settings.FormulaComplexity && type == InspectionType.MANUAL) ||
(settings.FormulaComplexity && settings.FormulaComplexityAutomatic))
{
XElement formulaComplexity = createFormulaComplexity();
root.Add(formulaComplexity);
}
if ((settings.NonConsideredConstants && type == InspectionType.MANUAL) ||
(settings.NonConsideredConstants && settings.NonConsideredConstantsAutomatic))
{
XElement nonConsidered = createNonConsideredValues();
root.Add(nonConsidered);
}
if ((settings.OneAmongOthers && type == InspectionType.MANUAL) ||
(settings.OneAmongOthers && settings.OneAmongOthersAutomatic))
{
XElement oneAmongOthers = createOneAmongOthers();
root.Add(oneAmongOthers);
}
if ((settings.RefToNull && type == InspectionType.MANUAL) ||
(settings.RefToNull && settings.RefToNullAutomatic))
{
XElement refToNull = createRefToNull();
root.Add(refToNull);
}
if ((settings.StringDistance && type == InspectionType.MANUAL) ||
(settings.StringDistance && settings.StringDistanceAutomatic))
{
XElement stringDistance = createStringDistance(settings);
root.Add(stringDistance);
}
if ((settings.MultipleSameRef && type == InspectionType.MANUAL) ||
(settings.MultipleSameRef && settings.MultipleSameRefAutomatic))
{
XElement msr = createMultipleSameRef();
root.Add(msr);
}
if ((settings.ErrorInCells && type == InspectionType.MANUAL) ||
(settings.ErrorInCells && settings.ErrorInCellsAutomatic))
{
XElement eic = createErrorInCells();
root.Add(eic);
}
return(root);
}
public object Visit(Core.WorkbookModel n)
{
var root = new XElement("cellDefinitions");
//input cells
var inputElement = new XElement("inputCells");
foreach (var c in n.InputCells)
{
inputElement.Add(c.Accept(this));
}
root.Add(inputElement);
//intermediate cells
var intermediateElement = new XElement("intermediateCells");
foreach (var c in n.IntermediateCells)
{
intermediateElement.Add(c.Accept(this));
}
root.Add(intermediateElement);
//result cells
var resultElement = new XElement("resultCells");
foreach (var c in n.OutputCells)
{
resultElement.Add(c.Accept(this));
}
root.Add(resultElement);
var sanityValueElement = new XElement("sanityValueCells");
foreach (var c in n.SanityValueCells)
{
sanityValueElement.Add(c.Accept(this));
}
root.Add(sanityValueElement);
var sanityConstraintElement = new XElement("sanityConstraintCells");
foreach (var c in n.SanityConstraintCells)
{
sanityConstraintElement.Add(c.Accept(this));
}
root.Add(sanityConstraintElement);
var sanityExplanationElement = new XElement("sanityExplanationCells");
foreach (var c in n.SanityExplanationCells)
{
sanityExplanationElement.Add(c.Accept(this));
}
root.Add(sanityExplanationElement);
var sanityCheckingElement = new XElement("sanityCheckingCells");
foreach (var c in n.SanityCheckingCells)
{
sanityCheckingElement.Add(c.Accept(this));
}
root.Add(sanityCheckingElement);
root.Add(resultElement);
return(root);
}
