/// <summary>
/// get event details
/// </summary>
/// <param name="Id"> event id </param>
/// <returns> event model </returns>
public EventsModel GetEventDetails(string Id)
{
using (var _ctx = new ChinmayaEntities())
{
EventsModel emm = new EventsModel();
Event emData = _ctx.Events.Where(e => e.Id == Id).FirstOrDefault();
if (emData != null)
{
emm.Id = emData.Id;
emm.Name = emData.Name;
emm.Description = emData.Description;
emm.WeekdayId = emData.WeekdayId;
emm.FrequencyId = emData.FrequencyId;
emm.AgeFrom = emData.AgeFrom;
emm.AgeTo = emData.AgeTo;
emm.Amount = emData.Amount;
EventSession esessionData = _ctx.EventSessions.Where(es => es.EventId == emData.Id).FirstOrDefault();
emm.SessionId = esessionData.SessionId;
emm.StartDate = Convert.ToDateTime(esessionData.StartDate);
emm.EndDate = Convert.ToDateTime(esessionData.EndDate);
emm.StartTime = esessionData.StartTime;
emm.EndTime = esessionData.EndTime;
emm.Location = esessionData.Location;
emm.Instructor = esessionData.Instructor;
emm.Contact = esessionData.Contact;
emm.Other = esessionData.Other;
EventHoliday eHolidayData = _ctx.EventHolidays.Where(eh => eh.EventId == emData.Id).FirstOrDefault();
emm.HolidayDate = eHolidayData.HolidayDate;
}
return(emm);
}
}
public void Execute()
{
listener = new TcpListener(IPAddress.Parse("127.0.0.1"), Setting.Instance.ListenPort);
listener.Start();
Trace.WriteLine("EventServer listen start port: " + Setting.Instance.ListenPort);
while (true)
{
try {
EventSession session = new EventSession(this, listener.AcceptTcpClient());
lock (sessions) {
sessions.Add(session);
}
} catch (Exception e) {
Trace.WriteLine("EventServer stopped:" + e.Message);
return;
}
/* new Thread(new ThreadStart(() => {
* session.ReceiveLoop();
* lock(sessions) {
* sessions.Remove(session);
* }
* }));*/
}
}
private static bool ManageInclude(EventSession currentSession, Event e, Track track)
{
if (track.IsPossibleInclude(currentSession, e.Duration))
{
e.Session = currentSession;
track.Events.Add(e);
return(true);
}
return(false);
}
public void StopSession()
{
if (runningSession == null)
{
return;
}
autoLogExitCts?.Cancel();
using (runningSession) {
runningSession.Stop();
SessionStopped?.Invoke(runningSession);
runningSession = null;
}
}
public async Task StopSessionAsync()
{
if (runningSession == null)
{
return;
}
autoLogExitCts?.Cancel();
using (runningSession) {
await Task.Run(() => runningSession.Stop());
SessionStopped?.Invoke(runningSession);
runningSession = null;
}
}
public bool IsPossibleInclude(EventSession session, int eventDuration)
{
var duration = this.DurationSession(session);
if (session == EventSession.Morning)
{
return(duration <= MORNING_SESSION_DURATION &&
duration + eventDuration <= MORNING_SESSION_DURATION);
}
else
{
return(duration <= AFTERNOON_SESSION_DURATION &&
duration + eventDuration <= AFTERNOON_SESSION_DURATION);
}
}
public async Task <EventSession> StartSessionAsync(TraceProfileDescriptor descriptor)
{
if (runningSession != null)
{
throw new InvalidOperationException("Session already in progress.");
}
var traceLog = new TraceLog();
var session = new EventSession(descriptor, traceLog);
SessionStarting?.Invoke(traceLog);
await session.StartAsync();
runningSession = session;
SessionStarted?.Invoke(runningSession);
return(session);
}
private void RemoveEventSession(EventSession eventSession) => eventSessions.Remove(eventSession);
private void AddEventSession(EventSession eventSession) => eventSessions.Add(eventSession);
/// <summary>
/// adds event
/// </summary>
/// <param name="ev"> Event Model </param>
public void PostEvent(EventsModel ev)
{
using (var _ctx = new ChinmayaEntities())
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <EventsModel, Event>();
});
IMapper mapper = config.CreateMapper();
var eve = new Event
{
Id = Guid.NewGuid().ToString(),
Name = ev.Name,
Description = ev.Description,
WeekdayId = ev.WeekdayId,
FrequencyId = ev.FrequencyId,
AgeFrom = ev.AgeFrom,
AgeTo = ev.AgeTo,
Amount = ev.Amount,
Status = true,
CreatedBy = ev.CreatedBy,
CreatedDate = DateTime.Now
};
var evs = new EventSession
{
EventId = eve.Id,
SessionId = ev.SessionId,
StartDate = ev.StartDate,
EndDate = ev.EndDate,
StartTime = ev.StartTime,
EndTime = ev.EndTime,
Location = ev.Location,
Instructor = ev.Instructor,
Contact = ev.Contact,
Other = ev.Other
};
if (ev.HolidayDate != null)
{
var eHoliday = new EventHoliday
{
EventId = eve.Id,
HolidayDate = ev.HolidayDate
};
_ctx.EventHolidays.Add(eHoliday);
}
_ctx.Events.Add(eve);
_ctx.EventSessions.Add(evs);
try
{
_ctx.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var even in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
even.Entry.Entity.GetType().Name, even.Entry.State);
foreach (var ve in even.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
}
}
}
private void RemoveEventSession(EventSession eventSession)
{
using (eventSessions.EnterWriteLock())
eventSessions.Remove(eventSession);
} // proc RemoveEventSession
private void AddEventSession(EventSession eventSession)
{
using (eventSessions.EnterWriteLock())
eventSessions.Add(eventSession);
} // proc AddEventSession
/// <summary>
/// adds event
/// </summary>
/// <param name="ev"> Event Model </param>
public string PostEvent(EventsModel ev)
{
using (var _ctx = new ChinmayaEntities())
{
string res = "";
using (var transaction = _ctx.Database.BeginTransaction())
{
try
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap <EventsModel, Event>();
});
IMapper mapper = config.CreateMapper();
Event evnt = new Event();
mapper.Map(ev, evnt);
var config1 = new MapperConfiguration(cfg =>
{
cfg.CreateMap <EventsModel, EventSession>().ForMember(dest => dest.Id, opt => opt.Ignore());
});
IMapper mapper1 = config1.CreateMapper();
EventSession evntssn = new EventSession();
mapper1.Map(ev, evntssn);
var config2 = new MapperConfiguration(cfg =>
{
cfg.CreateMap <EventsModel, EventHoliday>().ForMember(dest => dest.Id, opt => opt.Ignore());
});
IMapper mapper2 = config2.CreateMapper();
EventHoliday evnthld = new EventHoliday();
mapper2.Map(ev, evnthld);
if (ev.Id == null)
{
evnt.Id = Guid.NewGuid().ToString();
evnt.Status = true;
evnt.CreatedDate = DateTime.Now;
_ctx.Events.Add(evnt);
_ctx.SaveChanges();
evntssn.EventId = evnt.Id;
_ctx.EventSessions.Add(evntssn);
_ctx.SaveChanges();
evnthld.EventId = evnt.Id;
_ctx.EventHolidays.Add(evnthld);
_ctx.SaveChanges();
transaction.Commit();
res = "Event successfully added";
}
else
{
var rgstrusr = _ctx.EventRegistrations.Where(r => r.EventId == ev.Id).FirstOrDefault();
if (rgstrusr == null)
{
evnt = _ctx.Events.Where(e => e.Id == ev.Id).FirstOrDefault();
evnt.Id = ev.Id;
evnt.Name = ev.Name;
evnt.Description = ev.Description;
evnt.WeekdayId = ev.WeekdayId;
evnt.FrequencyId = ev.FrequencyId;
evnt.AgeFrom = ev.AgeFrom;
evnt.AgeTo = ev.AgeTo;
evnt.Amount = ev.Amount;
evnt.Status = true;
evnt.CreatedDate = ev.CreatedDate;
evnt.UpdatedBy = ev.UpdatedBy;
evnt.UpdatedDate = DateTime.Now;
_ctx.SaveChanges();
evntssn = _ctx.EventSessions.Where(e => e.EventId == ev.Id).FirstOrDefault();
evntssn.SessionId = ev.SessionId;
evntssn.StartDate = ev.StartDate;
evntssn.EndDate = ev.EndDate;
evntssn.StartTime = ev.StartTime;
evntssn.EndTime = ev.EndTime;
evntssn.Location = ev.Location;
evntssn.Instructor = ev.Instructor;
evntssn.Contact = ev.Contact;
evntssn.Other = ev.Other;
_ctx.SaveChanges();
evnthld = _ctx.EventHolidays.Where(e => e.EventId == ev.Id).FirstOrDefault();
evnthld.HolidayDate = ev.HolidayDate;
_ctx.SaveChanges();
transaction.Commit();
res = "Event successfully edited";
}
else
{
res = "Users already registered for the Event";
}
}
}
catch
{
transaction.Rollback();
throw;
}
}
return(res);
}
}
private int DurationSession(EventSession session)
{
return(this.Events.Where(e => e.Session == session)
.Sum(e => e.Duration));
}
