void allowEditForClassInfoNodeListViews(Dictionary model) {
var applicationNodeWrapper = new ApplicationNodeWrapper(model);
ClassInfoNodeWrapper classInfoNodeWrapper = applicationNodeWrapper.BOModel.FindClassByType(TypesInfo.Instance.ClassInfoGraphNodeType);
foreach (var listViewInfoNodeWrapper in applicationNodeWrapper.Views.GetListViews(classInfoNodeWrapper)) {
listViewInfoNodeWrapper.AllowEdit = true;
}
}
private void RemoveXpoRoleModelDictionaryDifferenceStoreBONode(Dictionary model)
{
BOModelNodeWrapper boModelNodeWrapper = new ApplicationNodeWrapper(model).BOModel;
ClassInfoNodeWrapper wrapper = boModelNodeWrapper.Classes.Where(nodeWrapper => nodeWrapper.ClassTypeInfo.Type==typeof(RoleModelDifferenceObject)).FirstOrDefault();
if (wrapper != null)
boModelNodeWrapper.Node.RemoveChildNode(wrapper.Node);
}
public IArtifactHandler <TObject> Setup(Action <XafApplication> created, Action <TObject> action)
{
_applicationNodeWrapper = new ApplicationNodeWrapper(new Dictionary(new DictionaryNode(ApplicationNodeWrapper.NodeName), Schema.GetCommonSchema()));
_applicationNodeWrapper.Load(typeof(TObject));
var objectSpaceProvider = new ObjectSpaceProvider(new MemoryDataStoreProvider());
_objectSpace = objectSpaceProvider.CreateObjectSpace();
_currentObject = (TObject)_objectSpace.CreateObject(typeof(TObject));
if (action != null)
{
action.Invoke(_currentObject);
}
_xafApplication = Isolate.Fake.Instance <XafApplication>();
// CollectionSourceBase _collectionSource = null;
// var collectionSourceBase = Isolate.Fake.Instance<CollectionSourceBase>();
// Isolate.WhenCalled((String listViewId, CollectionSourceBase collectionSource, bool isRoot) => _xafApplication.CreateListView("", collectionSourceBase,
// false)).AndArgumentsMatch((s, @base, arg3) => {
// _collectionSource = @base;
// return true;
// }).WillReturn(new ListView(_collectionSource, _xafApplication, false));
if (created != null)
{
created.Invoke(_xafApplication);
}
return(this);
}
public override void UpdateModel(Dictionary model)
{
base.UpdateModel(model);
var applicatioNodeWrapper = new ApplicationNodeWrapper(model);
foreach (ClassInfoNodeWrapper clw in applicatioNodeWrapper.BOModel.Classes)
clw.Node.AddChildNode(DisabledDataStoreFiltersAttributeName);
}
protected override void OnActivated()
{
base.OnActivated();
var applicationNodeWrapper = new ApplicationNodeWrapper(Application.Info);
if (applicationNodeWrapper.Node.GetChildNode(FilterDataStoreModule.FilterDataStoreModuleAttributeName).GetAttributeBoolValue("Enabled"))
{
IEnumerable<ClassInfoNodeWrapper> classInfoNodeWrappers =
applicationNodeWrapper.BOModel.Classes.Where(
wrapper => wrapper.ClassTypeInfo.IsPersistent);
foreach (ClassInfoNodeWrapper classInfo in classInfoNodeWrappers)
{
foreach (FilterProviderBase provider in FilterProviderManager.Providers)
{
if (classInfo.ClassTypeInfo.FindMember(provider.FilterMemberName) == null)
CreateMember(classInfo.ClassTypeInfo, provider);
ObjectSpace.Session.UpdateSchema(new[] { classInfo.ClassTypeInfo.Type });
XafTypesInfo.Instance.RefreshInfo(classInfo.ClassTypeInfo.Type);
}
}
}
Active["RunOnce"] = false;
}
protected override void OnActivated()
{
base.OnActivated();
var applicationNodeWrapper = new ApplicationNodeWrapper(Application.Info);
if (applicationNodeWrapper.Node.GetChildNode(FilterDataStoreModule.FilterDataStoreModuleAttributeName).GetAttributeBoolValue("Enabled"))
{
IEnumerable <ClassInfoNodeWrapper> classInfoNodeWrappers =
applicationNodeWrapper.BOModel.Classes.Where(
wrapper => wrapper.ClassTypeInfo.IsPersistent);
foreach (ClassInfoNodeWrapper classInfo in classInfoNodeWrappers)
{
foreach (FilterProviderBase provider in FilterProviderManager.Providers)
{
if (classInfo.ClassTypeInfo.FindMember(provider.FilterMemberName) == null)
{
CreateMember(classInfo.ClassTypeInfo, provider);
}
ObjectSpace.Session.UpdateSchema(new[] { classInfo.ClassTypeInfo.Type });
XafTypesInfo.Instance.RefreshInfo(classInfo.ClassTypeInfo.Type);
}
}
}
Active["RunOnce"] = false;
}
public string Load(string key){
key = key.Replace("_Settings", "");
lock (_keysToBeStoredInDataStore){
if (_keysToBeStoredInDataStore.Contains(key)){
Dictionary dictionary = new QueryUserModelDifferenceObject(_session).GetActiveModelDifference(_applicationName).Model;
BaseViewInfoNodeWrapper wrapper = new ApplicationNodeWrapper(dictionary).Views.FindViewById(key);
if (wrapper != null) return new DictionaryXmlWriter().GetCurrentAspectXml(wrapper.Node);
}
}
return null;
}
public override void UpdateModel(Dictionary model)
{
base.UpdateModel(model);
var applicationNodeWrapper = new ApplicationNodeWrapper(model);
IEnumerable<string> enumerable = applicationNodeWrapper.BOModel.Classes.Where(
wrapper => typeof (ICategorizedItem).IsAssignableFrom(wrapper.ClassTypeInfo.Type)).Select(wrapper => wrapper.ClassTypeInfo.FullName);
foreach (var nodeWrapper in applicationNodeWrapper.Views.Items.Where(
wrapper => wrapper.Id.EndsWith("_LookupListView") && enumerable.Contains(wrapper.ClassName)))
nodeWrapper.Node.SetAttribute(LookUpListSearch, "AlwaysEnable");
}
protected override void OnActivated()
{
base.OnActivated();
IEnumerable<ClassInfoNodeWrapper> classInfoNodeWrappers =
new ApplicationNodeWrapper(Application.Model).BOModel.Classes.Where(
wrapper => wrapper.Node.GetAttributeBoolValue(DescribeRunTimeMembersAttributeName));
foreach (var classInfoNodeWrapper in classInfoNodeWrappers) {
TypeDescriptionProvider typeDescriptionProvider = TypeDescriptor.GetProvider(classInfoNodeWrapper.ClassTypeInfo.Type);
var membersTypeDescriptionProvider = new RuntimeMembersTypeDescriptionProvider(typeDescriptionProvider);
TypeDescriptor.AddProvider(membersTypeDescriptionProvider, classInfoNodeWrapper.ClassTypeInfo.Type);
}
}
public void If_Security_Is_Not_Complex_UserType_Is_Set_Remove_RoleAspect_Node()
{
Isolate.WhenCalled(() => SecuritySystem.UserType).WillReturn(typeof(User));
var wrapper = new ApplicationNodeWrapper(new Dictionary(new DictionaryNode(ApplicationNodeWrapper.NodeName), Schema.GetCommonSchema()));
wrapper.Load(typeof(RoleModelDifferenceObject));
var module = new ModelDifferenceModule();
Isolate.WhenCalled(() => module.AddCultures(null)).IgnoreCall();
module.UpdateModel(wrapper.Dictionary);
Assert.AreEqual(0, wrapper.BOModel.Classes.Count);
}
private void OnCustomShowNavigationItem(object sender, CustomShowNavigationItemEventArgs args)
{
string viewId = args.ActionArguments.SelectedChoiceActionItem.Info.GetAttributeValue("ViewID");
var viewInfoNodeWrapper = new ApplicationNodeWrapper(Application.Info).Views.FindViewById(viewId) as ListViewInfoNodeWrapper;
if (viewInfoNodeWrapper != null) {
var node = viewInfoNodeWrapper.Node.FindChildNode("Variants");
if (node != null)
{
var variantName = node.GetAttribute("Current").Value;
if (!string.IsNullOrEmpty(variantName)&&variantName!="Default")
((ViewShortcut)args.ActionArguments.SelectedChoiceActionItem.Data).ViewId = node.GetChildNode("Variant", "ID", variantName).GetAttributeValue("ViewID");
}
}
}
public void Proccess(CustomProcessShortcutEventArgs shortcutEventArgs) {
var shortcut = shortcutEventArgs.Shortcut;
if (shortcut.ObjectKey.StartsWith("@"))
shortcut.ObjectKey =
ParametersFactory.CreateParameter(shortcut.ObjectKey.Substring(1)).CurrentValue.ToString();
var baseViewInfoNodeWrapper = new ApplicationNodeWrapper(_application.Model).Views.FindViewById(shortcut.ViewId);
if (string.IsNullOrEmpty(shortcut.ObjectKey) && (baseViewInfoNodeWrapper is DetailViewInfoNodeWrapper)) {
var objectSpace = _application.CreateObjectSpace();
shortcutEventArgs.Handled = true;
shortcutEventArgs.View = _application.CreateDetailView(objectSpace,
objectSpace.CreateObject(
baseViewInfoNodeWrapper.BusinessObjectType));
}
}
public override bool IsInvisible(DictionaryNode node, string attributeName)
{
var attributeValueByPath = helper.GetAttributeValueByPath(node, helper.GetParamValue("ID", "@ID"));
if (!string.IsNullOrEmpty(attributeValueByPath))
{
var wrapper = new ApplicationNodeWrapper(node.Dictionary).Views.FindViewById(attributeValueByPath);
if ((helper.GetParamValue("ViewType") == ViewType.DetailView.ToString() && wrapper is DetailViewInfoNodeWrapper) ||
(helper.GetParamValue("ViewType") == ViewType.ListView.ToString() && wrapper is ListViewInfoNodeWrapper))
return true;
if (helper.GetParamValue("ViewType") == ViewType.Any.ToString() && wrapper != null)
return true;
}
return false;
}
public string Load(string key)
{
key = key.Replace("_Settings", "");
lock (_keysToBeStoredInDataStore){
if (_keysToBeStoredInDataStore.Contains(key))
{
Dictionary dictionary = new QueryUserModelDifferenceObject(_session).GetActiveModelDifference(_applicationName).Model;
BaseViewInfoNodeWrapper wrapper = new ApplicationNodeWrapper(dictionary).Views.FindViewById(key);
if (wrapper != null)
{
return(new DictionaryXmlWriter().GetCurrentAspectXml(wrapper.Node));
}
}
}
return(null);
}
public override void UpdateModel(Dictionary dictionary)
{
base.UpdateModel(dictionary);
var applicationNodeWrapper = new ApplicationNodeWrapper(dictionary);
IEnumerable<ClassInfoNodeWrapper> classInfoNodeWrappers =
applicationNodeWrapper.BOModel.Classes.Where(cls =>typeof (XPBaseObject).IsAssignableFrom(cls.ClassTypeInfo.Type));
foreach (ClassInfoNodeWrapper classInfoNodeWrapper in classInfoNodeWrappers){
foreach (PropertyInfoNodeWrapper propertyInfoNodeWrapper in from property in classInfoNodeWrapper.Properties
let detailViewItemInfoNodeWrapper =new DetailViewItemInfoNodeWrapper(property.Node)
let isSimpleStringEdit =(property.Type != typeof(string).FullName ||(detailViewItemInfoNodeWrapper.RowCount == 0))
let isComboStringEdit =(isSimpleStringEdit &&!string.IsNullOrEmpty(detailViewItemInfoNodeWrapper.PredefindedValues))
where property.PropertyEditorType ==typeof(StringPropertyEditor).FullName &&isSimpleStringEdit && !isComboStringEdit
select property)
propertyInfoNodeWrapper.PropertyEditorType = typeof(MemberLevelSecurityStringPropertyEditor).FullName;
}
}
///<summary>
///
///<para>
///Updates the Application Model.
///
///</para>
///
///</summary>
///
///<param name="dictionary">
/// A <b>Dictionary</b> object that provides access to the Application Model's nodes.
///
/// </param>
public override void UpdateModel(Dictionary dictionary)
{
base.UpdateModel(dictionary);
var wrappers = new ApplicationNodeWrapper(dictionary).Views.Items.Where(wrapper => wrapper is ListViewInfoNodeWrapper);
foreach (ListViewInfoNodeWrapper wrapper in wrappers)
{
wrapper.Node.SetAttribute(IsColumnHeadersVisible, true.ToString());
wrapper.Node.SetAttribute(UseTabKey, true.ToString());
wrapper.Node.SetAttribute(GuessAutoFilterRowValuesFromFilter, true.ToString());
foreach (ColumnInfoNodeWrapper column in wrapper.Columns.Items.Where(wrapper2 => wrapper2.PropertyTypeInfo.Type == typeof(string)))
{
column.Node.SetAttribute(AutoFilterCondition, DevExpress.XtraGrid.Columns.AutoFilterCondition.Contains.ToString());
column.Node.SetAttribute(ImmediateUpdateAutoFilter, false.ToString());
}
}
}
public override void UpdateModel(Dictionary dictionary)
{
base.UpdateModel(dictionary);
var wrapper = new ApplicationNodeWrapper(dictionary);
DictionaryNode node = wrapper.Node.AddChildNode(Modules);
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
try{
foreach (var type in assembly.GetTypes().Where(type => typeof(ModuleBase).IsAssignableFrom(type))){
if (node.FindChildNode("Module", "Name", type.FullName) == null)
node.AddChildNode("Module").SetAttribute("Name", type.FullName);
}
}
catch (ReflectionTypeLoadException){
Tracing.Tracer.LogError(string.Format("ReflectionTypeLoadException for {0}", assembly.FullName));
}
}
}
public void Is_A_Combination_Of_All_Models_Assign_to_Current_User_For_Current_Aspect_And_Application()
{
var store = new XpoUserModelDictionaryDifferenceStore( Isolate.Fake.Instance<XafApplication>());
var modelDifferenceObject = new UserModelDifferenceObject(Session.DefaultSession) { Model = DefaultDictionary, PersistentApplication = new PersistentApplication(Session.DefaultSession) { Model = PersistentAppDictionary } };
Isolate.WhenCalled(() => store.GetActiveDifferenceObjects()).
WillReturnCollectionValuesOf(new List<ModelDifferenceObject>{
modelDifferenceObject,
new UserModelDifferenceObject(Session.DefaultSession)
{Model = DefaultDictionary2,PersistentApplication = new PersistentApplication(Session.DefaultSession){Model = new Dictionary(Schema.GetCommonSchema())}}
}.AsQueryable());
Dictionary dictionary = store.LoadDifference(Schema.GetCommonSchema());
var wrapper = new ApplicationNodeWrapper(dictionary).BOModel;
Assert.IsNotNull(wrapper.FindClassByName("MyClass"));
Assert.IsNotNull(wrapper.FindClassByName("MyClass2"));
}
public void When_Updating_Model_It_Should_Add_AllCultures_As_Predifined_Values_Of_CurrentLanguage_Member(){
var dictionary = DictionaryFactory.Create(typeof(ModelDifferenceObject));
var module = new ModelDifferenceModule();
Isolate.WhenCalled(() => module.GetAllCultures()).WillReturn("test");
module.UpdateModel(dictionary);
var name = new ModelDifferenceObject(Session.DefaultSession).GetPropertyInfo(x=>x.PreferredAspect).Name;
var single = new ApplicationNodeWrapper(dictionary).BOModel.FindClassByType(typeof(ModelDifferenceObject)).AllProperties.Where(wrapper => wrapper.Name==name).Single();
Assert.AreEqual("test", single.Node.GetAttributeValue("PredefinedValues"));
}
IEnumerable<ListViewInfoNodeWrapper> GetListViewInfoNodeWrappers(Dictionary dictionary)
{
var wrapper = new ApplicationNodeWrapper(dictionary);
List<ListViewInfoNodeWrapper> wrappers =
wrapper.Views.GetListViews(TypesInfo.Instance.ExtendedReferenceMemberInfoType);
wrappers.AddRange(wrapper.Views.GetListViews(TypesInfo.Instance.ExtendedCollectionMemberInfoType));
wrappers.AddRange(wrapper.Views.GetListViews(TypesInfo.Instance.ExtendedCoreMemberInfoType));
return wrappers;
}
public bool FilterIsShared(string tableName,string providerName)
{
bool ret = false;
string classNameInDictionary = FindClassNameInDictionary(tableName);
if (classNameInDictionary != null)
{
var classInfoNodeWrapper = new ApplicationNodeWrapper(Application.Info).BOModel.FindClassByName(classNameInDictionary);
if (classInfoNodeWrapper != null)
foreach (
DictionaryNode childNode in
classInfoNodeWrapper.Node.GetChildNode(DisabledDataStoreFiltersAttributeName).ChildNodes)
if (childNode.GetAttributeValue("Name") == providerName)
ret =true;
}
Tracing.Tracer.LogVerboseValue("FilterIsShared", ret);
return ret;
}
private ListViewInfoNodeWrapper GetCurrentVariant(ChangeVariantController changeVariantController, ApplicationNodeWrapper wrapper) {
var node1 = new ListViewInfoNodeWrapper(wrapper.Views.FindViewById(Application.FindListViewId(View.ObjectTypeInfo.Type)).Node);
changeVariantController.ChangeVariantAction.Items.Remove(
changeVariantController.ChangeVariantAction.SelectedItem);
changeVariantController.ChangeVariantAction.SelectedItem = (from item in changeVariantController.ChangeVariantAction.Items
where item.Caption == node1.Node.FindChildNode("Variants").ChildNodes[0].KeyAttribute.Value
select item).Single();
return node1;
}
void enableCloning(Dictionary model)
{
foreach (var propertyInfo in typeof(ITypesInfo).GetProperties())
{
var type = (Type)propertyInfo.GetValue(TypesInfo.Instance, null);
var classInfoNodeWrapper = new ApplicationNodeWrapper(model).BOModel.FindClassByType(type);
classInfoNodeWrapper.Node.SetAttribute("IsClonable", true);
}
}
public void AddCultures(Dictionary model)
{
var propertyInfoNodeWrapper = new ApplicationNodeWrapper(model).BOModel.FindClassByType(typeof(ModelDifferenceObject)).AllProperties.Where(wrapper => wrapper.Name == "PreferredAspect").Single();
propertyInfoNodeWrapper.Node.SetAttribute("PredefinedValues", GetAllCultures());
}
private void removeVariantNodeFromViews(string id, ApplicationNodeWrapper wrapper) {
var variantNodes = wrapper.Views.Items.OfType<ListViewInfoNodeWrapper>().Where(nodeWrapper => nodeWrapper.Node.FindChildNode("Variants")!=null).Select(nodeWrapper => nodeWrapper.Node.FindChildNode("Variants")).SelectMany(node => node.ChildNodes).ToList();
foreach (var node in variantNodes) {
if (node.KeyAttribute.Value==id) {
node.Parent.SetAttribute("Current",node.Parent.ChildNodes.Where(dictionaryNode => dictionaryNode.KeyAttribute.Value!=id).ToList()[0].KeyAttribute.Value);
node.Parent.RemoveChildNode(node);
}
}
}
public AdditionalViewControlsRuleWrapper(View view)
{
ClassInfoNodeWrapper classInfoNodeWrappers = new ApplicationNodeWrapper(view.Info.Dictionary.RootNode).BOModel.Classes.Where(wrapper => wrapper.ClassTypeInfo==view.ObjectTypeInfo).FirstOrDefault();
dictionaryNode = classInfoNodeWrappers.Node.GetChildNode(UpdateModelViewController.AdditionalViewControls);
}
private void setCurrentVariant(string oldId, string newId) {
var wrapper = new ApplicationNodeWrapper(Application.Info);
var variantNodes = wrapper.Views.Items.OfType<ListViewInfoNodeWrapper>().Where(nodeWrapper => nodeWrapper.Node.FindChildNode("Variants") != null).Select(nodeWrapper => nodeWrapper.Node.FindChildNode("Variants")).SelectMany(node => node.ChildNodes).ToList();
foreach (DictionaryNode node in variantNodes) {
if (node.KeyAttribute.Value == oldId) {
node.Parent.SetAttribute("Current", newId);
node.SetAttribute("ID", newId);
node.SetAttribute("ViewID", newId);
node.SetAttribute("Caption", newId);
}
}
}
private void deleteView(object sender) {
var changeVariantController = Frame.GetController<ChangeVariantController>();
if (changeVariantController.ChangeVariantAction.Items.Count == 1) {
MessageBox.Show("You cannot delete all views");
return;
}
var wrapper = new ApplicationNodeWrapper(Application.Info);
var choiceActionItem = ((ChoiceActionItem)((ComboBoxEdit)sender).EditValue);
var id = choiceActionItem.Data.ToString();
var childNode = wrapper.Views.FindViewById(id).Node;
removeVariantNodeFromViews(choiceActionItem.Info.KeyAttribute.Value, wrapper);
wrapper.Views.Node.RemoveChildNode(childNode);
ListViewInfoNodeWrapper node1 = GetCurrentVariant(changeVariantController, wrapper);
View.SetInfo(node1.Node);
}
