public void SaveIntoDataContext()
{
try
{
SessionDataContext.SaveChanges();
}
catch (Exception e)
{
}
}
private void SaveProduct()
{
try
{
SessionDataContext.SaveChanges();
}
catch (Exception e)
{
}
}
private ExecutionResult ExecuteConstraints(SessionDataContext ctx, SessionLocalInfo currentInfo)
{
var messages = ctx.MessageList;
// Notification des événements.
// La notification se fait encore dans le scope actif
// A partir d'ici, les événements (issues des commandes) NE SONT PLUS pris en compte car si une nouvelle commande est émise
// il faut pouvoir :
// 1 - exécuter les contraintes sur les nouvelles modifications.
// 2 - renvoyer les nouveaux évents.
// Ce qui n'est pas possible à partir d'ici puisqu'on est dans le processus gérant ces cas.
//
// Si on veut générer d'autres events, il faut s'abonner dans un autre thread (pour pouvoir créer une nouvelle session)
ctx.ReadOnly = true;
var hasInvolvedElements = false;
using (CodeMarker.MarkBlock("Session.PrepareInvolvedElements"))
{
// Récupération des éléments impactés au cours de la session
// Ne pas le faire lors des chargements des metadonnées car :
// 1 - Il n'y a pas de contraintes sur les metadonnées
// 2 - En cas de chargement d'une extension, les métadonnées ne sont pas encore accessibles et cela fait planter le code.
hasInvolvedElements = SessionDataContext.TrackingData.PrepareModelElements(IsAborted, (currentInfo.Mode & SessionMode.LoadingSchema) == SessionMode.LoadingSchema);
}
// Validation implicite sur les éléments modifiés au cours de la session
// Ce code ne doit pas se faire lorsqu'on charge les metadonnées
if (hasInvolvedElements && (currentInfo.Mode & SessionMode.SkipConstraints) != SessionMode.SkipConstraints)
{
try
{
// Vérification des contraintes implicites
using (CodeMarker.MarkBlock("Session.CheckConstraints"))
{
CheckConstraints(InvolvedElements);
}
// Une contrainte peut entrainer un rollback de la transaction
// si il retourne une erreur dans result.
ctx.Aborted = ctx.MessageList != null && ctx.MessageList.HasErrors;
}
catch (Exception ex)
{
ctx.Aborted = true;
var exception = ex;
if (exception is AggregateException)
{
exception = ((AggregateException)ex).InnerException;
}
Log(new DiagnosticMessage(MessageType.Error, exception.Message, ExceptionMessages.Diagnostic_ConstraintsProcessError, SessionDataContext.InValidationProcess, null, exception));
}
}
return(messages);
}
public void AddKeyword(string keyword)
{
KeywordHistory keywordHistory = new KeywordHistory();
keywordHistory.DateModified = DateTime.Now;
keywordHistory.Keyword = keyword;
keywordHistory.ProductId = _ProductVM.Product.ProductId;
SessionDataContext.KeywordHistories.Add(keywordHistory);
SessionDataContext.SaveChanges();
}
private void DeleteProduct()
{
var entry = SessionDataContext.Entry(SelectedProduct.Product);
if (entry.State == System.Data.Entity.EntityState.Added)
{
entry.State = System.Data.Entity.EntityState.Detached;
}
else
{
SessionDataContext.Products.Remove(SelectedProduct.Product);
entry.State = EntityState.Deleted;
}
_Products.Remove(_SelectedProduct);
SelectedProduct = _Products.FirstOrDefault();
RaisePropertyChanged(nameof(SelectedProduct));
}
public void AddInitialKeywordHistoryRecord(string keyword)
{
var keywordHistories = SessionDataContext
.KeywordHistories
.Where(x => x.ProductId == _ProductVM.Product.ProductId);
if (keywordHistories.Count() != 0)
{
return;
}
KeywordHistory keywordHistory = new KeywordHistory();
keywordHistory.DateModified = DateTime.Now;
keywordHistory.Keyword = keyword;
keywordHistory.ProductId = _ProductVM.Product.ProductId;
SessionDataContext.KeywordHistories.Add(keywordHistory);
SessionDataContext.SaveChanges();
}
private void DisposeSession(SessionDataContext ctx)
{
try
{
if (_scope != null)
{
using (CodeMarker.MarkBlock("Session.ScopeDispose"))
{
_scope.Dispose();
}
}
}
catch (Exception ex)
{
var exception = ex;
if (exception is AggregateException)
{
exception = ((AggregateException)ex).InnerException;
}
Log(new DiagnosticMessage(MessageType.Error, exception.Message, "Session", SessionDataContext.InValidationProcess, null, exception));
}
_scope = null;
try
{
// Libération des locks
Store.LockManager.ReleaseLocks(ctx.Locks, ctx.Aborted);
}
catch (Exception ex)
{
throw new CriticalException(ExceptionMessages.CriticalErrorMaybeAwaitInSession, ex);
}
// Suppression de la session courante. Il n'est plus possible de faire référence à la session
ctx.Current = null;
SessionDataContext = null;
ResetSessionIndex(true);
}
private Tuple <ExecutionResult, ISessionInformation> CompleteTopLevelTransaction(IEnumerable <IEventNotifier> notifiers, SessionDataContext ctx, SessionLocalInfo currentInfo)
{
// Sauvegarde des références vers les objets qui sont utilisés aprés que les données de la session auront été supprimées
ExecutionResult messages = null;
ISessionInformation sessionInfo = null;
// Il ne peut pas y avoir d'erreur dans cette partie de code
try
{
ctx.Disposing = true;
// Si la session était en lecture seule, on simplifie les traitements
// Pas de validation
if (!ctx.ReadOnly)
{
messages = ExecuteConstraints(ctx, currentInfo);
}
// Contexte en lecture seule de la session mais tjs dans le scope
// Envoi des events même en read-only pour s'assurer que le OnSessionCompleted soit bien notifié
if (!ctx.CancellationToken.IsCancellationRequested)
{
using (CodeMarker.MarkBlock("Session.OnSessionCompleted"))
{
sessionInfo = OnSessionCompleted(currentInfo, notifiers, messages);
}
}
// Si tout va bien, on commite
if (!IsAborted && _scope != null && (messages == null || !messages.HasErrors))
{
_scope.Complete();
}
}
catch (Exception ex)
{
Log(new DiagnosticMessage(MessageType.Error, ex.Message, ExceptionMessages.Diagnostic_ApplicationError, SessionDataContext.InValidationProcess, null, ex));
}
finally
{
DisposeSession(ctx);
}
return(Tuple.Create(messages ?? ExecutionResult.Empty, sessionInfo));
}
