CSLA.NET 5.4.2
CSLA .NET is a software development framework that helps you build a reusable, maintainable object-oriented business layer for your app.
CslaDataProviderCommandManager.cs
Go to the documentation of this file.
1#if !XAMARIN && !WINDOWS_UWP
2//-----------------------------------------------------------------------
3// <copyright file="CslaDataProviderCommandManager.cs" company="Marimer LLC">
4// Copyright (c) Marimer LLC. All rights reserved.
5// Website: https://cslanet.com
6// </copyright>
7// <summary>Implements support for RoutedCommands that can</summary>
8//-----------------------------------------------------------------------
9using System;
10using System.Windows.Input;
11using System.ComponentModel;
12
13namespace Csla.Xaml
14{
24 public class CslaDataProviderCommandManager : System.Windows.UIElement
25 {
26 private CslaDataProvider _provider;
27
28 private CslaDataProvider Provider
29 {
30 get { return _provider; }
31 }
32
33 internal CslaDataProviderCommandManager(CslaDataProvider provider)
34 {
35 _provider = provider;
36 }
37
38 static CslaDataProviderCommandManager()
39 {
40 CommandBinding binding;
41
42 binding = new CommandBinding(ApplicationCommands.Save, SaveCommand, CanExecuteSave);
43 CommandManager.RegisterClassCommandBinding(typeof(CslaDataProviderCommandManager), binding);
44
45 binding = new CommandBinding(ApplicationCommands.Undo, UndoCommand, CanExecuteUndo);
46 CommandManager.RegisterClassCommandBinding(typeof(CslaDataProviderCommandManager), binding);
47
48 binding = new CommandBinding(ApplicationCommands.New, NewCommand, CanExecuteNew);
49 CommandManager.RegisterClassCommandBinding(typeof(CslaDataProviderCommandManager), binding);
50
51 binding = new CommandBinding(ApplicationCommands.Delete, RemoveCommand, CanExecuteRemove);
52 CommandManager.RegisterClassCommandBinding(typeof(CslaDataProviderCommandManager), binding);
53 }
54
55 private static void CanExecuteSave(object target, CanExecuteRoutedEventArgs e)
56 {
57 bool result = false;
58 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
59 if (ctl != null && ctl.Provider != null)
60 {
61 Csla.Core.IEditableBusinessObject ibiz = ctl.Provider.Data as Csla.Core.IEditableBusinessObject;
62 if (ibiz != null)
63 result = ibiz.IsSavable;
64 else
65 {
66 Csla.Core.IEditableCollection icol = ctl.Provider.Data as Csla.Core.IEditableCollection;
67 if (icol != null)
68 result = icol.IsSavable;
69 }
70 }
71 e.CanExecute = result;
72 }
73
74 private static void SaveCommand(object target, ExecutedRoutedEventArgs e)
75 {
76 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
77 if (ctl != null && ctl.Provider != null)
78 ctl.Provider.Save();
79 }
80
81 private static void CanExecuteUndo(object target, CanExecuteRoutedEventArgs e)
82 {
83 bool result = false;
84 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
85 if (ctl != null && ctl.Provider != null)
86 {
87 if (ctl.Provider.Data != null)
88 {
89 Csla.Core.IEditableBusinessObject ibiz = ctl.Provider.Data as Csla.Core.IEditableBusinessObject;
90 if (ibiz != null)
91 result = ibiz.IsDirty;
92 else
93 {
94 Csla.Core.IEditableCollection icol = ctl.Provider.Data as Csla.Core.IEditableCollection;
95 if (icol != null)
96 result = icol.IsDirty;
97 }
98 }
99 }
100 e.CanExecute = result;
101 }
102
103 private static void UndoCommand(object target, ExecutedRoutedEventArgs e)
104 {
105 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
106 if (ctl != null && ctl.Provider != null)
107 ctl.Provider.Cancel();
108 }
109
110 private static void CanExecuteNew(object target, CanExecuteRoutedEventArgs e)
111 {
112 bool result = false;
113 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
114 if (ctl != null && ctl.Provider != null)
115 {
116 if (ctl.Provider.Data != null)
117 {
118 IBindingList list = ctl.Provider.Data as IBindingList;
119 if (list != null)
120 {
121 result = list.AllowNew;
122 if (result && !Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, ctl.Provider.Data))
123 result = false;
124 }
125 }
126 }
127 e.CanExecute = result;
128 }
129
130 private static void NewCommand(object target, ExecutedRoutedEventArgs e)
131 {
132 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
133 if (ctl != null && ctl.Provider != null)
134 ctl.Provider.AddNew();
135 }
136
137 private static void CanExecuteRemove(object target, CanExecuteRoutedEventArgs e)
138 {
139 bool result = false;
140 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
141 if (ctl != null && ctl.Provider != null)
142 {
143 if (ctl.Provider.Data != null)
144 {
145 Csla.Core.BusinessBase bb = e.Parameter as Csla.Core.BusinessBase;
146 IBindingList list;
147 if (bb != null)
148 list = bb.Parent as IBindingList;
149 else
150 list = ctl.Provider.Data as IBindingList;
151 if (list != null)
152 {
153 result = list.AllowRemove;
154 if (result && !Csla.Rules.BusinessRules.HasPermission(Rules.AuthorizationActions.EditObject, ctl.Provider.Data))
155 result = false;
156 }
157 }
158 }
159 e.CanExecute = result;
160 }
161
162 private static void RemoveCommand(object target, ExecutedRoutedEventArgs e)
163 {
164 CslaDataProviderCommandManager ctl = target as CslaDataProviderCommandManager;
165 if (ctl != null && ctl.Provider != null)
166 ctl.Provider.RemoveItem(null, new ExecuteEventArgs { MethodParameter = e.Parameter });
167 }
168 }
169}
170#endif
Csla.Core.BusinessBase
This is the non-generic base class from which most business objects will be derived.
Definition: Csla/Core/BusinessBase.cs:54
Csla.Core.BusinessBase.Parent
Core.IParent Parent
Provide access to the parent reference for use in child object code.
Definition: Csla/Core/BusinessBase.cs:130
Csla.Rules.BusinessRules
Tracks the business rules for a business object.
Definition: BusinessRules.cs:29
Csla.Rules.BusinessRules.HasPermission
static bool HasPermission(AuthorizationActions action, Type objectType)
Checks per-type authorization rules.
Definition: BusinessRules.cs:311
Csla.Xaml.CslaDataProviderCommandManager
Implements support for RoutedCommands that can be executed by the CslaDataProvider control.
Definition: CslaDataProviderCommandManager.cs:25
Csla.Xaml.CslaDataProvider
Wraps and creates a CSLA .NET-style object that you can use as a binding source.
Definition: CslaDataProvider.cs:26
Csla.Xaml.CslaDataProvider.AddNew
object AddNew()
Adds a new item to the object if the object implements IBindingList and AllowNew is true.
Definition: CslaDataProvider.cs:532
Csla.Xaml.CslaDataProvider.Cancel
void Cancel()
Cancels changes to the business object, returning it to its previous state.
Definition: CslaDataProvider.cs:442
Csla.Xaml.CslaDataProvider.RemoveItem
void RemoveItem(object sender, ExecuteEventArgs e)
Removes an item from the list if the object implements IBindingList and AllowRemove is true.
Definition: CslaDataProvider.cs:553
Csla.Xaml.CslaDataProvider.Save
void Save()
Accepts changes to the business object, and commits them by calling the object's Save() method.
Definition: CslaDataProvider.cs:474
Csla.Xaml.ExecuteEventArgs
Arguments passed to a method invoked by the Execute trigger action.
Definition: ExecuteEventArgs.cs:25
Csla.Core.IEditableBusinessObject
Defines the common methods required by all editable CSLA single objects.
Definition: IEditableBusinessObject.cs:23
Csla.Core.IEditableCollection
Defines the common methods required by all editable CSLA collection objects.
Definition: IEditableCollection.cs:21
Csla.Core.ITrackStatus.IsSavable
bool IsSavable
Returns true if this object is both dirty and valid.
Definition: ITrackStatus.cs:132
Csla.Core.ITrackStatus.IsDirty
bool IsDirty
Returns true if this object's data, or any of its fields or child objects data, has been changed.
Definition: ITrackStatus.cs:73