public static ExcelBindingDefinitionWithFormula CreateInstance(ExcelTemplateDefinition templateDefinition, BindingDefinitionDescription definition)
{
try
{
IBindingDefinition formulaBindingDefinition = null;
IBindingDefinition targetBindingDefinition = null;
if (!string.IsNullOrEmpty(definition.Formula))
{
BindingDefinitionDescription formulaBindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinition, definition.Formula, definition.Formula);
formulaBindingDefinition = BindingDefinitionFactory.CreateInstances(templateDefinition, formulaBindingDefinitionDescription);
}
if (!string.IsNullOrEmpty(definition.BindingExpression))
{
string bindingExpression = $"{{{definition.BindingExpression}}}";
BindingDefinitionDescription targetBindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinition, bindingExpression, bindingExpression);
targetBindingDefinition = BindingDefinitionFactory.CreateInstances(templateDefinition, targetBindingDefinitionDescription);
}
ExcelBindingDefinitionWithFormula ret = new ExcelBindingDefinitionWithFormula(definition, targetBindingDefinition, formulaBindingDefinition);
return(ret);
}
catch (Exception ex)
{
string message = $"Cannot create the 'ExcelBindingDefinitionWithFormula' from '{definition.BindingExpression ?? string.Empty}'. {ex.Message}";
throw new EtkException(message);
}
}
public ModelLeafProperty(IModelType parent, IBindingDefinition bindingDefinition)
{
Parent = parent;
BindingDefinition = bindingDefinition;
Name = BindingDefinition.Name;
Description = BindingDefinition.Description;
}
public ExcelContextItemButton(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
CanNotify = bindingDefinition?.CanNotify ?? false;
excelBindingDefinitionButton = bindingDefinition as ExcelBindingDefinitionButton;
if (CanNotify)
{
objectsToNotify = excelBindingDefinitionButton.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
if (excelBindingDefinitionButton.EnablePropertyInfo != null)
{
EnablePropertyGet = excelBindingDefinitionButton.EnablePropertyInfo.GetGetMethod();
if (EnablePropertyGet != null)
{
if (!EnablePropertyGet.IsStatic)
{
if (ParentElement.DataSource != null && ParentElement.DataSource is INotifyPropertyChanged)
{
EnableProperty = (INotifyPropertyChanged)ParentElement.DataSource;
EnableProperty.PropertyChanged += OnPropertyChanged;
}
}
}
}
}
public static ExcelBindingDefinitionNamedRange CreateInstance(ExcelTemplateDefinitionPart templateDefinition, ExcelNamedRangeDefinition definition, IBindingDefinition nestedBindingDefinition)
{
try
{
string trimmedName = definition.Name.Trim();
IBindingDefinition nameBindingDefinition = null;
string rootName = null;
int pos = trimmedName.IndexOf('{');
if (pos != -1)
{
rootName = trimmedName.Remove(pos);
string expression = trimmedName.Substring(pos);
BindingDefinitionDescription bindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinition.Parent, expression, expression);
if (bindingDefinitionDescription != null && !string.IsNullOrEmpty(bindingDefinitionDescription.BindingExpression))
{
if (bindingDefinitionDescription.BindingExpression.Contains(ALL_POS_KEYWORD) || bindingDefinitionDescription.BindingExpression.Contains(POS_KEYWORD))
{
throw new ArgumentException($"Cannot mixte the keywords '{POS_KEYWORD}' and '{ALL_POS_KEYWORD}' with binding dataAccessor");
}
nameBindingDefinition = BindingDefinitionFactory.CreateInstances(templateDefinition.Parent as ExcelTemplateDefinition, bindingDefinitionDescription);
}
}
return(new ExcelBindingDefinitionNamedRange(definition, rootName, nestedBindingDefinition, nameBindingDefinition));
}
catch (Exception ex)
{
string message = $"Cannot create create the named caller binding dataAccessor '{definition.Name}'. {ex.Message}";
throw new EtkException(message);
}
}
public BindingContextItem(IBindingContextElement parent, IBindingDefinition bindingDefinition)
{
ParentElement = parent;
BindingDefinition = bindingDefinition;
CanNotify = false;
Name = BindingDefinition == null ? string.Empty : BindingDefinition.Name;
}
public FilterOnConditions(ITemplateDefinition templateDefinition, IBindingDefinition definition, string condition, FilterDefinitionRelation relation, bool caseSensitive)
{
TemplateDefinition = templateDefinition;
DefinitionToFilter = definition;
Condition = condition;
Relation = relation;
CaseSensitive = caseSensitive;
}
public SortDefinition(ITemplateDefinition templateDefinition, IBindingDefinition bindingDefinition, bool descending, bool caseSensitive)
{
TemplateDefinition = templateDefinition;
BindingDefinition = bindingDefinition;
Descending = descending;
CaseSensitive = caseSensitive;
SetExpression();
}
private ExcelBindingDefinitionFormulaResult(BindingDefinitionDescription bindingDefinitionDescription, IBindingDefinition underlyingBindingDefinition, IBindingDefinition useFormulaBindingDefinition)
: base(bindingDefinitionDescription)
{
NestedBindingDefinition = underlyingBindingDefinition;
UseFormulaBindingDefinition = useFormulaBindingDefinition;
CanNotify = underlyingBindingDefinition.CanNotify;
DefinitionDescription = new BindingDefinitionDescription();
}
protected void AddAfterRenderingAction(IBindingDefinition bindingDefinition, ExcelInterop.Range concernedRange)
{
if (bindingDefinition.OnAfterRendering?.Parameters != null)
{
foreach (SpecificEventCallbackParameter param in bindingDefinition.OnAfterRendering.Parameters.Where(p => p.IsSender))
{
param.ParameterValue = concernedRange;
}
}
Parent.AddAfterRenderingAction(bindingDefinition.OnAfterRendering);
}
public FilterOnValues(ITemplateDefinition templateDefinition, IBindingDefinition definition, IEnumerable <object> selectedValues, bool useOrEquals)
{
TemplateDefinition = templateDefinition;
DefinitionToFilter = definition;
SelectedValues = selectedValues;
UseOrEquals = useOrEquals;
if (selectedValues != null && selectedValues.Any())
{
SetFilterExpression();
}
}
private ExcelBindingDefinitionWithFormula(BindingDefinitionDescription bindingDefinitionDescription, IBindingDefinition targetBindingDefinition, IBindingDefinition formulaBindingDefinition)
: base(bindingDefinitionDescription)
{
TargetBindingDefinition = targetBindingDefinition;
FormulaBindingDefinition = formulaBindingDefinition;
if (TargetBindingDefinition != null)
{
CanNotify = TargetBindingDefinition.CanNotify;
}
DefinitionDescription = new BindingDefinitionDescription();
}
public BindingContextItemCanNotify(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
CanNotify = true;
objectsToNotify = bindingDefinition.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
public override IBindingContextItem ContextItemFactory(IBindingContextElement parent)
{
BindingContextItem ret;
if (parent.DataSource == null)
{
ret = new BindingContextItem(parent, this);
}
else
{
IBindingDefinition realBindingDefinition = CreateRealBindingDefinition(parent.DataSource.GetType());
ret = realBindingDefinition.CanNotify ? new BindingContextItemCanNotify(parent, realBindingDefinition)
: new BindingContextItem(parent, realBindingDefinition);
}
ret.Init();
return(ret);
}
/// <summary> Create a list of binding definition for a given list of <see cref="BindingDefinitionDescription"/> </summary>
internal static List <IBindingDefinition> CreateInstances(Type type, List <BindingDefinitionDescription> definitionDescriptions)
{
List <IBindingDefinition> bindingDefinitions = new List <IBindingDefinition>();
if (definitionDescriptions != null)
{
foreach (BindingDefinitionDescription definitionDescription in definitionDescriptions)
{
IBindingDefinition bindingDefinition = CreateInstance(type, definitionDescription);
if (bindingDefinition != null)
{
bindingDefinitions.Add(bindingDefinition);
}
}
}
return(bindingDefinitions);
}
public BindingDefinitionViewModel(TemplateViewModel parent, IBindingDefinition bindingDefinition, IEnumerable <IBindingContextItem> items)
{
this.parent = parent;
BindingDefinition = bindingDefinition;
this.items = items.ToList();
if (items.Any())
{
ValueSelectionList = this.items.Select(i => i.ResolveBinding())
.Distinct()
.Select(v => new ValueSelection(v))
.OrderBy(s => s.Value)
.ToList();
}
SortOrFilterSelected += OnSortOrFilterSelected;
}
/// <summary>Create a binding definition from a cell value</summary>
private IBindingDefinition CreateBindingDefinition(ExcelTemplateDefinitionPart templateDefinitionPart, string value, string trimmedValue)
{
ExcelTemplateDefinition excelTemplateDefinition = templateDefinitionPart.Parent as ExcelTemplateDefinition;
IBindingDefinition ret = null;
if (trimmedValue.StartsWith(ExcelBindingDefinitionButton.BUTTON_TEMPLATE_PREFIX))
{
ret = ExcelBindingDefinitionButton.CreateInstance(excelTemplateDefinition, trimmedValue);
}
else if (trimmedValue.StartsWith(ExcelBindingDefinitionCheckBox.CHECKBOX_TEMPLATE_PREFIX))
{
ret = ExcelBindingDefinitionCheckBox.CreateInstance(excelTemplateDefinition, trimmedValue);
}
else if (trimmedValue.StartsWith(ExcelBindingDefinitionFormulaResult.FORMULA_RESULT_PREFIX))
{
ret = ExcelBindingDefinitionFormulaResult.CreateInstance(excelTemplateDefinition, trimmedValue);
}
else if (trimmedValue.StartsWith(ExcelBindingDefinitionNamedRange.NAMEDRANGE_TEMPLATE_PREFIX))
{
ExcelNamedRangeDefinition excelNamedRangeDefinition = ExcelBindingDefinitionNamedRange.RetrieveNamedRangeDefinition(trimmedValue);
if (excelNamedRangeDefinition != null)
{
BindingDefinition nestedBindingDefinition = null;
if (!string.IsNullOrEmpty(excelNamedRangeDefinition.Value))
{
nestedBindingDefinition = CreateBindingDefinition(templateDefinitionPart, excelNamedRangeDefinition.Value, excelNamedRangeDefinition.Value.Trim()) as BindingDefinition;
}
ret = ExcelBindingDefinitionNamedRange.CreateInstance(templateDefinitionPart, excelNamedRangeDefinition, nestedBindingDefinition);
}
}
else
{
BindingDefinitionDescription bindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinitionPart.Parent, value, trimmedValue);
if (bindingDefinitionDescription.Formula != null)
{
ret = ExcelBindingDefinitionWithFormula.CreateInstance(excelTemplateDefinition, bindingDefinitionDescription);
}
else
{
ret = BindingDefinitionFactory.CreateInstances(excelTemplateDefinition, bindingDefinitionDescription);
}
}
return(ret);
}
/// <summary> Create a binding definition for a given <see cref="BindingDefinitionDescription"/> owned by a given <see cref="FilterOwner"/> </summary>
/// <param name="templateDefinition">The <see cref="FilterOwner"/> that owned the <see cref="BindingDefinitionDescription"/></param>
/// <param name="bindingDefinitionDescription">the given <see cref="BindingDefinitionDescription"/></param>
/// <returns>The newly created Binding definition or an exception is an error occurs</returns>
public static IBindingDefinition CreateInstances(TemplateDefinition templateDefinition, BindingDefinitionDescription bindingDefinitionDescription)
{
IBindingDefinition ret = null;
if (templateDefinition != null && bindingDefinitionDescription != null)
{
if (bindingDefinitionDescription.IsConst)
{
ret = BindingDefinitionConstante.CreateInstance(bindingDefinitionDescription);
}
else
{
Type type = templateDefinition.MainBindingDefinition?.BindingType;
ret = CreateInstance(type, bindingDefinitionDescription);
}
}
return(ret);
}
private ExcelBindingDefinitionNamedRange(ExcelNamedRangeDefinition definition, string rootName, IBindingDefinition nestedBindingDefinition, IBindingDefinition nameBindingDefinition)
{
NestedBindingDefinition = nestedBindingDefinition;
this.definition = definition;
this.rootName = rootName;
this.nameBindingDefinition = nameBindingDefinition;
if (nameBindingDefinition == null)
{
if (definition.Name.Contains(POS_KEYWORD))
{
usePos = true;
}
if (definition.Name.Contains(ALL_POS_KEYWORD))
{
useAllPos = true;
}
}
}
public static ExcelBindingDefinitionFormulaResult CreateInstance(ExcelTemplateDefinition templateDefinition, string definition)
{
try
{
definition = definition.Replace(FORMULA_RESULT_PREFIX, string.Empty);
definition = definition.TrimEnd('}');
//UseFormulaBindingDefinition
string[] parts = definition.Split(';');
if (parts.Count() > 2)
{
throw new ArgumentException($"dataAccessor '{definition}' is invalid.");
}
string useFormulaDefinition = null;
string underlyingDefinition;
if (parts.Count() == 1)
{
underlyingDefinition = $"{{{parts[0].Trim()}}}";
}
else
{
useFormulaDefinition = $"{{{parts[0].Trim()}}}";
underlyingDefinition = $"{{{parts[1].Trim()}}}";
}
BindingDefinitionDescription bindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinition, underlyingDefinition, underlyingDefinition);
IBindingDefinition underlyingBindingDefinition = BindingDefinitionFactory.CreateInstances(templateDefinition, bindingDefinitionDescription);
IBindingDefinition useFormulaBindingDefinition = null;
if (!string.IsNullOrEmpty(useFormulaDefinition))
{
bindingDefinitionDescription = BindingDefinitionDescription.CreateBindingDescription(templateDefinition, useFormulaDefinition, useFormulaDefinition);
useFormulaBindingDefinition = BindingDefinitionFactory.CreateInstances(templateDefinition, bindingDefinitionDescription);
}
ExcelBindingDefinitionFormulaResult ret = new ExcelBindingDefinitionFormulaResult(bindingDefinitionDescription, underlyingBindingDefinition, useFormulaBindingDefinition);
return(ret);
}
catch (Exception ex)
{
string message = $"Cannot retrieve the formula result binding dataAccessor '{definition.EmptyIfNull()}'. {ex.Message}";
throw new EtkException(message);
}
}
public ExcelContextItemFormulaResult(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
excelBindingDefinitionFormulaResult = bindingDefinition as ExcelBindingDefinitionFormulaResult;
CanNotify = excelBindingDefinitionFormulaResult.CanNotify;
//NestedContextItem = nestedContextItem;
if (CanNotify)
{
objectsToNotify = bindingDefinition.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
}
private void CheckType(IBindingDefinition mainBindingDef, IBindingDefinition dataSourceType)
{
bool checkTypesOk = false;
if (dataSourceType.IsACollection)
{
checkTypesOk = true;
}
//checkTypesOk = mainBindingDef.BindingType == dataSourceType.BindingType || mainBindingDef.BindingType.IsAssignableFrom(dataSourceType.BindingType);
else
{
checkTypesOk = mainBindingDef.BindingType == dataSourceType.BindingType || mainBindingDef.BindingType.IsAssignableFrom(dataSourceType.BindingType);
}
if (!checkTypesOk)
{
Type expected = mainBindingDef.BindingType;
Type got = dataSourceType.BindingType;
throw new BindingTemplateException($"DataSource has not got the right UnderlyingType. '{expected.Name}' (or a UnderlyingType derivated from) was expected, got '{got.Name}'");
}
}
public ExcelContextItemCheckBox(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
if (bindingDefinition != null)
{
CanNotify = bindingDefinition.CanNotify;
excelBindingDefinition = bindingDefinition as ExcelBindingDefinitionCheckBox;
if (excelBindingDefinition != null)
{
objectsToNotify = excelBindingDefinition.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
}
}
/// <summary>
/// Manage the contextual menus
/// </summary>
public IContextualMenu GetMenus(ExcelTemplateView view, Microsoft.Office.Interop.Excel.Range range, IBindingContextItem contextItem)
{
IBindingDefinition bindingDefinition = contextItem.BindingDefinition;
if (bindingDefinition == null || !bindingDefinition.IsBoundWithData || bindingDefinition.BindingType == null)
{
return(null);
}
if (!((TemplateDefinition)contextItem.ParentElement.ParentPart.ParentContext.TemplateDefinition).CanSort)
{
return(null);
}
foreach (IContextualPart menuPart in sortSearchAndFilersMenu.Items)
{
ContextualMenuItem menuItem = menuPart as ContextualMenuItem;
menuItem.SetAction(() => menuItem.MethodInfo.Invoke(null, new object[] { view, contextItem }));
}
return(sortSearchAndFilersMenu);
}
public ExcelContextItemWithFormula(IBindingContextElement parent, IBindingDefinition bindingDefinition)
: base(parent, bindingDefinition)
{
excelBindingDefinitionWithFormula = bindingDefinition as ExcelBindingDefinitionWithFormula;
CanNotify = excelBindingDefinitionWithFormula.CanNotify;
if (excelBindingDefinitionWithFormula.FormulaBindingDefinition != null)
{
formulaBindingContext = excelBindingDefinitionWithFormula.FormulaBindingDefinition.ContextItemFactory(parent);
}
if (CanNotify)
{
objectsToNotify = excelBindingDefinitionWithFormula.GetObjectsToNotify(DataSource);
if (objectsToNotify != null)
{
foreach (INotifyPropertyChanged obj in objectsToNotify)
{
obj.PropertyChanged += OnPropertyChanged;
}
}
}
}
public static IEnumerable <IModelProperty> CreateInstances(IModelType parent, Type type)
{
List <IModelProperty> ret = new List <IModelProperty>();
if (type != null)
{
foreach (PropertyInfo pi in type.GetProperties())
{
IBindingDefinition bindingDefinition = BindingDefinitionFactory.CreateInstance(pi);
if (bindingDefinition != null)
{
if (pi.PropertyType.Namespace.Equals("System"))
{
ret.Add(new ModelLeafProperty(parent, bindingDefinition));
}
else
{
ret.Add(new ModelProperty(parent, bindingDefinition));
}
}
}
}
return(ret);
}
public static object TryConvert(IBindingDefinition bindingDefinition, object data)
{
if (data == null)
{
return(null);
}
if (bindingDefinition.BindingType == data.GetType() || bindingDefinition.BindingType == typeof(object))
{
return(data);
}
Type toConvertType = bindingDefinition.IsNullable ? bindingDefinition.BindingGenericType : bindingDefinition.BindingType;
if (toConvertType == data.GetType())
{
return(data);
}
if (toConvertType == typeof(DateTime))
{
return(ToDateTime(data));
}
if (toConvertType == typeof(bool))
{
return(ToBoolean(data));
}
if (toConvertType.IsEnum)
{
return(ToEnum(toConvertType, data));
}
return(Convert.ChangeType(data, toConvertType));
}
public ExcelContextItemNamedRange(IBindingContextElement parent, string name, IBindingDefinition bindingDefinition, IBindingContextItem nestedContextItem)
: base(parent, bindingDefinition)
{
this.name = name;
excelBindingDefinitionNamedRange = bindingDefinition as ExcelBindingDefinitionNamedRange;
CanNotify = excelBindingDefinitionNamedRange.CanNotify;
NestedContextItem = nestedContextItem;
}
public void AddBindingDefinition(IBindingDefinition definition)
{
BindingParts.Add(definition);
BindingDefinitions.Add(definition);
}
/// <summary>Analyze a cell of the template part</summary>
private IDefinitionPart AnalyzeCell(ExcelTemplateDefinitionPart templateDefinitionPart, ExcelInterop.Range cell)
{
IDefinitionPart part = null;
if (cell.Value2 != null)
{
string value = cell.Value2.ToString();
if (!string.IsNullOrEmpty(value))
{
string trimmedValue = value.Trim();
if (trimmedValue.StartsWith(LINKED_TEMPLATE_PREFIX))
{
try
{
XmlTemplateLink xmlTemplateLink = trimmedValue.Deserialize <XmlTemplateLink>();
TemplateLink templateLink = TemplateLink.CreateInstance(xmlTemplateLink);
ExcelTemplateDefinition templateDefinition = (ETKExcel.TemplateManager as ExcelTemplateManager).GetTemplateDefinitionFromLink(templateDefinitionPart, templateLink);
LinkedTemplateDefinition linkedTemplateDefinition = new LinkedTemplateDefinition(templateDefinitionPart.Parent, templateDefinition, templateLink);
templateDefinitionPart.AddLinkedTemplate(linkedTemplateDefinition);
part = linkedTemplateDefinition;
}
catch (Exception ex)
{
string message = $"Cannot create the linked template dataAccessor '{trimmedValue}'. {ex.Message}";
throw new EtkException(message, false);
}
}
else
{
if (trimmedValue.StartsWith(ExcelBindingFilterDefinition.Filter_PREFIX))
{
ExcelBindingFilterDefinition filterdefinition = ExcelBindingFilterDefinition.CreateInstance(templateDefinitionPart, trimmedValue);
templateDefinitionPart.AddFilterDefinition(filterdefinition);
part = filterdefinition;
}
else if (trimmedValue.StartsWith(ExcelBindingSearchDefinition.Search_PREFIX))
{
ExcelBindingSearchDefinition searchdefinition = ExcelBindingSearchDefinition.CreateInstance(trimmedValue);
templateDefinitionPart.AddSearchDefinition(searchdefinition);
part = searchdefinition;
}
else
{
try
{
IBindingDefinition bindingDefinition = CreateBindingDefinition(templateDefinitionPart, value, trimmedValue);
templateDefinitionPart.AddBindingDefinition(bindingDefinition);
part = bindingDefinition;
}
catch (Exception ex)
{
string message = $"Cannot create the binding definition for '{trimmedValue}'. {ex.Message}";
throw new EtkException(message, false);
}
}
}
}
}
return(part);
}
public static ISorterDefinition CreateInstance(ITemplateDefinition templateDefinition, IBindingDefinition bindingDefinition, bool descending, bool caseSensitive)
{
if (templateDefinition == null || bindingDefinition == null)
{
return(null);
}
MethodInfo createLambdaExpression = typeof(SortDefinitionFactory).GetMethod("CreateInstance", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(templateDefinition.BindingType.BindType, bindingDefinition.BindingType);
return(createLambdaExpression.Invoke(null, new object[] { templateDefinition, bindingDefinition, descending, caseSensitive }) as ISorterDefinition);
}
