public bool DeleteEvent(EventDataModel eventData)
{
using (var context = new BookReadingEventsDBEntities())
{
context.Database.Log = Logger.Log;
var deleteEvent = context.Events
.SingleOrDefault(e => e.Id == eventData.Id);
bool result = false;
if (deleteEvent != null)
{
// Deleting Invites
var deleteInvites = context.Invites.Where(i => i.EventId == eventData.Id).ToList();
foreach (var invite in deleteInvites)
{
context.Invites.Remove(invite);
context.SaveChanges();
}
// Deleting Comments
var deleteComments = context.Comments.Where(c => c.EventId == eventData.Id).ToList();
foreach (var comment in deleteComments)
{
context.Comments.Remove(comment);
context.SaveChanges();
}
// Deleting Event
context.Events.Remove(deleteEvent);
context.SaveChanges();
result = true;
}
return(result);
}
}
private EventDataModel getRandomEventData()
{
Encounter encounter = getEventEncounter();
EventDataModel edm = EventDataModel.getCombatEvent(encounter);
return(edm);
}
public ActionResult EventDetail(EventViewModel model)
{
if (model.Id != 0)
{
EventDataModel eventDataModel = new EventDataModel();
eventDataModel.Id = model.Id;
EventService eventService = new EventService();
var result = eventService.GetEventDetails(eventDataModel);
if (result != null)
{
model.Date = result.Date;
model.Description = result.Description;
model.DurationInHours = (int)result.DurationInHours;
model.InviteEmails = result.InviteEmails;
model.Location = result.Location;
model.OtherDetails = result.OtherDetails;
model.StartTime = (DateTime)result.StartTime;
model.Title = result.Title;
model.Type = result.Type;
}
return(View(model));
}
return(View());
}
public ActionResult Details(EventViewModel eventView)
{
EventDataModel eventDataModel = new EventDataModel();
eventDataModel.Id = eventView.Id;
EventService eventService = new EventService();
var result = eventService.GetEventDetails(eventDataModel);
EventViewModel eventViewModel = new EventViewModel();
if (result != null)
{
eventViewModel.Date = result.Date;
eventViewModel.Description = result.Description;
eventViewModel.DurationInHours = (int)result.DurationInHours;
eventViewModel.Id = result.Id;
eventViewModel.InviteEmails = result.InviteEmails;
eventViewModel.Location = result.Location;
eventViewModel.OtherDetails = result.OtherDetails;
eventViewModel.StartTime = (DateTime)result.StartTime;
eventViewModel.Title = result.Title;
eventViewModel.TotalInvites = (int)result.TotalInvites;
eventViewModel.Type = result.Type;
eventViewModel.UserId = result.UserId;
return(View(eventViewModel));
}
return(View());
}
public ActionResult CreateEvent(EventViewModel eventData)
{
if (ModelState.IsValid)
{
EventDataModel eventDataModel = new EventDataModel();
string user = GetUserDetail();
eventDataModel.UserId = Convert.ToInt32(user.Split('|')[1]);
eventDataModel.Date = eventData.Date;
eventDataModel.Description = eventData.Description;
eventDataModel.DurationInHours = (int)eventData.DurationInHours;
eventDataModel.Id = eventData.Id;
eventDataModel.InviteEmails = eventData.InviteEmails;
eventDataModel.Location = eventData.Location;
eventDataModel.OtherDetails = eventData.OtherDetails;
eventDataModel.StartTime = (DateTime)eventData.StartTime;
eventDataModel.Title = eventData.Title;
eventDataModel.TotalInvites = (int)eventData.TotalInvites;
eventDataModel.Type = eventData.Type;
EventService eventService = new EventService();
var result = eventService.CreateEvent(eventDataModel);
if (result == null)
{
ModelState.AddModelError("", "Something went wrong...");
return(View());
}
ModelState.Clear();
return(RedirectToAction("MyEvents"));
}
return(View());
}
//Volunteer/Unvolunteer method
public ActionResult NotRealVolunteer(int id)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//checks if the user has volunteered or not to this event
var userId = User.Identity.GetUserId();
var chkIfVolunteered = db.VolunteeredEventsModel.Where(a => a.EventId == id && a.UserId == userId)
.Select(a => a.Id).FirstOrDefault();
EventDataModel eventDataModel = db.EventDataModels.Find(id);
if (chkIfVolunteered != 0)
{
//they are volunteered for this event
ViewData["Message"] = "CannotVolunteer";
}
else if (chkIfVolunteered == 0 && eventDataModel.volunteersNeeded > 0)
{
//they are not volunteeered for this event and the event still needs volunteers
ViewData["Message"] = "CanVolunteer";
}
return(View(eventDataModel));
}
public ActionResult Create([Bind(Include = "eventName,eventStartDate,eventEndDate,volunteersNeeded,location,startTime,endTime,description")] EventDataModel eventDataModel)
{
if (ModelState.IsValid)
{
eventDataModel.eventEndDate = eventDataModel.eventStartDate.Substring(13, 10);
eventDataModel.eventStartDate = eventDataModel.eventStartDate.Substring(0, 10);
//sets a time if no time was selected in the create form
if (eventDataModel.startTime == null)
{
eventDataModel.startTime = "12:00am";
}
if (eventDataModel.endTime == null)
{
eventDataModel.endTime = "11:59pm";
}
db.EventDataModels.Add(eventDataModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(eventDataModel));
}
public EventDataModel GetEventDetails(EventDataModel eventData)
{
using (var context = new BookReadingEventsDBEntities())
{
context.Database.Log = Logger.Log;
var eventDetail = context.Events.Where(e => e.Id == eventData.Id).SingleOrDefault();
EventDataModel eventDataModel = new EventDataModel();
if (eventDetail != null)
{
eventDataModel.Date = eventDetail.Date;
eventDataModel.Description = eventDetail.Description;
eventDataModel.DurationInHours = (int)eventDetail.DurationInHours;
eventDataModel.Id = eventDetail.Id;
eventDataModel.InviteEmails = eventDetail.InviteEmails;
eventDataModel.Location = eventDetail.Location;
eventDataModel.OtherDetails = eventDetail.OtherDetails;
eventDataModel.StartTime = (DateTime)eventDetail.StartTime;
eventDataModel.Title = eventDetail.Title;
eventDataModel.TotalInvites = (int)eventDetail.TotalInvites;
eventDataModel.Type = eventDetail.Type;
eventDataModel.UserId = eventDetail.UserId;
}
return(eventDataModel);
}
}
public static void DispatchEvent(EVENT eventKey, EventDataModel argv = null)
{
if (!callbackMap.ContainsKey(eventKey))
{
return;
}
callbackMap [eventKey].ForEach((callback) => callback(argv));
}
public EventDataModel EditEvent(EventDataModel eventData)
{
List <string> inviteEmails = ConvertInviteEmails(eventData.InviteEmails);
using (var context = new BookReadingEventsDBEntities())
{
context.Database.Log = Logger.Log;
Event editEvent = context.Events.SingleOrDefault(e => e.Id == eventData.Id);
if (eventData != null)
{
editEvent.Description = eventData.Description;
editEvent.DurationInHours = (int)eventData.DurationInHours;
editEvent.InviteEmails = eventData.InviteEmails;
editEvent.Location = eventData.Location;
editEvent.OtherDetails = eventData.OtherDetails;
editEvent.StartTime = (DateTime)eventData.StartTime;
editEvent.Title = eventData.Title;
editEvent.Type = eventData.Type;
editEvent.Date = eventData.Date;
}
context.SaveChanges();
int countOfInvites = 0;
if (inviteEmails != null && editEvent.Type != "Private")
{
foreach (string email in inviteEmails)
{
var user = context.Users.Where(u => u.Email == email).SingleOrDefault();
if (user != null)
{
var invite = context.Invites
.SingleOrDefault(i => i.EventId == editEvent.Id && i.UserId == user.Id);
if (invite == null)
{
Invite inviteDetail = new Invite();
inviteDetail.EventId = editEvent.Id;
inviteDetail.UserId = user.Id;
context.Invites.Add(inviteDetail);
context.SaveChanges();
}
countOfInvites++;
}
}
}
editEvent.TotalInvites = countOfInvites;
context.SaveChanges();
eventData.TotalInvites = countOfInvites;
return(eventData);
}
}
private string ReplaceTemplateBody(string templateBody, EventDataModel eventData)
{
StringBuilder sb = new StringBuilder(templateBody);
sb.Replace("{Firstname}", eventData.FirstName);
sb.Replace("{AppointmentDateTime}", eventData.AppointmentDateTime.ToShortDateString());
sb.Replace("{OrganisationName}", eventData.OrganisationName);
sb.Replace("{Reason}", eventData.Reason);
return(sb.ToString());
}
public ActionResult DeleteConfirmed(int id)
{
//finds the event in the database and deletes it
EventDataModel eventDataModel = db.EventDataModels.Find(id);
db.EventDataModels.Remove(eventDataModel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
void UnselectPawn(EventDataModel data)
{
var targetData = (UnselectEventDataModel)data;
if (targetData == null)
{
return;
}
PawnPool.Add(targetData.Pawn);
SelectedPawns.Remove(targetData.Pawn);
}
void AddPawnToParty(EventDataModel data)
{
var targetData = (AddedToPartyEventDataModel)data;
if (targetData == null)
{
return;
}
PawnPool.Remove(targetData.Pawn);
SelectedPawns.Add(targetData.Pawn);
}
// GET: Event/Edit/5
public ActionResult Edit(int id)
{
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventDataModel eventDataModel = db.EventDataModels.Find(id);
if (eventDataModel == null)
{
return(HttpNotFound());
}
return(View(eventDataModel));
}
// GET: Event/Details/5
public ActionResult Details(int id)
{
//grabbing event details, if an event is found
if (id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
EventDataModel eventDataModel = db.EventDataModels.Find(id);
if (eventDataModel == null)
{
return(HttpNotFound());
}
return(View(eventDataModel));
}
public bool RemoveEvent(Event e, int id)
{
var remove = from Event in EventDataModel.Event
where Event.EventID == id
select Event;
if (MessageBoxResult.Yes != ModernWpf.MessageBox.Show($"Czy zatwierdzasz zedytowaną wizytę? \n" +
$"Imię: {e.FirstName}\n" +
$"Nazwisko: {e.LastName} \n" +
$"Data: {e.EventDate:dd.MM.yyyy (dddd)}\n" +
$"Godzina: {e.EventDate:HH:mm} do {e.EventDate.AddMinutes(e.EventDuration):HH:mm}\n" +
$"Cel wizyty: {e.Subject}\n" +
$"Lekarz: {e.Doctor}\n" +
$"Uwagi: {e.MoreAbout}\n", "Usuwanie wizyty", MessageBoxButton.YesNo))
{
return(false);
}
foreach (var item in remove)
{
EventDataModel.Event.Remove(item);
}
int counter = 0;
while (true)
{
try
{
EventDataModel.SaveChanges();
break;
}
catch (Exception)
{
counter++;
if (counter == 5)
{
counter = 0;
ModernWpf.MessageBox.Show("Sprawdz swoje połączenie z internetem a następnie naciśnij OK aby spróbować ponownie.", "Serwer jest nieosiągalny");
}
Thread.Sleep(2000);
continue;
}
}
RedrawCalendar();
return(true);
}
public static void UpdateEvent(int event_id, int employee_id, string title, string description, DateTime dateTimeStart, DateTime dateTimeEnd, string type)
{
EventDataModel data = new EventDataModel
{
Employee_ID = employee_id,
Title = title,
Description = description,
DatetimeStart = dateTimeStart,
DatetimeEnd = dateTimeEnd,
Type = type
};
string sql = @"UPDATE schedule SET employee_id = @employee_id, datetimeStart = @DatetimeStart, datetimeEnd = @DatetimeEnd,
title = @Title, description = @Description, type = @Type WHERE id = " + event_id + ";";
SQLDataAccess.SaveData(sql, data);
}
public static void CreateEvent(int employee_id, string title, string description, DateTime dateTimeStart, DateTime dateTimeEnd, string type)
{
EventDataModel data = new EventDataModel
{
Employee_ID = employee_id,
Title = title,
Description = description,
DatetimeStart = dateTimeStart,
DatetimeEnd = dateTimeEnd,
Type = type
};
string sql = @"INSERT INTO schedule (employee_id, datetimeStart, datetimeEnd, title, description, type)
VALUES(@Employee_id, @DatetimeStart, @DatetimeEnd, @Title, @Description, @Type);";
SQLDataAccess.SaveData(sql, data);
}
void OnSpawnEnemyPawns(EventDataModel data)
{
SpawnEnemyPawnEventDataModel targetData = (SpawnEnemyPawnEventDataModel)data;
if (targetData == null)
{
return;
}
targetData.Pawns.ForEach((pawn) =>
{
SelectedPawn cell = GetEmptyCell();
if (cell != null)
{
cell.SetPawnImage(pawn);
}
});
}
public List <EventDataModel> GetInvites(InviteDataModel invitesData)
{
using (var context = new BookReadingEventsDBEntities())
{
context.Database.Log = Logger.Log;
List <EventDataModel> listOfInvites = null;
Event eventModel = new Event();
Invite inviteModel = new Invite();
var invitesEntityList = context.Invites.Where(i => i.UserId == invitesData.UserId).
GroupJoin(context.Events,
i => i.EventId, e => e.Id, (i, eve) => new
{
eventDetail = eve
});
if (invitesEntityList != null)
{
listOfInvites = new List <EventDataModel>();
foreach (var invite in invitesEntityList)
{
EventDataModel eventDataModel = new EventDataModel();
eventDataModel.Date = invite.eventDetail.ElementAt(0).Date;
eventDataModel.Description = invite.eventDetail.ElementAt(0).Description;
eventDataModel.DurationInHours = (int)invite.eventDetail.ElementAt(0).DurationInHours;
eventDataModel.Id = invite.eventDetail.ElementAt(0).Id;
eventDataModel.InviteEmails = invite.eventDetail.ElementAt(0).InviteEmails;
eventDataModel.Location = invite.eventDetail.ElementAt(0).Location;
eventDataModel.OtherDetails = invite.eventDetail.ElementAt(0).OtherDetails;
eventDataModel.StartTime = (DateTime)invite.eventDetail.ElementAt(0).StartTime;
eventDataModel.Title = invite.eventDetail.ElementAt(0).Title;
eventDataModel.TotalInvites = (int)invite.eventDetail.ElementAt(0).TotalInvites;
eventDataModel.Type = invite.eventDetail.ElementAt(0).Type;
eventDataModel.UserId = invite.eventDetail.ElementAt(0).UserId;
listOfInvites.Add(eventDataModel);
}
}
return(listOfInvites);
}
}
/// <summary>
/// <para>Retrieves the given record from the database</para>
/// </summary>
/// <param name="id">The identifier for the record to retrieve</param>
/// <returns></returns>
public EventDataModel GetDataEvent(int id)
{
EventDataModel data = new EventDataModel();
string sql = "SELECT id,Telephone,CreatedSaved,Topic,Summary,Category,Body1,Body2,Body3,Body4 WHERE id = @id";
using (IDbCommand cmd = connection.CreateCommand())
{
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
IDbDataParameter identity = cmd.CreateParameter();
identity.ParameterName = "@id";
identity.Value = id;
identity.DbType = DbType.Int32; // TODO: Change to the matching type for id column
cmd.Parameters.Add(identity);
try
{
connection.Open();
using (IDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
data.id = reader.GetInt32(reader.GetOrdinal("id"));
// TODO : assign the rest of the properties to the object
}
else
{
// TODO : if method should return null when data is not found
data = null;
}
}
// TODO : Catch db exceptions
} finally
{
// Ensure connection is always closed
if (connection.State != ConnectionState.Closed)
{
connection.Close();
}
}
}
// TODO : Decide if you should return null, or empty object if target cannot be found.
return(data);
}
static List <EventDataModel> SampleEvents(int batchSize)
{
List <EventDataModel> events = new List <EventDataModel>();
for (int i = 0; i < batchSize; i++)
{
EventDataModel item = new EventDataModel()
{
id = System.Guid.NewGuid().ToString(),
topic = $"topic-{new System.Random().Next(4, 6)}",
message = $"message - {System.Guid.NewGuid().ToString()}",
createdTime = DateTime.UtcNow
};
events.Add(item);
Console.WriteLine($"\t Generated event - id: {item.id}, created time: {item.createdTime} , topic: {item.topic}, message: {item.message}");
}
return(events);
}
public ActionResult DeleteEvent(EventViewModel model)
{
EventDataModel eventDetail = new EventDataModel();
eventDetail.Id = model.Id;
EventService eventService = new EventService();
var result = eventService.DeleteEvent(eventDetail);
ModelState.Clear();
if (User.Identity.Name.Split('|')[2] == "admin")
{
return(RedirectToAction("Events"));
}
else
{
return(RedirectToAction("MyEvents"));
}
}
public IEnumerable <string> Get(int id)
{
IDbConnection dbConnection = System.Data.Common.DbProviderFactories.GetFactory("MySql.Data.MySqlClient");
RetrieveDataClass dal = new RetrieveDataClass(dbConnection);
EventDataModel data = dal.GetDataEvent(id);
if (data != null)
{
// Using Newtonsoft library to convert the object to JSON data
string output = Newtonsoft.Json.JsonConvert.SerializeObject(data);
// TODO : Not sure if you need IEnumerable<string> as return type
return(new List <string>()
{
output
});
}
else
{
// TODO : handle a record not found - usually raises a 404
}
}
void OnSelectPawn(EventDataModel data)
{
var targetData = (SelectEventDataModel)data;
if (targetData == null)
{
return;
}
SelectedPawn cell = GetEmptyCell();
if (cell != null)
{
cell.SetPawnImage(targetData.Pawn);
cell.HP.value = 1.0F;
targetData.Pawn.PawnDef.HP = targetData.Pawn.PawnDef.MaxHP;
AddedToPartyEventDataModel partyAddData = new AddedToPartyEventDataModel();
partyAddData.Pawn = targetData.Pawn;
EventManager.DispatchEvent(EVENT.AddedPawnToParty, partyAddData);
}
}
public List <EventDataModel> GetUserPastEvents(EventDataModel eventData)
{
using (var context = new BookReadingEventsDBEntities())
{
context.Database.Log = Logger.Log;
List <EventDataModel> listOfEvents = null;
var eventsEntityList = context.Events.OrderByDescending(e => e.Date)
.Where(e => e.Date < DateTime.Now && e.Type == "Public" ||
(e.Type == "Private" && e.UserId == eventData.UserId && e.Date < DateTime.Now))
.ToList();
if (eventsEntityList != null)
{
listOfEvents = new List <EventDataModel>();
foreach (Event levent in eventsEntityList)
{
EventDataModel eventDataModel = new EventDataModel();
eventDataModel.Date = levent.Date;
eventDataModel.Description = levent.Description;
eventDataModel.DurationInHours = (int)levent.DurationInHours;
eventDataModel.Id = levent.Id;
eventDataModel.InviteEmails = levent.InviteEmails;
eventDataModel.Location = levent.Location;
eventDataModel.OtherDetails = levent.OtherDetails;
eventDataModel.StartTime = (DateTime)levent.StartTime;
eventDataModel.Title = levent.Title;
eventDataModel.TotalInvites = (int)levent.TotalInvites;
eventDataModel.Type = levent.Type;
eventDataModel.UserId = levent.UserId;
listOfEvents.Add(eventDataModel);
}
}
return(listOfEvents);
}
}
public void GetAllEventsLanguageFilterTest()
{
var options = new DbContextOptionsBuilder <TheaterDatabaseContext>()
.UseInMemoryDatabase(databaseName: "LanguageFilterTestDb").Options;
var context = new TheaterDatabaseContext(options);
context.Event.Add(new Event {
EventId = 1, Date = new DateTime(2020, 10, 10)
});
context.Event.Add(new Event {
EventId = 2, Date = new DateTime(2021, 10, 10)
});
context.EventTr.Add(new EventTr {
EventId = 1, LanguageId = 1
});
context.EventTr.Add(new EventTr {
EventId = 2, LanguageId = 2
});
context.Language.Add(new Language {
LanguageCode = "en", LanguageId = 1
});
context.Language.Add(new Language {
LanguageCode = "ua", LanguageId = 2
});
context.SaveChanges();
var repository = new EventRepository(context);
var actual = repository.GetAllEvents("en").First();
var expected = new EventDataModel {
EventId = 1, Date = new DateTime(2020, 10, 10)
};
Assert.IsTrue(actual.EventId == expected.EventId && actual.Date == expected.Date);
}
public ActionResult MyEvents()
{
EventDataModel eventDataModel = new EventDataModel();
string user = GetUserDetail();
eventDataModel.UserId = Convert.ToInt32(user.Split('|')[1]);
EventService eventService = new EventService();
var result = eventService.GetEvents(eventDataModel);
List <EventViewModel> eventsModel = null;
if (result != null)
{
eventsModel = new List <EventViewModel>();
foreach (EventDataModel levent in result)
{
EventViewModel eventViewModel = new EventViewModel();
eventViewModel.Date = levent.Date;
eventViewModel.Description = levent.Description;
eventViewModel.DurationInHours = (int)levent.DurationInHours;
eventViewModel.Id = levent.Id;
eventViewModel.InviteEmails = levent.InviteEmails;
eventViewModel.Location = levent.Location;
eventViewModel.OtherDetails = levent.OtherDetails;
eventViewModel.StartTime = (DateTime)levent.StartTime;
eventViewModel.Title = levent.Title;
eventViewModel.TotalInvites = (int)levent.TotalInvites;
eventViewModel.Type = levent.Type;
eventViewModel.UserId = levent.UserId;
eventsModel.Add(eventViewModel);
}
return(View(eventsModel));
}
return(View());
}
public ActionResult EditEventPost(EventViewModel model)
{
if (ModelState.IsValid)
{
EventDataModel eventDataModel = new EventDataModel();
string user = GetUserDetail();
eventDataModel.UserId = Convert.ToInt32(user.Split('|')[1]);
eventDataModel.Date = model.Date;
eventDataModel.Description = model.Description;
eventDataModel.DurationInHours = (int)model.DurationInHours;
eventDataModel.InviteEmails = model.InviteEmails;
eventDataModel.Location = model.Location;
eventDataModel.OtherDetails = model.OtherDetails;
eventDataModel.StartTime = (DateTime)model.StartTime;
eventDataModel.Title = model.Title;
eventDataModel.Type = model.Type;
eventDataModel.Id = model.Id;
EventService eventService = new EventService();
var result = eventService.EditEvent(eventDataModel);
if (result == null)
{
ModelState.AddModelError("", "Something went wrong...");
return(View());
}
if (user.Split('|')[2] == "normal")
{
return(RedirectToAction("MyEvents"));
}
else
{
return(RedirectToAction("Events"));
}
}
return(View());
}
