public SalesOrderSnapshot CreateNewSalesOrderSnapshot(Guid salesOrderId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
GetSalesOrderDetails_Result result = tec.GetSalesOrderDetails(salesOrderId).FirstOrDefault();
if (result == null)
{
return(null);
}
SalesOrderSnapshot snapshot = this.CreateSalesOrderSnapshot(result, salesOrderId);
var historyEvents = tec.GetSalesOrderHistory(salesOrderId).OrderBy(he => he.eventDate);
bool isFirstPrepayment = true;
foreach (GetSalesOrderHistory_Result hResult in historyEvents)
{
SalesOrderEvent soe = this.CreateSalesOrderEvent(hResult, snapshot, isFirstPrepayment);
snapshot.SalesOrderEvents.Add(soe);
if (soe.EventName == EventName.FirstPrepayment && isFirstPrepayment)
{
isFirstPrepayment = false;
}
}
return(snapshot);
}
}
public Contractor GetContractor(Guid contractorId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
return(CreateContractor(tec.GetContractorData(contractorId).FirstOrDefault()));
}
}
public List <Message> GetMessages(List <Guid> messageIds)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
return(tec.Messages.Where(m => messageIds.Contains(m.Id)).ToList());
}
}
public Message GetMessage(Guid messageId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
return(tec.Messages.Where(m => m.Id == messageId).FirstOrDefault());
}
}
public List <Item> GetSalesOrderItems(Guid salesOrderId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
return(tec.GetItems(salesOrderId).ToList());
}
}
public List <MessageReference> GetMessageReferences(Guid salesOrderId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
return(tec.MessageReferences.Where(mr => mr.SalesOrderId == salesOrderId).ToList());
}
}
public void InsertMessages(List <Message> messages)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
InsertMessages(messages, tec);
}
}
public void ProcessSalesOrderEvents()
{
int noErrors = 0;
int idleDelay = Convert.ToInt32(ConfigurationManager.AppSettings["idleDelay"] ?? "60");
int errorsDelay = Convert.ToInt32(ConfigurationManager.AppSettings["errorsDelay"] ?? "300");
int maxErrors = Convert.ToInt32(ConfigurationManager.AppSettings["errorsCount"] ?? "10");
bool idle = false;
while (true)
{
try
{
using (TrackerEntitiesContainer tec = TrackerEntitiesManager.GetNewTrackerObjectContext())
{
//Open connection before any operation on context in order to ensure that all operations will run under same local transaction!!
tec.Connection.Open();
GetCurrentSalesOrdersQueue(tec);
if (SalesOrderId.HasValue && SalesOrderId != Guid.Empty)
{
SalesOrderSnapshot newSnapshot
= TrackerEntitiesManager.Instance.CreateNewSalesOrderSnapshot(SalesOrderId.Value);
if (newSnapshot == null)
{
throw new ApplicationException("Nie odnaleziono obiektu o id = " + SalesOrderId);
}
SalesOrderSnapshot oldSnapshot
= TrackerEntitiesManager.Instance.GetSalesOrderSnapshot(SalesOrderId.Value, tec);
var previousEvents = TrackerEntitiesManager.Instance.CreateEventsList(oldSnapshot);
var currentEvents = TrackerEntitiesManager.Instance.CreateEventsList(newSnapshot);
var newEvents = GetNewEvents(previousEvents, currentEvents);
newEvents = newEvents.Where(ev => ev.EventDate >= TemplatesCache.StartDate).ToList();
List <Message> newMessages = GenerateMessages(newSnapshot, newEvents);
MarkSalesOrdersQueueAsCompleted();
SaveEntities(newSnapshot, oldSnapshot, newMessages, tec);
}
else
{
idle = true;
}
}
if (idle == true)
{
Thread.Sleep(TimeSpan.FromSeconds(idleDelay));
idle = false;
}
}
catch (Exception ex)
{
noErrors++;
Utils.LogException(ex, typeof(MessagingLogic), ConfigurationManager.AppSettings["LogFolder"]);
if (noErrors == maxErrors)
{
Thread.Sleep(TimeSpan.FromSeconds(errorsDelay));
noErrors = 0;
}
}
}
}
public void DeleteMessage(Message message)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
string entitySetName = tec.Messages.EntitySet.Name;
EntityFrameworkHelper.Instance.DeleteEntity <Message>(tec, entitySetName, message);
}
}
public void InsertMessageReferences(List <MessageReference> entities, TrackerEntitiesContainer tec)
{
foreach (MessageReference messRef in entities.Where(mref => mref.Id == Guid.Empty))
{
messRef.Id = Guid.NewGuid();
}
EntityFrameworkHelper.Instance.InsertEntities <MessageReference>(tec, tec.MessageReferences.EntitySet.Name, entities);
}
public void InsertMessages(List <Message> messages, TrackerEntitiesContainer tec)
{
foreach (Message message in messages.Where(msg => msg.Id == Guid.Empty))
{
message.Id = Guid.NewGuid();
}
string entitySetName = tec.Messages.EntitySet.Name;
foreach (Message message in messages)
{
EntityFrameworkHelper.Instance.InsertEntity(tec, entitySetName, message);
Thread.Sleep(10);
}
}
private void SaveEntities(SalesOrderSnapshot salesOrderSnapshot, SalesOrderSnapshot oldSnapshot
, List <Message> messages, TrackerEntitiesContainer tec)
{
using (TransactionScope ts = new TransactionScope())
{
TrackerEntitiesManager.Instance.InsertMessages(messages, tec);
TrackerEntitiesManager.Instance.PersistSalesOrderSnapshot(salesOrderSnapshot, oldSnapshot, messages, tec);
TrackerEntitiesManager.Instance.UpdateSOTQEntries(SalesOrdersCurrentFullQueue, tec);
ts.Complete();
}
}
public List <SalesOrderSnapshot> GetSalesOrdersList(Guid contractorId)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
List <SalesOrderSnapshot> createdList = new List <SalesOrderSnapshot>();
var results = tec.GetSalesOrderList(contractorId);
foreach (var result in results)
{
createdList.Add(CreateSalesOrderSnapshot(result));
}
return(createdList);
}
}
/// <summary>
/// Insert or update message
/// </summary>
/// <param name="message"></param>
public void PersistMessage(Message message)
{
using (TrackerEntitiesContainer tec = GetNewTrackerObjectContext())
{
try
{
string entitySetName = tec.Messages.EntitySet.Name;
message.Id = Guid.NewGuid();
EntityFrameworkHelper.Instance.PersistEntity <Message>(tec, entitySetName, message);
}
catch (OptimisticConcurrencyException)
{
throw new MessageAlreadySentException();
}
}
}
/// <summary>
/// SOTQ stands for Sales Order Tracker Queue
/// Get all unprocessed entries for first salesOrderId in a Queue
/// </summary>
/// <returns></returns>
public List <SalesOrderTrackerQueueEntry> GetCurrentSOTQEntries(TrackerEntitiesContainer tec)
{
ObjectQuery <SalesOrderTrackerQueueEntry> query =
(ObjectQuery <SalesOrderTrackerQueueEntry>)tec.SalesOrderTrackerQueueEntries
.Where(entry => !entry.IsCompleted).OrderBy(entry => entry.Date);
query.MergeOption = MergeOption.NoTracking;
List <SalesOrderTrackerQueueEntry> list = query.ToList();
if (list.Count == 0)
{
return(new List <SalesOrderTrackerQueueEntry>());
}
Guid firstSalesOrderId = list.Select(entry => entry.SalesOrderId).First();
return(list.Where(entry => entry.SalesOrderId == firstSalesOrderId).ToList());
}
private void GetCurrentSalesOrdersQueue(TrackerEntitiesContainer tec)
{
SalesOrdersCurrentFullQueue = TrackerEntitiesManager.Instance.GetCurrentSOTQEntries(tec);
SalesOrderId = SalesOrdersCurrentFullQueue.Select(entry => entry.SalesOrderId).FirstOrDefault();
}
public void PersistSalesOrderSnapshot(SalesOrderSnapshot salesOrderSnapshot, SalesOrderSnapshot oldSnapshot
, List <Message> messages, TrackerEntitiesContainer tec)
{
#region Message references - create them and insert to collection
foreach (Message message in messages)
{
MessageReference reference = new MessageReference()
{
Id = Guid.NewGuid(), MessageId = message.Id, SalesOrderId = salesOrderSnapshot.Id
};
salesOrderSnapshot.MessageReferences.Add(reference);
}
#endregion
#region Related Events - delete old events and create ids for new events
if (oldSnapshot != null)
{
while (oldSnapshot.SalesOrderEvents.Count > 0)
{
tec.DeleteObject(oldSnapshot.SalesOrderEvents.Last());
}
}
foreach (SalesOrderEvent newEvent in salesOrderSnapshot.SalesOrderEvents)
{
newEvent.Id = Guid.NewGuid();
}
#endregion
#region Set all objects state before saving
object oldObject = null;
string entitySetName = tec.SalesOrderSnapshots.EntitySet.Name;
tec.TryGetObjectByKey(tec.CreateEntityKey(entitySetName, salesOrderSnapshot), out oldObject);
if (oldObject == null)
{
tec.AddObject(entitySetName, salesOrderSnapshot); //all related objects will be also added
}
else
{
tec.ApplyCurrentValues(entitySetName, salesOrderSnapshot);
//salesOrderSnapshot remains detached. Status of related objects must be set manualy.
oldSnapshot = (SalesOrderSnapshot)oldObject;
while (salesOrderSnapshot.MessageReferences.Count > 0)
{
oldSnapshot.MessageReferences.Add(salesOrderSnapshot.MessageReferences.Last());
}
//tec.AddObject(tec.MessageReferences.EntitySet.Name, messageReference);
while (salesOrderSnapshot.SalesOrderEvents.Count > 0)
{
oldSnapshot.SalesOrderEvents.Add(salesOrderSnapshot.SalesOrderEvents.Last());
}
//tec.AddObject(tec.SalesOrderEvents.EntitySet.Name, soEvent);
}
#endregion
tec.SaveChanges();
}
public SalesOrderSnapshot GetSalesOrderSnapshot(Guid salesOrderId, TrackerEntitiesContainer tec)
{
return(tec.SalesOrderSnapshots.Include(tec.SalesOrderEvents.EntitySet.Name)
.Where(sos => sos.Id == salesOrderId).FirstOrDefault());
}
public void UpdateSOTQEntries(List <SalesOrderTrackerQueueEntry> entries, TrackerEntitiesContainer tec)
{
EntityFrameworkHelper.Instance.UpdateEntities <SalesOrderTrackerQueueEntry>(tec
, tec.SalesOrderTrackerQueueEntries.EntitySet.Name, entries);
}
