/// <summary> /// Initializes a new instance of the <see cref="QueryConverter"/> class. /// </summary> /// <param name="services">The services.</param> /// <param name="typeProvider">The type provider.</param> /// <param name="translator">The translator.</param> /// <param name="nodeFactory">The node factory.</param> internal QueryConverter(IDataServices services, TypeSystemProvider typeProvider, Translator translator, NodeFactory nodeFactory) { if(services == null) { throw Error.ArgumentNull("services"); } if(nodeFactory == null) { throw Error.ArgumentNull("sql"); } if(translator == null) { throw Error.ArgumentNull("translator"); } if(typeProvider == null) { throw Error.ArgumentNull("typeProvider"); } _services = services; _translator = translator; _nodeFactory = nodeFactory; _typeProvider = typeProvider; _parameterExpressionToSqlExpression = new Dictionary<ParameterExpression, SqlExpression>(); _parameterExpressionToExpression = new Dictionary<ParameterExpression, Expression>(); _parameterExpressionToSqlNode = new Dictionary<ParameterExpression, SqlNode>(); _sqlNodeToGroupInfo = new Dictionary<SqlNode, GroupInfo>(); _allowDeferred = true; }
// When data services are available and initialized, // the API calls the method you passed to Create() above: private void OnDataServicesCreated(IDataServices dataServices) { this.realtime = dataServices.Realtime; // Using realtime object, you can now start sending requests and/or // subscribing to realtime. See below for other code samples. }
internal ObjectReaderBase(ObjectReaderSession <TDataReader> session, NamedColumn[] namedColumns, object[] globals, object[] arguments, int nLocals ) : base() { this.Session = session; this.services = session.Provider.Services; this.DataReader = session.DataReader; this.Globals = globals; this.Arguments = arguments; if (nLocals > 0) { this.Locals = new object[nLocals]; } if (this.Session.IsBuffered) { this.Buffer(); } this.Ordinals = this.GetColumnOrdinals(namedColumns); }
/// <summary> /// Control the invoce control view model. /// </summary> /// <param name="dataServices">Data Services</param> /// <param name="container">Unity container</param> /// <param name="service">Service</param> /// <param name="manager">Region Manager</param> /// <param name="requestService">Request service</param> /// <param name="eventManager">Event manager</param> public InvoiceControlViewModel(IDataServices dataServices, IConfigurationService configurationService, IUnityContainer container, IDialogService service, IRegionManager manager, IInteractionRequestController requestService, IEventManager eventManager) : base( dataServices, requestService, service, eventManager, configurationService) { _regionManager = manager; IsBusy = false; _container = container; OpenItemCommand = new DelegateCommand <object>(OpenCurrentItem); InitViewModel(); ItemName = "Facturas"; ShowClientCommand = new DelegateCommand <object>(OnShowClient); _invoiceDataServices = DataServices.GetInvoiceDataServices(); ViewModelUri = new Uri("karve://invoice/viewmodel?id=" + UniqueId); MailboxName = ViewModelUri.ToString(); EventManager.RegisterObserverSubsystem(InvoiceModule.InvoiceSubSystem, this); RegisterMailBox(ViewModelUri.ToString()); StartAndNotify(); }
internal QueryConverter(IDataServices services, TypeSystemProvider typeProvider, Translator translator, SqlFactory sql) { if (services == null) { throw Error.ArgumentNull("services"); } if (sql == null) { throw Error.ArgumentNull("sql"); } if (translator == null) { throw Error.ArgumentNull("translator"); } if (typeProvider == null) { throw Error.ArgumentNull("typeProvider"); } this.services = services; this.translator = translator; this.sql = sql; this.typeProvider = typeProvider; this.map = new Dictionary<ParameterExpression, SqlExpression>(); this.exprMap = new Dictionary<ParameterExpression, Expression>(); this.dupMap = new Dictionary<ParameterExpression, SqlNode>(); this.gmap = new Dictionary<SqlNode, GroupInfo>(); this.allowDeferred = true; }
protected HeaderedLineViewModelBase(IDataServices dataServices, IDialogService dialogServices, IEventManager manager, IRegionManager regionManager, IIdentifier identifier, IConfigurationService configurationService, IInteractionRequestController controller) : base(dataServices, controller, dialogServices, manager, configurationService) { RegionManager = regionManager; IdentifierGenerator = identifier; AssistDataService = DataServices.GetAssistDataServices(); LineVisible = true; FooterVisible = true; /* This instruct the toolbar to skip its is own handlers. Avoiding complexity. * It will be just the view to save itself with composite command and to alert it subsystem. * This with the SetRegistrationPayLoad set properly it will permit to save itself. * Each view will save itself, like in this scenario: * https://prismlibrary.github.io/docs/wpf/Advanced-MVVM.html * It is better that all headered window will use a composite command. */ CompositeCommandOnly = true; }
//public new DbConnection Connection //{ // get // { // CheckDispose(); // CheckInitialized(); // var conn = conManager.Connection; // if (conn is Connection) // return ((Connection)conn).Source; // return conn; // } //} #endregion void IProvider.Initialize(IDataServices dataServices, object connection) { if (dataServices == null) { throw SqlClient.Error.ArgumentNull("dataServices"); } DbConnection conn; string constr; if (connection is string) { conn = new OracleConnection((string)connection); constr = (string)connection; } //else if (connection is Connection) //{ // conn = (Connection)connection; // constr = ((Connection)connection).ConnectionString; //} else { conn = (OracleConnection)connection; constr = conn.ConnectionString; } dbName = dataServices.Model.DatabaseName; object obj; var builder = new DbConnectionStringBuilder { ConnectionString = constr }; passowrd = !builder.TryGetValue("password", out obj) ? dbName : obj.ToString(); Initialize(dataServices, conn); }
public ProvidersControlViewModel(IConfigurationService configurationService, IUnityContainer container, IDataServices services, IRegionManager regionManager, IDialogService service, IEventManager eventManager) : base(configurationService, eventManager, services, null, service, regionManager) { _container = container; _regionManager = regionManager; _extendedSupplierDataTable = new DataTable(); _uniqueIdentifier = _uniqueIdentifier % Int64.MaxValue; _mailBoxName = PROVIDER_SUMMARY_VM; _supplierTaskEvent += OnNotifyIncrementalList <SupplierSummaryDto>; _supplierDataServices = DataServices.GetSupplierDataServices(); _gridSorter = new GridSorter <SupplierSummaryDto>(service, _supplierDataServices, DefaultPageSize); _gridSorter.OnInitPage += _gridSorter_OnInitPage; _gridSorter.OnNewPage += _gridSorter_OnNewPage; DefaultPageSize = 100; ViewModelUri = new Uri("karve://booking/viewmodel?id=" + Guid.ToString()); SortCommand = new DelegateCommand <object>(OnSortCommand); OpenItemCommand = new DelegateCommand <object>(OpenCurrentItem); InitViewModel(); ActiveSubSystem(); }
void IProvider.Initialize(IDataServices dataServices, object connection) { //Debug.Assert(connection is SQLiteConnection); if (dataServices == null) { throw SqlClient.Error.ArgumentNull("dataServices"); } var connection2 = connection as SQLiteConnection; if (connection2 == null) { var fileOrConnectionString = connection as string; if (fileOrConnectionString == null) { throw SqlClient.Error.InvalidConnectionArgument("connection"); } string connectionString = GetConnectionString(fileOrConnectionString); connection2 = new SQLiteConnection(connectionString); } services = dataServices; dbName = GetDatabaseName(connection2.ConnectionString); Initialize(dataServices, connection2); }
/// <summary> /// Commision agent info view model. /// </summary> /// <param name="configurationService"></param> /// <param name="eventManager"></param> /// <param name="services"></param> /// <param name="dialogService"></param> /// <param name="regionManager"></param> /// <param name="controller"></param> public CommissionAgentInfoViewModel(IConfigurationService configurationService, IEventManager eventManager, IDataServices services, IDialogService dialogService, IRegionManager regionManager, IInteractionRequestController controller ) : base(eventManager, configurationService, services, dialogService, regionManager, controller) { _queries = new Dictionary <string, string>(); _visibility = Visibility.Collapsed; _commissionAgentDataServices = DataServices.GetCommissionAgentDataServices(); _regionManager = regionManager; _onBranchesPrimaryKey += CommissionAgentInfoViewModel__onBranchesPrimaryKey; _onContactsPrimaryKey += CommissionAgentInfoViewModel__onContactsPrimaryKey; _onVisitPrimaryKey += CommissionAgentInfoViewModel__onVisitPrimaryKey; IsVisible = Visibility.Collapsed; AssistQueryDictionary = new Dictionary <string, string>(); PrimaryKeyValue = string.Empty; ConfigurationService = configurationService; InitEvents(); InitCommands(); ViewModelUri = new Uri("karve://broker/viewmodel?id=" + Guid.ToString()); _mapper = MapperField.GetMapper(); EventManager.RegisterObserverSubsystem(MasterModuleConstants.CommissionAgentSystemName, this); // update the assist. UpdateAssist(ref _leftSideDualDfSearchBoxes); UpdateChangeCommand(ref _leftSideDualDfSearchBoxes); // register itself in the broacast. EventManager.RegisterObserver(this); _countTime = 0; }
public InvoiceController(IDataServices dataService) { DataService = dataService; }
public ProviderDataLayer(IDataServices dataServices) { _dataServices = dataServices; Initialization = InitializeAsync(); }
/// FIXME: see if the payload can be TAP. /// <summary> /// Abstract method to override for executing the payload /// </summary> /// <param name="services">DataServices</param> /// <param name="manager">Event manager</param> /// <param name="payLoad">Payload to be filed.</param> public abstract void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad);
public DataProviderViewModel(IDataServices dataServices) { }
public BusinessUnitController(IDataServices dataServices) { _dataServices = dataServices; }
public LayoutController(IDataServices dataService) { DataService = dataService; }
/// <summary> /// Constructor for the helper view. /// </summary> /// <param name="dataService">DataService for retrieving the helper dataservice.</param> /// <param name="regionManager">Region manager used by the factory for the navigation.</param> /// <param name="dialogService">DialogService used by the factory for pointing out the errors.</param> public HelperNavigatorFactory(IDataServices dataService, IRegionManager regionManager, IDialogService dialogService) { _dataService = dataService; _regionManager = regionManager; _dialogService = dialogService; }
[ResourceExposure(ResourceScope.Machine)] // connection parameter may refer to filenames. void IProvider.Initialize(IDataServices dataServices, object connection) { if(dataServices == null) { throw Error.ArgumentNull("dataServices"); } _services = dataServices; DbConnection con; DbTransaction tx = null; string fileOrServerOrConnectionString = connection as string; if(fileOrServerOrConnectionString != null) { string connectionString = this.GetConnectionString(fileOrServerOrConnectionString); _dbName = this.GetDatabaseName(connectionString); if(_dbName.EndsWith(".sdf", StringComparison.OrdinalIgnoreCase)) { _mode = SqlServerProviderMode.SqlCE; } if(_mode == SqlServerProviderMode.SqlCE) { DbProviderFactory factory = SqlProvider.GetProvider(SqlCeProviderInvariantName); if(factory == null) { throw Error.ProviderNotInstalled(_dbName, SqlCeProviderInvariantName); } con = factory.CreateConnection(); } else { con = new SqlConnection(); } con.ConnectionString = connectionString; } else { // We only support SqlTransaction and SqlCeTransaction tx = connection as SqlTransaction; if(tx == null) { // See if it's a SqlCeTransaction if(connection.GetType().FullName == SqlCeTransactionTypeName) { tx = connection as DbTransaction; } } if(tx != null) { connection = tx.Connection; } con = connection as DbConnection; if(con == null) { throw Error.InvalidConnectionArgument("connection"); } if(con.GetType().FullName == SqlCeConnectionTypeName) { _mode = SqlServerProviderMode.SqlCE; } _dbName = this.GetDatabaseName(con.ConnectionString); } // initialize to the default command timeout using(DbCommand c = con.CreateCommand()) { _commandTimeout = c.CommandTimeout; } int maxUsersPerConnection = 1; if(con.ConnectionString.IndexOf("MultipleActiveResultSets", StringComparison.OrdinalIgnoreCase) >= 0) { DbConnectionStringBuilder builder = new DbConnectionStringBuilder(); builder.ConnectionString = con.ConnectionString; if(string.Compare((string)builder["MultipleActiveResultSets"], "true", StringComparison.OrdinalIgnoreCase) == 0) { maxUsersPerConnection = 10; } } // If fileOrServerOrConnectionString != null, that means we just created the connection instance and we have to tell // the SqlConnectionManager that it should dispose the connection when the context is disposed. Otherwise the user owns // the connection and should dispose of it themselves. _conManager = new ConnectionManager(this, con, maxUsersPerConnection, fileOrServerOrConnectionString != null /*disposeConnection*/); if(tx != null) { _conManager.Transaction = tx; } #if DEBUG SqlNode.Formatter = new SqlFormatter(); #endif Type readerType; if(_mode == SqlServerProviderMode.SqlCE) { readerType = con.GetType().Module.GetType(SqlCeDataReaderTypeName); } else if(con is SqlConnection) { readerType = typeof(SqlDataReader); } else { readerType = typeof(DbDataReader); } _readerCompiler = new ObjectReaderCompiler(readerType, _services); }
// Not implementing finalizer here because there are no unmanaged resources // to release. See http://msdnwiki.microsoft.com/en-us/mtpswiki/12afb1ea-3a17-4a3f-a1f0-fcdb853e2359.aspx // The bulk of the clean-up code is implemented in Dispose(bool) protected virtual void Dispose(bool disposing) { // Implemented but empty so that derived contexts can implement // a finalizer that potentially cleans up unmanaged resources. if(disposing) { _services = null; if(_conManager != null) { _conManager.DisposeConnection(); } _conManager = null; _typeProvider = null; _sqlFactory = null; _translator = null; _readerCompiler = null; _log = null; } }
internal ObjectReaderCompiler(Type dataReaderType, IDataServices services) { this.dataReaderType = dataReaderType; this.services = services; this.miDRisDBNull = dataReaderType.GetMethod("IsDBNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); this.miBRisDBNull = typeof(DbDataReader).GetMethod("IsDBNull", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); Type orbType = typeof(ObjectMaterializer<>).MakeGenericType(this.dataReaderType); this.ordinalsField = orbType.GetField("Ordinals", BindingFlags.Instance | BindingFlags.Public); this.globalsField = orbType.GetField("Globals", BindingFlags.Instance | BindingFlags.Public); this.argsField = orbType.GetField("Arguments", BindingFlags.Instance | BindingFlags.Public); this.readerField = orbType.GetField("DataReader", BindingFlags.Instance | BindingFlags.Public); this.bufferReaderField = orbType.GetField("BufferReader", BindingFlags.Instance | BindingFlags.Public); System.Diagnostics.Debug.Assert( this.miDRisDBNull != null && this.miBRisDBNull != null && this.readerField != null && this.bufferReaderField != null && this.ordinalsField != null && this.globalsField != null && this.argsField != null ); }
public ClientController(IDataServices dataService) { DataService = dataService; }
public ObjectStateManager(DataContext context) { _context = context; _dataServices = CommonDataServicesWrapper.CreateDataServiceServicesWrapper(context); }
public FlowsController(IDataServices dataServices) { _dataServices = dataServices; }
internal Translator(IDataServices services, SqlFactory sqlFactory, TypeSystemProvider typeProvider) { this.services = services; this.sql = sqlFactory; this.typeProvider = typeProvider; }
/// <summary> /// Generate a new navigator. A KarveNavigator is an helper for navigating from a view to another view /// allowing the communication with the toolbar. It allows a creation of data. /// </summary> /// <param name="dataServices">DataService. It has been used in this case for creating a new view with a new item</param> /// <param name="regionManager">RegionManager. It has been used in this case for navigating to the tabregion.</param> /// <param name="eventManager">EventManager. It has been used for sending messaging to the navigated subsystem with a new item.</param> /// <param name="dialogService">DialogService. It has been used for spotting an error.</param> /// <returns></returns> public static IKarveNavigator GetKarveNavigator(IDataServices dataServices, IRegionManager regionManager, IEventManager eventManager, IDialogService dialogService) { return(new KarveNavigator(dataServices, regionManager, eventManager, dialogService)); }
/// <summary> /// VisitType view model /// </summary> /// <param name="dataServices">Tipo de visita</param> /// <param name="region">Region</param> /// <param name="manager">Manager</param> public VisitTypeViewModel(IDataServices dataServices, IRegionManager region, IEventManager manager, IDialogService dialogService) : base(String.Empty, dataServices, region, manager, dialogService) { GridIdentifier = KarveCommon.Generic.GridIdentifiers.VisitType; }
public AirportBusinessService(IDataServices dataServices) { DataServices = dataServices; }
/// <summary> /// CreditCardView Model. /// </summary> /// <param name="dataServices">DataServices</param> /// <param name="region"> RegionManager to support further navigation</param> /// <param name="manager">Event Manager for the communiction between view modules.</param> public CreditCardViewModel(IDataServices dataServices, IRegionManager region, IEventManager manager, IDialogService dialogService) : base(String.Empty, dataServices, region, manager, dialogService) { GridIdentifier = KarveCommon.Generic.GridIdentifiers.HelperCreditCard; }
public SupplierCurrencyViewModel(IDataServices dataServices, IRegionManager region, IEventManager manager, IDialogService dialogService) : base(string.Empty, dataServices, region, manager, dialogService) { }
void IProvider.Initialize(IDataServices dataServices, object connection) { DbConnection connection2; Type type; if (dataServices == null) { throw Error.ArgumentNull("dataServices"); } services = dataServices; DbTransaction transaction = null; string fileOrServerOrConnectionString = connection as string; if (fileOrServerOrConnectionString != null) { string connectionString = GetConnectionString(fileOrServerOrConnectionString); dbName = GetDatabaseName(connectionString); if (dbName.EndsWith(".sdf", StringComparison.OrdinalIgnoreCase)) { Mode = ProviderMode.SqlCE; } if (Mode == ProviderMode.SqlCE) { DbProviderFactory provider = GetProvider("System.Data.SqlServerCe.3.5"); if (provider == null) { throw Error.ProviderNotInstalled(dbName, "System.Data.SqlServerCe.3.5"); } connection2 = provider.CreateConnection(); } else { connection2 = new SqlConnection(); } connection2.ConnectionString = connectionString; } else { transaction = connection as SqlTransaction; if ((transaction == null) && (connection.GetType().FullName == "System.Data.SqlServerCe.SqlCeTransaction")) { transaction = connection as DbTransaction; } if (transaction != null) { connection = transaction.Connection; } connection2 = connection as DbConnection; if (connection2 == null) { throw Error.InvalidConnectionArgument("connection"); } if (connection2.GetType().FullName == "System.Data.SqlServerCe.SqlCeConnection") { Mode = ProviderMode.SqlCE; } dbName = GetDatabaseName(connection2.ConnectionString); } using (DbCommand command = connection2.CreateCommand()) { CommandTimeout = command.CommandTimeout; } int maxUsers = 1; if (connection2.ConnectionString.Contains("MultipleActiveResultSets")) { DbConnectionStringBuilder builder = new DbConnectionStringBuilder(); builder.ConnectionString = connection2.ConnectionString; if ( string.Compare((string)builder["MultipleActiveResultSets"], "true", StringComparison.OrdinalIgnoreCase) == 0) { maxUsers = 10; } } conManager = new SqlConnectionManager(this, connection2, maxUsers); if (transaction != null) { conManager.Transaction = transaction; } if (Mode == ProviderMode.SqlCE) { type = connection2.GetType().Module.GetType("System.Data.SqlServerCe.SqlCeDataReader"); } else if (connection2 is SqlConnection) { type = typeof(SqlDataReader); } else { type = typeof(DbDataReader); } readerCompiler = new ObjectReaderCompiler(type, services); //InvokeIProviderMethod("Initialize", new[] { SourceService(conManager.Connection), connection }); }
public DataBaseObjectDataProvider(IDataServices dataServices) { _dataServices = dataServices; }
/// <summary> /// InvoiceInfoViewModel. /// </summary> /// <param name="dataServices">DataServices</param> /// <param name="dialogServices"></param> /// <param name="manager"></param> /// <param name="container"></param> /// <param name="regionManager"></param> /// <param name="controller"></param> public InvoiceInfoViewModel(IDataServices dataServices, IDialogService dialogServices, IEventManager manager, IConfigurationService configurationService, IRegionManager regionManager, IInteractionRequestController controller) : base(dataServices, controller, dialogServices, manager, configurationService) { _dataServices = dataServices; _regionManager = regionManager; _invoiceDataService = _dataServices.GetInvoiceDataServices(); LineVisible = true; CollectionView = new ObservableCollection <InvoiceSummaryViewObject>(); AssistMapper = _dataServices.GetAssistDataServices().Mapper; ItemChangedCommand = new Prism.Commands.DelegateCommand <IDictionary <string, object> >(OnChangedCommand); NavigateCommand = new DelegateCommand <object>(OnNavigate); AssistCommand = new DelegateCommand <object>(OnAssistCommand); AddNewClientCommand = new DelegateCommand <object>(OnAddNewClientCommand); OpenContractCommand = new DelegateCommand <object>(OnOpenContract); OpenVehiclesCommand = new DelegateCommand <object>(OnOpenVehicles); AssistExecuted += OnAssistExecuted; CompanyName = String.Empty; AddressName = String.Empty; List <string> colList; var genericInovice = new InvoiceSummaryViewObject(); colList = genericInovice.GetType().GetProperties().Select(value => value.Name).ToList(); GridColumns = new List <string>() { "AgreementCode", "VehicleCode", "Opciones", "Description", "Quantity", "Price", "Discount", "Subtotal", "Unity", "Iva" }; /* * This is a cell grid presentation item */ var presenter = new ObservableCollection <CellPresenterItem>() { new NavigationAwareItem() { DataTemplateName = "NavigateInvoiceItem", MappingName = "AgreementCode", RegionName = RegionNames.LineRegion }, new NavigationAwareItem() { DataTemplateName = "NavigateVehicleItem", MappingName = "VehicleCode", RegionName = RegionNames.LineRegion } }; CellGridPresentation = presenter; EventManager.RegisterObserverSubsystem(InvoiceModule.InvoiceSubSystem, this); var gid = Guid.NewGuid(); GridIdentifier = GridIdentifiers.InvoiceLineGrids; ViewModelUri = new Uri("karve://invoice/viewmodel?id=" + gid.ToString()); MailBoxHandler += IncomingMailBox; SubSystem = DataSubSystem.InvoiceSubsystem; RegisterMailBox(ViewModelUri.ToString()); }
public PgsqlQueryConverter(IDataServices services, ITypeSystemProvider typeProvider, Translator translator, SqlFactory sql) : base(services, typeProvider, translator, sql) { }
private ConcreteDomainFactory(IDataServices services) : base(services) { _services = services; }
/// <summary> /// Save a data command for the configuration manager. /// </summary> /// <param name="dataServices"></param> /// <param name="careKeeperService"></param> /// <param name="eventManager"></param> /// <param name="configurationService"></param> public SaveDataCommand(IDataServices dataServices, ICareKeeperService careKeeperService, IEventManager eventManager, IConfigurationService configurationService) : this(dataServices, careKeeperService, configurationService) { _eventManager = eventManager; InitHandlers(); }
protected override AbstractDomainWrapperFactory CreateAbstractFactory(IDataServices services) { return(new ConcreteDomainFactory(services)); }
public override void ExecutePayload(IDataServices services, IEventManager manager, ref DataPayLoad payLoad) { _companyDataServices = services.GetCompanyDataServices(); ToolbarInitializationNotifier = NotifyTaskCompletion.Create <DataPayLoad>(HandleSaveOrUpdate(payLoad), ExecutedPayloadHandler); }
/// <summary> /// KarveToolBarViewModel is a view model to modle the toolbar behaviour. /// </summary> /// <param name="dataServices">Service for fetching datas</param> /// <param name="eventManager">Service for communicate with other view models</param> /// <param name="careKeeper">Service for caring command and storing/undoing command</param> /// <param name="regionManager">Service for region handling</param> /// <param name="dialogService">Service for spotting the dialog</param> /// <param name="configurationService">Service for the configuraration parameters</param> public KarveToolBarViewModel(IDataServices dataServices, IEventManager eventManager, ICareKeeperService careKeeper, IRegionManager regionManager, IDialogService dialogService, IConfigurationService configurationService) : base(dataServices, null, dialogService, configurationService) { this._dictionary = SubsystemFactory.GetSubsytem(); this._dataServices = dataServices; this._dialogService = dialogService; this._configurationService = configurationService; this._eventManager = eventManager; this._eventManager.RegisterObserverToolBar(this); this._careKeeper = careKeeper; this.SaveCommand = new DelegateCommand(DoSaveCommand); this.NewCommand = new DelegateCommand(DoNewCommand); this.DeleteCommand = new DelegateCommand <object>(DoDeleteCommand); this._dataServices = dataServices; this._configurationService = configurationService; this._eventManager = eventManager; this._eventManager.RegisterObserverToolBar(this); this.CurrentSaveImagePath = currentSaveImage; _regionManager = regionManager; _states = ToolbarStates.None; _noActiveValue = string.Empty; this.IsSaveEnabled = false; this.IsDeleteEnabled = false; this.IsNewEnabled = false; ConfirmationRequest = new InteractionRequest <IConfirmation>(); Confirmation request = new Confirmation { Title = "Confirmacion", Content = confirmDelete }; ViewModelUri = new Uri("karve://toolbar/viewmodel?id=" + UniqueId); ConfirmationCommand = new DelegateCommand(() => { // string noActiveValue = configurationService.GetPrimaryKeyValue(); request.Content = confirmDelete; ConfirmationRequest.Raise(request); if (request.Confirmed) { string value = string.Empty; var singleView = _regionManager.Regions[RegionNames.TabRegion].ActiveViews.FirstOrDefault(); if (singleView != null) { var headerProp = singleView.GetType().GetProperty("Header"); if (headerProp != null) { if (headerProp.GetValue(singleView) is string header) { value = header.Split('.')[0]; } } } DeleteCommand.Execute(value); } }); SaveValueCommand = new DelegateCommand(() => { request.Content = confirmSave; ConfirmationRequest.Raise(request); if (request.Confirmed) { SaveCommand.Execute(); } else { this.CurrentSaveImagePath = KarveToolBarViewModel.currentSaveImage; } }); AddValidationChain(); _uniqueId = ObserverName + Guid.NewGuid(); }
public TestController(IDataServices dataServices) { _dataServices = dataServices; }
public PaymentFormViewModel(IDataServices dataServices, IRegionManager region, IEventManager manager, IDialogService dialogService) : base(string.Empty, dataServices, region, manager, dialogService) { GridIdentifier = KarveCommon.Generic.GridIdentifiers.PaymentFormGrid; }