public List<Contribution> GetAllContributions()
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Contributions.Include(c => c.Person).ToList();
     }
 }
 public List<Person> GetAllPersons()
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Persons.ToList();
     }
 }
 public Person GetPersonByNickname(string nickname)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Persons.Where(p => p.Nickname.ToLower().Equals(nickname.ToLower())).FirstOrDefault();
     }
 }
 public List<Contribution> GetAllContributionsFromEvent(Event eventTarget)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Include(e => e.Contributions.Select(c=>c.Person)).Where(e => e.Name.Equals(eventTarget.Name)).FirstOrDefault().Contributions.ToList();
     }
 }
 public Contribution GetContributionByName(string name)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Contributions.Where(c => c.Name.ToLower().Equals(name.ToLower())).FirstOrDefault();
     }
 }
 public bool DeleteAllContributionsForAllOpenEventsFromPerson(Person person)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         var PersonInDb = context.Persons.Where(p=>p.Nickname.Equals(person.Nickname)).FirstOrDefault();
         if(PersonInDb==null)
         {
             return false;
         }
         List<Event> openEvents = context.Events.Include(e=>e.Contributions.Select(c=>c.Person)).Where(e=>e.Status.ToString().Equals(EventStatus.Open.ToString())).ToList();
         var contr = context.Contributions.Include(c => c.Person).Where(c => c.Person.Nickname.Equals(PersonInDb.Nickname));
         foreach (var openEvent in openEvents)
         {
             foreach (var cont in contr)
             {
                 if (openEvent.Contributions.Contains(cont))
                 {
                     context.Contributions.Remove(cont);
                 }
             }
         }
         context.SaveChanges();
         return true;
     }
 }
 public List<Event> GetAllEvents()
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.ToList();
     }
 }
 public Event GetEventByName(string name)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Where(e => e.Name.ToLower().Equals(name.ToLower())).FirstOrDefault();
     }
 }
 public Event UpdateEvent(Event updatedEvent)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         // if address or name are null or name is already taken
         if (context.Events.Where(e => e.Name.Equals(updatedEvent.Name) && !e.Id.Equals(updatedEvent.Id)).Count() != 0
             || updatedEvent.Name.Equals("")
             || updatedEvent.Address.Equals("")
             || updatedEvent.Description.Equals(""))
         {
             return null;
         }
         Event eventInDb = context.Events.Where(e => e.Id.Equals(updatedEvent.Id)).FirstOrDefault();
         if (eventInDb == null)
         {
             return null;
         }
         eventInDb.Address = updatedEvent.Address;
         eventInDb.Date = updatedEvent.Date;
         eventInDb.Description = updatedEvent.Description;
         eventInDb.Name = updatedEvent.Name;
         eventInDb.Status = updatedEvent.Status;
         eventInDb.Type = updatedEvent.Type;
         context.SaveChanges();
         return eventInDb;
     }
 }
 public Event AddContribution(Contribution contribution, Event eventTarget)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         var contributionInDb = context.Contributions.Where(c => c.Name.ToLower().Equals(contribution.Name.ToLower())).FirstOrDefault();
         var eventInDb = context.Events.Include(e => e.Contributions).Where(e => e.Name.ToLower().Equals(eventTarget.Name.ToLower())).FirstOrDefault();
         if (contributionInDb == null || eventInDb == null)
         {
             return null;
         }
         eventInDb.Contributions.Add(contributionInDb);
         context.SaveChanges();
         return eventInDb;
     }
 }
 public Person CreatePerson(Person person)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         //can't contain space, or nickname already used, or Firstname AND Lastname couple is already used
         if (context.Persons.Where(c => c.Firstname.ToLower().Equals(person.Firstname) && c.Lastname.ToLower().Equals(person.Lastname.ToLower())).Count() != 0
             || context.Persons.Where(c => c.Nickname.ToLower().Equals(person.Nickname.ToLower())).Count() != 0
             || person.Nickname.Contains(' ') == true)
         {
             return null;
         }
         Person newPerson = context.Persons.Add(person);
         context.SaveChanges();
         return newPerson;
     }
 }
 public bool DeleteEvent(Event eventToDelete)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         Event EventInDb = context.Events.Include(e => e.Persons).Include(e=>e.Contributions).Where(e => e.Id.Equals(eventToDelete.Id)).FirstOrDefault();
         if (EventInDb == null)
         {
             return false;
         }
         EventInDb.Persons.Clear();
         EventInDb.Contributions.Clear();
         context.Events.Remove(EventInDb);
         context.SaveChanges();
         return true;
     }
 }
 public bool DeleteClosedEvents()
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         var closedEvents = context.Events.Where(e => e.Status.ToString().Equals(EventStatus.Closed.ToString())).ToList();
         if (closedEvents == null)
         {
             return false;
         }
         foreach (var closedEvent in closedEvents)
         {
             context.Events.Remove(closedEvent);
         }
         context.SaveChanges();
         return true;
     }
 }
 public Event CreateEvent(Event eventToCreate)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         // if address or name are null or name is already taken
         if(context.Events.Where(e=>e.Name.Equals(eventToCreate.Name)).Count()!=0
             || eventToCreate.Name.Equals("")
             || eventToCreate.Address.Equals("")
             || eventToCreate.Description.Equals(""))
         {
             return null;
         }
         Event newEvent = context.Events.Add(eventToCreate);
         context.SaveChanges();
         return newEvent;
     }
 }
 public Contribution CreateContribution(Contribution contribution)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         if (context.Contributions.Where(c => c.Name.ToLower().Equals(contribution.Name.ToLower())).Count() != 0)
         {
             return null;
         }
         var person = contribution.Person;
         contribution.Person = null;
         Contribution newContribution = context.Contributions.Add(contribution);
         var personInDb = context.Persons.Where(p => p.Id.Equals(person.Id)).FirstOrDefault();
         newContribution.Person = personInDb;
         context.SaveChanges();
         return newContribution;
     }
 }
 public bool AddPersonToOpenEvent(Event eventTarget, Person person)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         Person PersonInDb = context.Persons.Where(p => p.Nickname.ToLower().Equals(person.Nickname.ToLower())).FirstOrDefault();
         if (PersonInDb == null)
         {
             return false;
         }
         if (context.Events.Include(e=>e.Persons).Where(e => e.Name.ToLower().Equals(eventTarget.Name.ToLower())).FirstOrDefault().Persons.Contains(PersonInDb)
             || !context.Events.Where(e=>e.Name.ToLower().Equals(eventTarget.Name.ToLower())).FirstOrDefault().Status.ToString().Equals(EventStatus.Open.ToString()))
         {
             return false;
         }
         context.Events.Where(e => e.Name.Equals(eventTarget.Name)).FirstOrDefault().Persons.Add(PersonInDb);
         context.SaveChanges();
         return true;
     }
 }
        public bool DeletePerson(Person person)
        {
            using (SynchronicWorldContext context = new SynchronicWorldContext())
            {
                Person PersonInDb = context.Persons.Where(p => p.Id.Equals(person.Id)).FirstOrDefault();
                if (PersonInDb == null)
                {
                    return false;
                }
                var contribsToRemove = context.Contributions.Include(c => c.Person).Where(p => p.Person.Id.Equals(person.Id));
                var events = context.Events.Include(e => e.Contributions).Include(e => e.Persons).ToList();
                foreach (var event1 in events)
                {
                    event1.Persons.Remove(PersonInDb);
                    foreach(var contr in contribsToRemove)
                    {
                        event1.Contributions.Remove(contr);
                    }
                }

                // A CONTRIBUTION CAN HAVE NO PERSON
                /*foreach (var contr in contribs)
                {
                    context.Persons.Remove(contr.Person);
                }*/

                // BUT I CHOOSE A CONTRIBUTION MUST HAVE A PERSON, SO I DELETE EVERY CONTRIBUTIONS WHICH HAVE NOBODY NOW
                foreach (var contr in contribsToRemove)
                {
                    context.Contributions.Remove(contr);
                }
                context.Persons.Remove(PersonInDb);
                context.SaveChanges();
                return true;
            }
        }
 public List<Person> GetAllPersonsFromOpenEvent(Event eventTarget)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         if (!context.Events.Where(e => e.Name.ToLower().Equals(eventTarget.Name.ToLower())).FirstOrDefault().Status.ToString().Equals(EventStatus.Open.ToString()))
         {
             return null;
         }
         return context.Events.Include(e => e.Persons).Where(e => e.Name.Equals(eventTarget.Name)).FirstOrDefault().Persons;
     }
 }
 public List<Event> GetEventsByStatus(EventStatus status)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Where(e => e.Status.ToString().Equals(status.ToString())).ToList();
     }
 }
 public List<Event> GetEventsByDate(DateTime date)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Where(e => e.Date.Year.Equals(date.Year) && e.Date.Month.Equals(date.Month) && e.Date.Day.Equals(date.Day)).ToList();
     }
 }
 public List<Event> GetEventsByType(EventType type)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Where(e => e.Type.ToString().Equals(type.ToString())).ToList();
     }
 }
 public bool UpdatePendingEvents()
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         var pendingEvents = context.Events.Where(e => e.Status.ToString().Equals(EventStatus.Pending.ToString())).ToList();
         if (pendingEvents == null)
         {
             return false;
         }
         foreach (var pendingEvent in pendingEvents)
         {
             pendingEvent.Status = EventStatus.Open;
         }
         context.SaveChanges();
         return true;
     }
 }
 public List<Contribution> GetAllContributionsFromPerson(Person person)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         if (context.Persons.Where(c => c.Nickname.ToLower().Equals(person.Nickname.ToLower().FirstOrDefault())) == null)
         {
             return null;
         }
         return context.Contributions.Include(c => c.Person).Where(c => c.Person.Nickname.ToLower().ToString().Equals(person.Nickname.ToLower().ToString())).ToList();
     }
 }
 public List<Event> GetEventsBetweenTwoDates(DateTime startDate, DateTime endDate)
 {
     using (SynchronicWorldContext context = new SynchronicWorldContext())
     {
         return context.Events.Where(e => e.Date >= startDate && e.Date <= endDate).ToList();
     }
 }
        public Person UpdatePerson(Person person)
        {
            using (SynchronicWorldContext context = new SynchronicWorldContext())
            {

                //can't contain space, or nickname already used, or Firstname AND Lastname couple is already used
                if (context.Persons.Where(p => p.Firstname.ToLower().Equals(person.Firstname) && p.Lastname.ToLower().Equals(person.Lastname.ToLower()) && !p.Id.Equals(person.Id)).Count() != 0
                   || context.Persons.Where(p => p.Nickname.ToLower().Equals(person.Nickname.ToLower()) && !p.Id.Equals(person.Id)).Count() != 0
                   || person.Nickname.Contains(' ') == true)
                {
                    return null;
                }
                Person personInDb = context.Persons.Where(p => p.Id.Equals(person.Id)).FirstOrDefault();
                if (personInDb == null)
                {
                    return null;
                }
                personInDb.Firstname = person.Firstname;
                personInDb.Lastname = person.Lastname;
                personInDb.Nickname = person.Nickname;
                context.SaveChanges();
                return personInDb;
            }
        }