/// <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)
{
}
