private UIElement Add(IEnumerable <string> sportNames)
{
TournamentCreateViewModel viewModel = new TournamentCreateViewModel(sportNames);
TournamentCreateControl control = new TournamentCreateControl(viewModel);
viewModel.TournamentCreated += (s, e) =>
{
TournamentBaseModel tournamentCreateModel = e.Tournament;
TournamentBaseDTO tournamentCreateDTO = Mapper.Map <TournamentBaseModel, TournamentBaseDTO>(tournamentCreateModel);
using (ITournamentService service = factory.CreateTournamentService())
{
ServiceMessage serviceMessage = service.Create(tournamentCreateDTO);
RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message);
if (serviceMessage.IsSuccessful)
{
Notify();
viewModel.Name = String.Empty;
}
}
};
return(control);
}
public ServiceMessage Create(TournamentBaseDTO tournamentCreateDTO)
{
string message = "";
bool success = true;
if (success = Validate(tournamentCreateDTO, ref message))
{
string name = tournamentCreateDTO.Name;
string sportName = tournamentCreateDTO.SportName;
DateTime dateOfStart = tournamentCreateDTO.DateOfStart;
try
{
SportEntity sportEntity = unitOfWork.Sports.Get(sportName);
if (sportEntity != null)
{
bool exists = unitOfWork.Tournaments.Exists(name, sportEntity.Id, dateOfStart);
if (!exists)
{
TournamentEntity tournamentEntity = new TournamentEntity
{
Name = name,
DateOfStart = dateOfStart,
SportId = sportEntity.Id
};
unitOfWork.Tournaments.Add(tournamentEntity);
unitOfWork.Commit();
message = "Created new tournament";
}
else
{
message = "Such tournament already exists";
success = false;
}
}
else
{
message = "No such sport found";
success = false;
}
}
catch (Exception ex)
{
message = ExceptionMessageBuilder.BuildMessage(ex);
success = false;
}
}
return(new ServiceMessage(message, success));
}
private void Delete(TournamentBaseModel tournamentBaseModel)
{
TournamentBaseDTO tournamentBaseDTO = Mapper.Map <TournamentBaseModel, TournamentBaseDTO>(tournamentBaseModel);
using (ITournamentService service = factory.CreateTournamentService())
{
ServiceMessage serviceMessage = service.Delete(tournamentBaseDTO);
RaiseReceivedMessageEvent(serviceMessage);
if (serviceMessage.IsSuccessful)
{
Notify();
}
}
}
public ServiceMessage Delete(TournamentBaseDTO tournamentBaseDTO)
{
string message = "";
bool success = true;
string name = tournamentBaseDTO.Name;
string sportName = tournamentBaseDTO.SportName;
DateTime dateOfStart = tournamentBaseDTO.DateOfStart;
try
{
SportEntity sportEntity = unitOfWork.Sports.Get(sportName);
if (sportEntity != null)
{
TournamentEntity tournamentEntity = unitOfWork.Tournaments.Get(name, sportEntity.Type, dateOfStart);
if (tournamentEntity != null)
{
unitOfWork.Tournaments.Remove(tournamentEntity);
unitOfWork.Commit();
message = "Deleted tournament";
}
else
{
message = "Such tournament doesn't exist";
success = false;
}
}
else
{
message = "No such sport found";
success = false;
}
}
catch (Exception ex)
{
message = ExceptionMessageBuilder.BuildMessage(ex);
success = false;
}
return(new ServiceMessage(message, success));
}
private bool Validate(TournamentBaseDTO tournamentCreateDTO, ref string message)
{
bool isValid = true;
if (tournamentCreateDTO.DateOfStart < DateTime.Now)
{
message = "Invalid date: cannot start tournament in the past";
isValid = false;
}
else if (String.IsNullOrEmpty(tournamentCreateDTO.Name))
{
message = "Invalid name: cannot be empty";
isValid = false;
}
else if (String.IsNullOrEmpty(tournamentCreateDTO.SportName))
{
message = "Invalid sport: cannot be empty";
isValid = false;
}
return(isValid);
}
public UIElement GetDisplayElement()
{
TournamentListViewModel viewModel = new TournamentListViewModel(this, facade);
TournamentListControl control = new TournamentListControl(viewModel);
viewModel.TournamentSelected += (s, e) =>
{
TournamentDisplayModel tournamentDisplayModel = e.Tournament;
TournamentBaseDTO tournamentBaseDTO = Mapper.Map <TournamentDisplayModel, TournamentBaseDTO>(tournamentDisplayModel);
using (IParticipantService service = factory.CreateParticipantService())
{
DataServiceMessage <IEnumerable <ParticipantBaseDTO> > serviceMessage1 = service.GetBySport(tournamentBaseDTO.SportName);
DataServiceMessage <IEnumerable <ParticipantBaseDTO> > serviceMessage2 = service.GetByTournament(tournamentBaseDTO);
RaiseReceivedMessageEvent(serviceMessage1.IsSuccessful, serviceMessage1.Message);
RaiseReceivedMessageEvent(serviceMessage2.IsSuccessful, serviceMessage2.Message);
if (serviceMessage1.IsSuccessful && serviceMessage2.IsSuccessful)
{
IEnumerable <ParticipantBaseModel> sportParticipants = serviceMessage1
.Data
.Select(p => Mapper.Map <ParticipantBaseDTO, ParticipantBaseModel>(p))
.ToList();
IEnumerable <ParticipantBaseModel> tournamentParticipants = serviceMessage2
.Data
.Select(p => Mapper.Map <ParticipantBaseDTO, ParticipantBaseModel>(p))
.ToList();
Edit(tournamentDisplayModel, tournamentParticipants, sportParticipants);
}
}
};
viewModel.TournamentDeleteRequest += (s, e) => Delete(e.Tournament);
return(control);
}
public UIElement GetDisplayElement()
{
EventListViewModel viewModel = new EventListViewModel(this, facade);
EventListControl control = new EventListControl(viewModel);
viewModel.EventSelected += (s, e) =>
{
EventDisplayModel eventDisplayModel = e.Event;
TournamentBaseDTO tournamentBaseDTO = new TournamentBaseDTO
{
Name = eventDisplayModel.TournamentName,
DateOfStart = eventDisplayModel.DateOfTournamentStart,
SportName = eventDisplayModel.SportName
};
using (IParticipantService service = factory.CreateParticipantService())
{
DataServiceMessage <IEnumerable <ParticipantBaseDTO> > serviceMessage = service.GetByTournament(tournamentBaseDTO);
RaiseReceivedMessageEvent(serviceMessage);
if (serviceMessage.IsSuccessful)
{
IEnumerable <ParticipantBaseModel> allParticipants = serviceMessage
.Data
.Select(p => Mapper.Map <ParticipantBaseDTO, ParticipantBaseModel>(p))
.OrderBy(p => p.Name);
Edit(e.Event, allParticipants);
}
}
};
viewModel.EventDeleteRequest += (s, e) => Delete(e.Event);
return(control);
}
public DataServiceMessage <IEnumerable <ParticipantBaseDTO> > GetByTournament(TournamentBaseDTO tournamentBaseDTO)
{
string message;
bool success = true;
IEnumerable <ParticipantBaseDTO> partipantDisplayDTOs = null;
string name = tournamentBaseDTO.Name;
string sportName = tournamentBaseDTO.SportName;
DateTime dateOfStart = tournamentBaseDTO.DateOfStart;
try
{
TournamentEntity tournamentEntity = unitOfWork.Tournaments.Get(name, sportName, dateOfStart);
if (tournamentEntity != null)
{
IEnumerable <ParticipantEntity> participantEntities = tournamentEntity.Participants;
partipantDisplayDTOs = participantEntities
.Select(participant =>
{
return(new ParticipantBaseDTO
{
Name = participant.Name,
CountryName = participant.Country.Name,
SportName = participant.Sport.Type
});
})
.OrderBy(p => p.Name)
.ToList();
message = "Got all participants";
}
else
{
message = "No such tournament found";
success = false;
}
}
catch (Exception ex)
{
message = ExceptionMessageBuilder.BuildMessage(ex);
success = false;
}
return(new DataServiceMessage <IEnumerable <ParticipantBaseDTO> >(partipantDisplayDTOs, message, success));
}
public ServiceMessage Delete(TournamentBaseDTO tournamentBaseDTO)
{
return(new ServiceMessage("No permissions", false));
}
