public static void Main(string[] args)
{
var es = new Eventstore <InMemoryEventRepository>();
var a = new A();
var b = new B();
var c = new C();
es.Record(null, a);
es.Record(a.Id, c);
es.Record(c.Id, b);
EventArchive.Write("myarchive.json", es.Replay());
var events = EventArchive.Read("myarchive.json");
var es2 = new Eventstore <InMemoryEventRepository>();
EventId id = null;
events.ToList().ForEach(delegate(IEvent e)
{
es2.Record(id, e);
id = e.Id;
});
Console.WriteLine(es2.Replay().ToList().Count);
}
public void Store_and_load()
{
const string FILENAME = nameof(EventArchive_tests) + "_" + nameof(Store_and_load) + ".json";
if (File.Exists(FILENAME))
{
File.Delete(FILENAME);
}
var events = new IEvent[] {
new TestEvent {
Foo = "a"
},
new AnotherTestEvent {
Bar = 1
},
new TestEvent {
Foo = "b"
}
};
EventArchive.Write(FILENAME, events);
var result = EventArchive.Read(FILENAME).ToArray();
Assert.Equal("a", ((TestEvent)result[0]).Foo);
Assert.Equal(1, ((AnotherTestEvent)result[1]).Bar);
Assert.Equal("b", ((TestEvent)result[2]).Foo);
}
public static void Main(string[] args)
{
var es = new InMemoryEventstore();
es.Record(new A());
es.Record(new C());
es.Record(new B());
nsimpleeventstore.adapters.EventArchive.Write("myarchive.json", es.Replay().Events);
var events = EventArchive.Read("myarchive.json");
var es2 = new InMemoryEventstore(events);
Console.WriteLine(es2.Replay().Events.Length);
}
public async Task <HttpResponseMessage> GetEvents(string interval)
{
try
{
HttpClient httpClient = this.getBasicClient();
TransactionLog tLog = transactionLogService.Create(new TransactionLog());
tLog.TransactionLogK = Guid.NewGuid();
string unqTID = tLog.TransactionLogK.ToString();
httpClient.DefaultRequestHeaders.Add("X-Transaction-ID", unqTID);
string apiUri = "https://" + this.apiChorus + "/events?interval=" + interval;
var response = await httpClient.GetAsync(new Uri(apiUri));
tLog.Authorization = httpClient.DefaultRequestHeaders.Authorization.ToString();
tLog.BaseAddress = apiUri;
tLog.Response = response.ToString();
tLog.ResponseBody = await response.Content.ReadAsStringAsync();
transactionLogService.SaveChanges();
if (response.IsSuccessStatusCode)
{
JavaScriptSerializer oJS = new JavaScriptSerializer();
List <EventStage> listEventStage = new List <EventStage>();
listEventStage = oJS.Deserialize <List <EventStage> >(tLog.ResponseBody);
//Existing data in EventStage
IQueryable <EventStage> esExtgData = eventStageService.Find();
//Existing data in EventArchive
IQueryable <EventArchive> eaExtgData = eventArchiveService.Find();
//New inserts in EventStage
List <EventStage> esNewData = new List <EventStage>();
//New inserts in EventArchive
List <EventArchive> eaNewData = new List <EventArchive>();
if (this.chorusLimitEnable == "true")
{
int totalCount = esExtgData.Count();
if (totalCount >= this.chorusOrderLimit)
{
throw new HttpResponseException(
Request.CreateErrorResponse(HttpStatusCode.NotFound,
"Limit of " + this.chorusOrderLimit + " Service-Orders reached.")
);
}
}
//Insert data from payload
foreach (EventStage esItm in listEventStage)
{
if (this.chorusLimitEnable == "true" && esNewData != null)
{
int totalCount = esExtgData.Count() + esNewData.Count();
if (totalCount >= this.chorusOrderLimit)
{
break;
}
}
EventStage esFound = (from es in esExtgData
where es.OrderID == esItm.OrderID && es.ID == esItm.ID
select es).FirstOrDefault();
EventStage esNewFound = null;
if (esNewData != null)
{
esNewFound = esNewData.Where(es => es.OrderID == esItm.OrderID &&
es.ID == esItm.ID).FirstOrDefault();
}
if (esFound == null && esNewFound == null)
{
eventStageService.Create(esItm);
esNewData.Add(esItm);
}
EventArchive eaFound = (from ea in eaExtgData
where ea.OrderID == esItm.OrderID &&
ea.SOStage == esItm.SOStage &&
ea.SOType == esItm.SOType &&
ea.ASID == esItm.ASID &&
ea.ID == esItm.ID
select ea).FirstOrDefault();
EventArchive eaNewFound = null;
if (eaNewData != null)
{
eaNewFound = eaNewData.Where(ea => ea.OrderID == esItm.OrderID &&
ea.SOStage == esItm.SOStage &&
ea.SOType == esItm.SOType &&
ea.ASID == esItm.ASID &&
ea.ID == esItm.ID).FirstOrDefault();
}
if (eaFound == null && eaNewFound == null)
{
EventArchive eaTmp = new EventArchive();
eaTmp.ID = esItm.ID;
eaTmp.EventAction = esItm.EventAction;
eaTmp.OrderID = esItm.OrderID;
eaTmp.SOType = esItm.SOType;
eaTmp.SOStage = esItm.SOStage;
eaTmp.CrtDate = esItm.CrtDate;
eaTmp.ASID = esItm.ASID;
eventArchiveService.Create(eaTmp);
eaNewData.Add(eaTmp);
}
}
//Save and check if EventStage-table-modified while execution
bool saveFailed;
do
{
saveFailed = false;
try
{
eventStageService.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
saveFailed = true;
// Update original values from the database
var entry = ex.Entries.Single();
entry.OriginalValues.SetValues(entry.GetDatabaseValues());
}
} while (saveFailed);
//Save and check if EventArchive-table-modified while execution
do
{
saveFailed = false;
try
{
eventArchiveService.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{
saveFailed = true;
// Update original values from the database
var entry = ex.Entries.Single();
entry.OriginalValues.SetValues(entry.GetDatabaseValues());
}
} while (saveFailed);
response = Request.CreateResponse(HttpStatusCode.OK, eaNewData);
}
return(response);
}
catch (Exception e)
{
throw e;
}
}
