/// <summary> /// Processa a ação de exclusão. /// </summary> /// <param name="action"></param> private void ProcessDeleteAction(PersistenceAction action) { var observerManager = Colosoft.Query.RecordObserverManager.Instance; if (observerManager == null) { return; } Colosoft.Reflection.TypeName typeName = null; Query.Record record; Query.RecordKey recordKey; var deleteActionResult = action.Parameters.Where(f => f.Name == DeleteActionResultParameterName).Select(f => (IDeleteActionResult)f.Value).FirstOrDefault(); IEnumerable <Colosoft.Query.RecordKey> recordKeys = null; if (deleteActionResult == null) { typeName = GetActionRecord(action, out record, out recordKey); recordKeys = new Colosoft.Query.RecordKey[] { recordKey }; } else { typeName = new Reflection.TypeName(action.EntityFullName); recordKeys = deleteActionResult.RecordKeys; } observerManager.NotifyRecordDeleted(typeName, recordKeys); }
/// <summary> /// Recupera o registrao associado com a ação. /// </summary> /// <param name="action">Instancia da ação de persistencia realizada.</param> /// <param name="record">Registro gerado.</param> /// <param name="recordKey">Chave do registro.</param> /// <returns>Nome do tipo associado.</returns> private Colosoft.Reflection.TypeName GetActionRecord(PersistenceAction action, out Query.Record record, out Query.RecordKey recordKey) { var typeName = new Reflection.TypeName(action.EntityFullName); var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName); var typeFields = GetRecordFields(action.EntityFullName, typeMetadata); var fields = new List <Query.Record.Field>(); var recordValues = new List <object>(); foreach (var actionParameter in action.Parameters) { var indexOf = 0; for (; indexOf < typeFields.Count; indexOf++) { if (typeFields[indexOf].Name == actionParameter.Name) { break; } } if (indexOf < typeFields.Count) { fields.Add(new Query.Record.Field(typeFields[indexOf].Name, typeFields[indexOf].Type)); recordValues.Add(actionParameter.Value); } } if (typeMetadata.IsVersioned && !fields.Any(f => f.Name == "RowVersion")) { fields.Add(new Query.Record.Field("RowVersion", typeof(long))); recordValues.Add(action.RowVersion); } var recordDescriptor = new Query.Record.RecordDescriptor("default", fields); record = recordDescriptor.CreateRecord(recordValues.ToArray()); recordKey = RecordKeyFactory.Create(typeName, record); return(typeName); }
/// <summary> /// Processa a ações informada. /// </summary> /// <param name="action"></param> private void ProcessAction(PersistenceAction action) { if (action.BeforeActions.Count > 0) { NavigateActions(action.BeforeActions); } switch (action.Type) { case PersistenceActionType.Insert: ProcessInsertAction(action); break; case PersistenceActionType.Update: ProcessUpdateAction(action); break; case PersistenceActionType.Delete: ProcessDeleteAction(action); break; } if (action.AfterActions.Count > 0) { NavigateActions(action.AfterActions); } }
private IEnumerable <object> ListObjects(object filterEntity, PersistenceAction action, bool loadComposition = false, int recordLimit = 0, bool onlyListableAttributes = false, string showAttributes = null, Dictionary <string, double[]> rangeValues = null, string groupAttributes = null, string sortAttributes = null, bool orderDescending = false) { IEnumerable <object> returnList = null; // Getting SQL statement from Helper var sqlInstruction = EntitySqlParser.ParseEntity(filterEntity, engine, action, filterEntity, recordLimit, onlyListableAttributes, showAttributes, rangeValues, groupAttributes, sortAttributes, orderDescending, _readUncommited); if (keepConnection || Connect()) { // Getting database return using Dapper returnList = ExecuteQuery(filterEntity.GetType(), sqlInstruction); } if (!keepConnection) { Disconnect(); } // Perform the composition data load when exists (Eager Loading) if (loadComposition && (returnList != null) && returnList.Any()) { var itemProps = returnList.First().GetType().GetProperties(); foreach (var item in returnList) { FillComposition(item, itemProps); } } return(returnList); }
/// <summary> /// Cria o parser para a açõa informada. /// </summary> /// <param name="action"></param> /// <param name="providerName">Nome do provider associado.</param> /// <returns></returns> protected override PersistenceSqlParser CreateParser(PersistenceAction action, string providerName) { return(new DefaultPersistenceSqlParser(Translator, TypeSchema, new Query.Database.Generic.MsSql.MsSqlTakeParametersParser()) { Action = action, PrimaryKeyRepository = GetKeyRepository(providerName) }); }
/// <summary> /// Cria o parser para a açõa informada. /// </summary> /// <param name="action"></param> /// <param name="providerName">Nome do provider associado.</param> /// <returns></returns> protected override PersistenceSqlParser CreateParser(PersistenceAction action, string providerName) { return(new MySqlPersistenceSqlParser(Translator, TypeSchema) { Action = action, PrimaryKeyRepository = GetKeyRepository(providerName) }); }
/// <summary> /// Executa uma procedure no banco de dados. /// </summary> /// <param name="action">Informação da ação de persistência.</param> /// <param name="transaction">Transação de persistência.</param> /// <returns>Retorna resultado da ação de persistência.</returns> protected virtual PersistenceActionResult ExecuteProcedureCommand(PersistenceAction action, IPersistenceTransactionExecuter transaction) { var trans = (PersistenceTransactionExecuter)transaction; var outputParametersIndexes = new List <int>(); var procedure = CreateProcedure(action); if (action.Parameters != null) { for (int i = 0; i < action.Parameters.Count; i++) { var paramDirection = (System.Data.ParameterDirection)((int)action.Parameters[i].Direction); procedure.AddParameter(new GDAParameter(action.Parameters[i].Name, action.Parameters[i].Value, paramDirection) { Size = action.Parameters[i].Size }); if (action.Parameters[i].Direction != Colosoft.Query.ParameterDirection.Input) { outputParametersIndexes.Add(i); } } } var da = new DataAccess(trans.Transaction.ProviderConfiguration); object result = null; try { result = da.ExecuteScalar(trans.Transaction, procedure); } catch (GDAException ex) { Exception ex2 = ex; if (ex.InnerException is System.Data.Common.DbException || ex.InnerException is DataException) { ex2 = ex.InnerException; } ex2 = new DataException(ResourceMessageFormatter.Create(() => Properties.Resources.Exception_ExecuteDatabaseCommand, ex2.Message).Format(), ex2); action.NotifyError(ex2); return(new PersistenceActionResult { Success = false, AffectedRows = -1, FailureMessage = ex2.Message }); } foreach (int index in outputParametersIndexes) { action.Parameters[index].Value = procedure[index]; } action.NotifyExecution(); var presult = new PersistenceActionResult() { ActionId = action.ActionId, Parameters = action.Parameters.ToArray(), Result = result, Success = true }; return(presult); }
/// <summary> /// Executa a ação para apagar os ados do registro no cache. /// </summary> /// <param name="action"></param> /// <returns></returns> private PersistenceActionResult ExecuteDeleteAction(PersistenceAction action) { var typeMetadata = _typeSchema.GetTypeMetadata(action.EntityFullName); if (typeMetadata == null) { return new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_TypeMetadataNotFound, action.EntityFullName).Format(), } } ; var query = GetActionQuery(action, typeMetadata).CreateQueryInfo(); Queries.QueryResultSet queryResult = null; try { queryResult = ((CacheDataSource)_sourceContext.DataSource).ExecuteInCache(query); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_ExecuteQueryInCacheError, Colosoft.Diagnostics.ExceptionFormatter.FormatException(ex, true)).Format() }); } var typeName = new Colosoft.Reflection.TypeName(action.EntityFullName); var keyGenerator = _keyFactory.Value.CreateGenerator(typeName); var recordKeys = new List <RecordKey>(); using (var recordEnumerator = new Colosoft.Caching.Queries.QueryResultSetRecordEnumerator(_typeSchema, Cache, queryResult, query)) { while (recordEnumerator.MoveNext()) { recordKeys.Add(RecordKeyFactory.Instance.Create(typeName, recordEnumerator.Current)); try { Cache.Remove(recordEnumerator.CurrentKey, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation)); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ex.Message }); } } } return(new PersistenceActionResult { Success = true, Result = new DeleteActionResult(recordKeys) }); }
/// <summary> /// Método que troca os ids virtuais por ids reais /// </summary> /// <param name="action">Ação de persistência sobre a qual será executada as trocas</param> /// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param> private void SwapIds(PersistenceAction action, Dictionary <int, int> primaryKeyMappings) { var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName); for (int i = 0; i < action.Parameters.Count; i++) { var propertyMetadata = typeMetadata[action.Parameters[i].Name]; if (propertyMetadata == null) { continue; } if (propertyMetadata.IsForeignKey || propertyMetadata.ForeignKeyTypeCode.HasValue || propertyMetadata.ParameterType == PersistenceParameterType.IdentityKey) { int realId; int virtualId = 0; object value = action.Parameters[i].Value; if (value is int) { virtualId = (int)value; } else if (value is uint) { virtualId = (int)(uint)value; } else { if (value == null) { continue; } var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(int)); if (converter == null && !converter.CanConvertFrom(value.GetType())) { continue; } try { virtualId = (int)converter.ConvertFrom(value); } catch (NotSupportedException) { continue; } } if (primaryKeyMappings.TryGetValue(virtualId, out realId)) { action.Parameters[i].Value = realId; } } } }
/// <summary> /// Gera o id em caso de inserção /// </summary> /// <param name="action">Ação a ser executada</param> /// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param> /// <param name="providerName">Nome do provedor.</param> /// <param name="transaction">Transação.</param> private void GetId(PersistenceAction action, Dictionary <int, int> primaryKeyMappings, string providerName, IPersistenceTransactionExecuter transaction) { var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName); if (action.Type == PersistenceActionType.Insert && !GetKeyRepository(providerName).IsPosCommand(typeMetadata.FullName)) { for (int i = 0; i < action.Parameters.Count; i++) { var propertyMetadata = typeMetadata[action.Parameters[i].Name]; if (propertyMetadata.ParameterType == PersistenceParameterType.IdentityKey) { int virtualId = 0; object value = action.Parameters[i].Value; if (value is int) { virtualId = (int)value; } else { var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(int)); if (converter == null && !converter.CanConvertFrom(value.GetType())) { continue; } try { virtualId = (int)converter.ConvertFrom(value); } catch (NotSupportedException) { continue; } } if (virtualId <= 0) { var keyRepository = GetKeyRepository(providerName); var key = new PersistenceParameter(action.Parameters[i].Name, keyRepository.GetPrimaryKey(transaction, typeMetadata.FullName)); action.Parameters[i] = key; primaryKeyMappings.Add(virtualId, (int)key.Value); } else { throw new Exception(ResourceMessageFormatter.Create(() => Properties.Resources.ForeignMemberNotInserted, propertyMetadata.Name, virtualId.ToString(), typeMetadata.FullName).Format()); } return; } } } }
/// <summary> /// Processa a ação de inserção. /// </summary> /// <param name="action"></param> private void ProcessInsertAction(PersistenceAction action) { var observerManager = Colosoft.Query.RecordObserverManager.Instance; if (observerManager == null) { return; } Colosoft.Reflection.TypeName typeName = null; Query.Record record; Query.RecordKey recordKey; typeName = GetActionRecord(action, out record, out recordKey); observerManager.NotifyRecordsInserted(typeName, new Colosoft.Query.Record[] { record }); }
private void PersistReplicasAsync(object param) { try { foreach (var connString in _replicaConnStrings) { ParallelParam parallelParam = param as ParallelParam; object entity = parallelParam.Param1; PersistenceAction action = (PersistenceAction)parallelParam.Param2; bool persistComposition = false; if (parallelParam.Param3 != null) { persistComposition = (bool)parallelParam.Param3; } object filterEntity = null; if (parallelParam.Param4 != null) { filterEntity = parallelParam.Param4; } using (var repos = new GenericRepository <T>(DatabaseEngine.SQLServer, _connString)) { switch (action) { case PersistenceAction.Create: repos.CreateObject(entity, persistComposition, connString, true); break; case PersistenceAction.Edit: repos.EditObject(entity, filterEntity, persistComposition, connString, true); break; case PersistenceAction.Delete: repos.Delete(entity, connString, true); break; } } } } catch (Exception ex) { RegisterException("PersistReplicas", ex, param); } }
public override void Append(PersistenceAction action) { var ac = (SqlPersistenceAction)action; if (_builder == null) { _builder = new StringBuilder(); } else { _builder.AppendLine(";"); } // Use the finalized commant text _builder.Append(ac.Command.CommandText); this.Command.CommandText = _builder == null ? string.Empty : _builder.ToString(); }
/// <summary> /// Recupera usado para recupera a consulta associada com a ação. /// </summary> /// <param name="action"></param> /// <param name="typeMetadata"></param> /// <returns></returns> private Query.Queryable GetActionQuery(PersistenceAction action, Colosoft.Data.Schema.ITypeMetadata typeMetadata) { var query = _sourceContext.CreateQuery(); StringBuilder wherePart = new StringBuilder(); List <QueryParameter> wherePartParameters = new List <QueryParameter>(); bool isFirstWhere = true; for (int i = 0; i < action.Parameters.Count; i++) { var propertyMetadata = typeMetadata[action.Parameters[i].Name]; if (propertyMetadata != null && (propertyMetadata.ParameterType == Colosoft.Data.Schema.PersistenceParameterType.IdentityKey || propertyMetadata.ParameterType == Colosoft.Data.Schema.PersistenceParameterType.Key)) { if (action.Conditional != null) { continue; } wherePartParameters.Add(new QueryParameter("?" + action.Parameters[i].Name, action.Parameters[i].Value)); if (!isFirstWhere) { wherePart.Append(" && "); } else { isFirstWhere = false; } wherePart.Append(action.Parameters[i].Name).Append("=?").Append(action.Parameters[i].Name); } } if (action.Conditional == null && wherePart.Length > 0) { query.WhereClause = ConditionalContainer.Parse(wherePart.ToString(), wherePartParameters.ToArray()); } else if (action.Conditional != null) { query.WhereClause = action.Conditional; } query.From(new EntityInfo() { Alias = null, FullName = typeMetadata.FullName }); return(query); }
/// <summary> /// Processa a ação de atualização. /// </summary> /// <param name="action"></param> private void ProcessUpdateAction(PersistenceAction action) { var observerManager = Colosoft.Query.RecordObserverManager.Instance; if (observerManager == null) { return; } Colosoft.Reflection.TypeName typeName = null; Query.Record record; Query.RecordKey recordKey; typeName = GetActionRecord(action, out record, out recordKey); var notifier = observerManager.GetRecordChangedNotifier(typeName, recordKey); if (notifier.IsValid) { notifier.Notify(record); } }
/// <summary> /// Executa uma procedure no banco de dados. /// </summary> /// <param name="action">Informação da ação de persistência.</param> /// <param name="transaction">Transação de persistência.</param> /// <returns>Retorna resultado da ação de persistência.</returns> protected override PersistenceActionResult ExecuteProcedureCommand(PersistenceAction action, IPersistenceTransactionExecuter transaction) { var trans = (PersistenceTransactionExecuter)transaction; DataAccess da = trans != null ? new DataAccess(trans.Transaction.ProviderConfiguration) : new DataAccess(); var indexes = new List <int>(); var storedProcedureName = (Query.Database.TranslatedStoredProcedureName)Translator.GetName(action.StoredProcedureName); var script = "BEGIN " + (!string.IsNullOrEmpty(storedProcedureName.Schema) ? string.Format("\"{0}\".\"{1}\"", storedProcedureName.Schema, storedProcedureName.Name) : string.Format("\"{0}\"", storedProcedureName.Name)) + " ("; for (var i = 1; i <= action.Parameters.Count; i++) { script += ":" + i + ","; } script = (action.Parameters.Count > 0 ? script.Substring(0, script.Length - 1) : script) + "); END;"; var parameters = new GDA.Collections.GDAParameterCollection(); for (int i = 0; i < action.Parameters.Count; i++) { var paramDirection = (System.Data.ParameterDirection)((int)action.Parameters[i].Direction); var value = action.Parameters[i].Value; parameters.Add(CreateParameter(":" + (i + 1), value, action.Parameters[i].Size, paramDirection)); if (action.Parameters[i].Direction != Query.ParameterDirection.Input) { indexes.Add(i); } } var parameters2 = parameters.ToArray(); var result = da.ExecuteCommand(trans.Transaction, CommandType.Text, action.CommandTimeout, script, parameters2); foreach (int index in indexes) { action.Parameters[index].Value = parameters2[index].Value; } var presult = new PersistenceActionResult() { ActionId = action.ActionId, Parameters = action.Parameters.ToArray(), Result = result, Success = true }; return(presult); }
/// <summary> /// Navega pelas as ações. /// </summary> /// <param name="action">Instancia da ação.</param> /// <param name="state">Estado que está sendo usado na validação.</param> /// <param name="result">Resultado da validação.</param> private void NavigatePersistenceAction(PersistenceAction action, ValidationState state, PersistenceSessionValidateResult result) { if (action.Type == PersistenceActionType.Insert) { int virtualId = 0; PersistenceAction duplicateAction = null; IMessageFormattable message = null; if (!state.ValidateInsertionAction(action, out virtualId, out duplicateAction, out message)) { result.AddError(action, message); } } foreach (var i in action.BeforeActions) { NavigatePersistenceAction(i, state, result); } foreach (var i in action.AfterActions) { NavigatePersistenceAction(i, state, result); } }
/// <summary> /// Recupera a coluna identidade associada com entidade da ação de persistencia. /// </summary> /// <param name="action"></param> /// <returns></returns> protected IPropertyMetadata GetIdentityProperty(PersistenceAction action) { IPropertyMetadata property = null; lock (_typesIdentityProperty) if (_typesIdentityProperty.TryGetValue(action.EntityFullName, out property)) { return(property); } var typeMetadata = TypeSchema.GetTypeMetadata(action.EntityFullName); if (typeMetadata != null) { property = typeMetadata.Where(f => f.ParameterType == PersistenceParameterType.IdentityKey).FirstOrDefault(); } lock (_typesIdentityProperty) if (!_typesIdentityProperty.ContainsKey(action.EntityFullName)) { _typesIdentityProperty.Add(action.EntityFullName, property); } return(property); }
/// <summary> /// Realiza a troca das referencias de novos Uids. /// </summary> /// <param name="action">Ação de persistência sobre a qual será executada as trocas</param> /// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param> private void SwapNewUidReferences(PersistenceAction action, Dictionary <int, int> primaryKeyMappings) { int realId = 0; foreach (var parameter in action.Parameters) { if (parameter.Value is NewUidReference) { var virtualId = ((NewUidReference)parameter.Value).Uid; if (primaryKeyMappings.TryGetValue(virtualId, out realId)) { parameter.Value = realId; } else { throw new Colosoft.DetailsException(string.Format("Not found real value for NewUidReference '{0}' from parameter '{1}'", virtualId, parameter.Name).GetFormatter()); } } } if (action.Conditional != null) { foreach (var parameter in action.Conditional) { if (parameter.Value is NewUidReference) { var virtualId = ((NewUidReference)parameter.Value).Uid; if (primaryKeyMappings.TryGetValue(virtualId, out realId)) { parameter.Value = realId; } else { throw new Colosoft.DetailsException(string.Format("Not found real value for NewUidReference '{0}' from parameter '{1}'", virtualId, parameter.Name).GetFormatter()); } } } } }
private void PersistComposition(object entity, PersistenceAction action, object filterEntity = null) { try { List <string> childEntityCommands = ParseComposition(entity, action, filterEntity); foreach (var cmd in childEntityCommands) { ExecuteCommand(cmd); } if (base.transactionControl != null) { base.CommitTransaction(); } if (!keepConnection) { base.Disconnect(); } // Efetua a limpeza do cache para a entidade em questão var isCacheable = (entity.GetType().GetCustomAttribute(typeof(CacheableAttribute)) != null); if (isCacheable) { DataCache.Del(entity, true); } } catch (Exception) { if (base.transactionControl != null) { base.CancelTransaction(); } } }
/// <summary> /// Executa uma ação de persistência no banco de dados /// </summary> /// <param name="commandText">Texto do comando a ser executado</param> /// <param name="action">Ação a ser executada</param> /// <param name="transaction">Objeto de transação</param> /// <param name="primaryKeyMappings">Dicionário que mapeia ids virtuais para reais</param> /// <returns>Retorna resultado da ação de persistência</returns> protected abstract PersistenceActionResult ExecuteCommand(string commandText, PersistenceAction action, IPersistenceTransactionExecuter transaction, Dictionary <int, int> primaryKeyMappings);
/// <summary> /// Executa a ação para atualizar os dados do registro no cache. /// </summary> /// <param name="action"></param> /// <returns></returns> private PersistenceActionResult ExecuteUpdateAction(PersistenceAction action) { var typeName = new Reflection.TypeName(action.EntityFullName); var typeMetadata = _typeSchema.GetTypeMetadata(action.EntityFullName); if (typeMetadata == null) { return new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_TypeMetadataNotFound, action.EntityFullName).Format(), } } ; var query = GetActionQuery(action, typeMetadata).CreateQueryInfo(); Queries.QueryResultSet queryResult = null; try { queryResult = ((CacheDataSource)_sourceContext.DataSource).ExecuteInCache(query); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_ExecuteQueryInCacheError, Colosoft.Diagnostics.ExceptionFormatter.FormatException(ex, true)).Format() }); } Colosoft.Query.Record.RecordDescriptor recordDescriptor = null; try { recordDescriptor = new Colosoft.Query.Record.RecordDescriptor(action.EntityFullName, GetRecordFields(action.EntityFullName, typeMetadata)); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ex.Message }); } var keyGenerator = _keyFactory.Value.CreateGenerator(typeName); var typeInfoMap = Cache.GetTypeInfoMap(); var keysResult = queryResult.SearchKeysResult.ToArray(); if (keysResult.Length > 0) { foreach (var key in keysResult) { var record = CacheDataSource.CreateRecord(Cache, key, ref recordDescriptor, query); var recordValues = new object[recordDescriptor.Count]; record.GetValues(recordValues); foreach (var actionParameter in action.Parameters) { var indexOf = 0; for (; indexOf < recordDescriptor.Count; indexOf++) { if (StringComparer.InvariantCultureIgnoreCase.Equals(recordDescriptor[indexOf].Name, actionParameter.Name)) { break; } } if (indexOf < recordDescriptor.Count) { recordValues[indexOf] = actionParameter.Value; } } var newRecord = new CacheItemRecord(new Reflection.TypeName(action.EntityFullName), recordValues, recordDescriptor); var newKey = keyGenerator.GetKey(newRecord); try { var queryInfo = GetCacheEntryQueryInfo(Cache, typeInfoMap, newRecord); Cache.Remove(key, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation)); var insertResult = Cache.Insert(newKey, newRecord, null, null, new Colosoft.Caching.Policies.PriorityEvictionHint(CacheItemPriority.Normal), null, null, queryInfo, new BitSet(), null, 0, LockAccessType.IGNORE_LOCK, null, null, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation)); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ex.Message }); } } } else { } return(new PersistenceActionResult { Success = true }); }
/// <summary> /// Valida a ações de inserção. /// </summary> /// <param name="action"></param> /// <param name="virtualId"></param> /// <param name="duplicateAction">Instancia da ação duplicada.</param> /// <param name="message">Mensagem de retorno.</param> /// <returns></returns> public bool ValidateInsertionAction(Data.PersistenceAction action, out int virtualId, out PersistenceAction duplicateAction, out IMessageFormattable message) { var identityProperty = _validator.GetIdentityProperty(action); if (identityProperty == null) { duplicateAction = null; virtualId = 0; message = null; return(true); } var identityParameter = action.Parameters.Where(f => f.Name == identityProperty.Name).FirstOrDefault(); if (identityParameter != null) { object value = identityParameter.Value; if (value is int) { virtualId = (int)value; } else if (value is uint) { virtualId = (int)(uint)value; } else { var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(int)); if (converter == null && !converter.CanConvertFrom(value.GetType())) { duplicateAction = null; virtualId = 0; message = null; return(true); } try { virtualId = (int)converter.ConvertFrom(value); } catch (NotSupportedException) { duplicateAction = null; virtualId = 0; message = null; return(true); } } if (virtualId > 0) { message = ResourceMessageFormatter.Create(() => Properties.Resources.SchemaPersistenceSessionValidator_NonNegativeIdentityProperty, virtualId, identityProperty.Name, action.EntityFullName); duplicateAction = null; return(false); } if (_insertActions.TryGetValue(virtualId, out duplicateAction)) { message = ResourceMessageFormatter.Create(() => Properties.Resources.SchemaPersistenceSessionValidator_DuplicateInsertionAction, action.EntityFullName, virtualId); return(false); } _insertActions.Add(virtualId, action); } else { virtualId = 0; } message = null; duplicateAction = null; return(true); }
/// <summary> /// Executa a ação informada. /// </summary> /// <param name="action"></param> /// <param name="existErrors">Identifica se existem erros na execução da açõa.</param> /// <returns></returns> private PersistenceActionResult Execute(PersistenceAction action, out bool existErrors) { PersistenceActionResult[] beforeActions = null; if (action.BeforeActions.Count > 0) { beforeActions = Execute(action.BeforeActions.ToArray(), out existErrors); if (existErrors) { return(new PersistenceActionResult { Success = false, FailureMessage = beforeActions.Where(f => !f.Success).FirstOrDefault().FailureMessage, BeforeActions = beforeActions }); } } PersistenceActionResult result = null; try { switch (action.Type) { case PersistenceActionType.Insert: result = ExecuteInsertAction(action); break; case PersistenceActionType.Update: result = ExecuteUpdateAction(action); break; case PersistenceActionType.Delete: result = ExecuteDeleteAction(action); break; default: result = new PersistenceActionResult { Success = true }; break; } } catch (Exception ex) { result = new PersistenceActionResult { Success = false, FailureMessage = ex.Message }; } if (!result.Success) { existErrors = true; } result.BeforeActions = beforeActions; if (result.Success && action.AfterActions.Count > 0) { result.AfterActions = Execute(action.AfterActions.ToArray(), out existErrors); if (existErrors) { result.FailureMessage = result.AfterActions.Where(f => !f.Success).FirstOrDefault().FailureMessage; result.Success = false; return(result); } } existErrors = false; return(result); }
/// <summary> /// Executa a ação para inserir um novo registro no cache. /// </summary> /// <param name="action"></param> /// <returns></returns> private PersistenceActionResult ExecuteInsertAction(PersistenceAction action) { var typeMetadata = _typeSchema.GetTypeMetadata(action.EntityFullName); if (typeMetadata == null) { return new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_TypeMetadataNotFound, action.EntityFullName).Format(), } } ; IEnumerable <Colosoft.Query.Record.Field> recordFields = null; try { recordFields = GetRecordFields(action.EntityFullName, typeMetadata); } catch (Exception ex) { return(new PersistenceActionResult { Success = false, FailureMessage = ex.Message }); } var recordDescriptor = new Colosoft.Query.Record.RecordDescriptor(action.EntityFullName, recordFields); var recordValues = new object[recordDescriptor.Count]; foreach (var actionParameter in action.Parameters) { var indexOf = 0; for (; indexOf < recordDescriptor.Count; indexOf++) { if (StringComparer.InvariantCultureIgnoreCase.Equals(recordDescriptor[indexOf].Name, actionParameter.Name)) { break; } } if (indexOf < recordDescriptor.Count) { recordValues[indexOf] = actionParameter.Value; } else { return new PersistenceActionResult { Success = false, FailureMessage = ResourceMessageFormatter.Create(() => Properties.Resources.CachePersistenceExecuter_PropertyMetadataNotFound, actionParameter.Name, action.EntityFullName).Format() } }; } var record = new CacheItemRecord(new Reflection.TypeName(action.EntityFullName), recordValues, recordDescriptor); var typeName = new Reflection.TypeName(action.EntityFullName); var keyGenerator = _keyFactory.Value.CreateGenerator(typeName); var key = keyGenerator.GetKey(record); var queryInfo = GetCacheEntryQueryInfo(Cache, Cache.GetTypeInfoMap(), record); var insertResult = Cache.Insert(key, record, null, null, new Colosoft.Caching.Policies.PriorityEvictionHint(CacheItemPriority.Normal), null, null, queryInfo, new BitSet(), null, 0, LockAccessType.IGNORE_LOCK, null, null, new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation)); return(new PersistenceActionResult { Success = true }); }
public static Dictionary <object, object> GetPropertiesValueList(object entity, Type entityType, PropertyInfo[] entityProperties, PersistenceAction action) { var objectSQLDataRelation = new Dictionary <object, object>(); var tableAnnotation = GetTableAttribute(entityType); if (tableAnnotation != null) { var tableName = string.Empty; if (!string.IsNullOrWhiteSpace(tableAnnotation.Schema)) { tableName = string.Format("{0}.{1}", tableAnnotation.Schema, tableAnnotation.Name); } else { tableName = string.Format("{0}", tableAnnotation.Name); } objectSQLDataRelation.Add("TableName", tableName); } foreach (var prop in entityProperties) { var isAutoGenerated = prop.GetCustomAttributes().Any(atb => atb is AutoGeneratedAttribute); var columnAnnotation = prop.GetCustomAttribute(typeof(ColumnAttribute)) as ColumnAttribute; var columnName = prop.Name; if (columnAnnotation != null) { columnName = columnAnnotation.Name; } var columnValue = prop.GetValue(Convert.ChangeType(entity, entity.GetType()), null); columnValue = FormatSQLInputValue(prop, columnValue, action); if (!((action == PersistenceAction.Create) && isAutoGenerated)) { var sqlValueColumn = new KeyValuePair <object, object>(columnName, columnValue); objectSQLDataRelation.Add(prop.Name, sqlValueColumn); } } return(objectSQLDataRelation); }
private static object FormatSQLInputValue(PropertyInfo column, object columnValue, PersistenceAction action) { if (columnValue != null) { var isRequired = column.GetCustomAttributes().Any(atb => atb is RequiredAttribute); switch (columnValue.GetType().ToString()) { case SQL.DataType.Short: if (((short)columnValue == short.MinValue) && !isRequired) { columnValue = SqlDefaultValue.Null; } break; case SQL.DataType.Integer: if (((int)columnValue == int.MinValue) && !isRequired) { columnValue = SqlDefaultValue.Null; } break; case SQL.DataType.Long: if (((long)columnValue == long.MinValue) && !isRequired) { columnValue = SqlDefaultValue.Null; } break; case SQL.DataType.Boolean: columnValue = ((bool)columnValue) ? 1 : 0; break; case SQL.DataType.String: var strValue = columnValue.ToString().Replace("'", "\""); if (!string.IsNullOrWhiteSpace(strValue)) { columnValue = string.Concat("'", strValue, "'"); } else { columnValue = SqlDefaultValue.Null; } break; case SQL.DataType.DateTime: if (!(((DateTime)columnValue).Equals(DateTime.MinValue))) { columnValue = "'" + ((DateTime)columnValue).ToString(DateTimeFormat.CompleteDateTime) + "'"; } else { columnValue = SqlDefaultValue.Null; } break; case SQL.DataType.Float: if (((float)columnValue == 0) && !isRequired) { columnValue = SqlDefaultValue.Null; } else { columnValue = columnValue.ToString().Replace(",", "."); } break; case SQL.DataType.Double: if (((double)columnValue == 0) && !isRequired) { columnValue = SqlDefaultValue.Null; } else { columnValue = columnValue.ToString().Replace(",", "."); } break; } } else { columnValue = (action == PersistenceAction.Create) ? SqlDefaultValue.Null : null; } return(columnValue); }
/// <summary> /// Cria o parser para a ação informada. /// </summary> /// <param name="action"></param> /// <param name="providerName">Nome do provider associado.</param> /// <returns></returns> protected abstract PersistenceSqlParser CreateParser(PersistenceAction action, string providerName);
/// <summary> /// Cria a procedure. /// </summary> /// <param name="action"></param> /// <returns></returns> protected override GDA.GDAStoredProcedure CreateProcedure(PersistenceAction action) { var procedure = new GDA.GDAStoredProcedure((!string.IsNullOrEmpty(action.StoredProcedureName.Schema) ? string.Format("`{0}`.`{1}`", action.StoredProcedureName.Schema, action.StoredProcedureName.Name) : string.Format("`{0}`", action.StoredProcedureName.Name))); return(procedure); }
public PersistenceEvent(Entity entity, PersistenceAction action) : base(entity, action) { }