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 CoefficientCreateViewModel(IEnumerable <string> sports, IEnumerable <TournamentBaseModel> tournaments, IEnumerable <EventBaseModel> events)
{
this.coefficient = new CoefficientCreateModel();
this.CreateCoefficientCommand = new DelegateCommand(() => Create(coefficient), CanCreate);
this.Sports = new ObservableCollection <string>(sports);
this.Tournaments = new ObservableCollection <TournamentBaseModel>(tournaments);
this.Events = new ObservableCollection <EventBaseModel>(events);
this.SortedTournaments.Filter = obj =>
{
TournamentBaseModel t = obj as TournamentBaseModel;
return
(SelectedSport != null &&
t.SportName == SelectedSport);
};
this.SortedEvents.Filter = obj =>
{
EventBaseModel e = obj as EventBaseModel;
return
(SelectedTournament != null &&
e.TournamentName == SelectedTournament.Name &&
e.DateOfTournamentStart == SelectedTournament.DateOfStart);
};
}
private void RaiseTournamentCreatedEvent(TournamentBaseModel tournament)
{
var handler = TournamentCreated;
if (handler != null)
{
TournamentEventArgs e = new TournamentEventArgs(tournament);
handler(this, e);
}
}
public TournamentCreateViewModel(IEnumerable <string> sportNames)
{
tournament = new TournamentBaseModel
{
DateOfStart = DateTime.Now.AddMonths(1)
};
this.CreateTournamentCommand = new DelegateCommand(() => RaiseTournamentCreatedEvent(tournament), CanCreateTournament);
this.Sports = new ObservableCollection <string>(sportNames);
}
public TournamentManageViewModel(TournamentBaseModel tournament, IEnumerable <ParticipantBaseModel> tournamentParticipants, IEnumerable <ParticipantBaseModel> sportParticipants)
{
TournamentEditModel tournamentEditModel = new TournamentEditModel
{
Name = tournament.Name,
SportName = tournament.SportName,
DateOfStart = tournament.DateOfStart,
Participants = new List <ParticipantBaseModel>(tournamentParticipants)
};
InfoViewModel = new TournamentInfoViewModel(tournament);
ParticipantViewModel = new TournamentParticipantViewModel(tournamentEditModel, sportParticipants);
}
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 EventCreateViewModel(IEnumerable <string> sports, IEnumerable <TournamentBaseModel> tournaments, IEnumerable <ParticipantTournamentModel> participants)
{
this.eventCreateModel = new EventCreateModel
{
DateOfEvent = DateTime.Now.AddMonths(2).Date
};
this.Sports = new ObservableCollection <string>(sports);
this.Tournaments = new ObservableCollection <TournamentBaseModel>(tournaments);
this.Participants = new ObservableCollection <ParticipantTournamentModel>(participants);
this.SelectedParticipants = new ObservableCollection <ParticipantTournamentModel>();
this.CreateEventCommand = new DelegateCommand(() => Create(eventCreateModel), CanCreate);
this.MoveToEventCommand = new DelegateCommand(
() => MoveToEvent(SelectedParticipant),
obj => SelectedParticipant != null);
this.MoveAllToEventCommand = new DelegateCommand(
() => MoveAllToEvent(),
obj => true);
this.MoveFromEventCommand = new DelegateCommand(
() => MoveFromEvent(SelectedEventsParticipant),
obj => SelectedEventsParticipant != null);
this.SortedTournaments.Filter = obj =>
{
TournamentBaseModel tournamentBaseModel = obj as TournamentBaseModel;
return(tournamentBaseModel.SportName == SelectedSport);
};
this.SortedParticipants.Filter = obj =>
{
bool isValid = SelectedTournament != null;
if (isValid)
{
ParticipantTournamentModel participantModel = obj as ParticipantTournamentModel;
isValid = participantModel
.Tournaments
.Select(t => t.Name)
.Contains(SelectedTournament.Name) &&
!SelectedParticipants
.Select(p => p.Name)
.Contains(participantModel.Name);
}
return(isValid);
};
}
private void Edit(TournamentBaseModel tournament, IEnumerable <ParticipantBaseModel> tournamentParticipants, IEnumerable <ParticipantBaseModel> sportParticipants)
{
TournamentManageViewModel viewModel = new TournamentManageViewModel(tournament, tournamentParticipants, sportParticipants);
TournamentManageControl control = new TournamentManageControl(viewModel);
Window window = WindowFactory.CreateByContentsSize(control);
viewModel.InfoViewModel.TournamentEdited += (s, e) =>
{
TournamentEditModel tournamentEditModel = e.Tournament;
TournamentEditDTO tournamentEditDTO = Mapper.Map <TournamentEditModel, TournamentEditDTO>(tournamentEditModel);
using (ITournamentService service = factory.CreateTournamentService())
{
ServiceMessage serviceMessage = service.Update(tournamentEditDTO);
RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message);
if (serviceMessage.IsSuccessful)
{
Notify();
}
}
};
viewModel.ParticipantViewModel.TournamentEdited += (s, e) =>
{
TournamentEditModel tournamentEditModel = e.Tournament;
TournamentEditDTO tournamentEditDTO = Mapper.Map <TournamentEditModel, TournamentEditDTO>(tournamentEditModel);
using (ITournamentService service = factory.CreateTournamentService())
{
ServiceMessage serviceMessage = service.UpdateParticipants(tournamentEditDTO);
RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message);
if (serviceMessage.IsSuccessful)
{
Notify();
}
}
};
window.Show();
}
//TODO
//this shit
public BetCreateViewModel(string bookmakerPhoneNumber, IEnumerable <ClientDisplayModel> clients, IEnumerable <string> sports, IEnumerable <TournamentBaseModel> tournaments, IEnumerable <EventBaseModel> events, IEnumerable <CoefficientDisplayModel> coefficients)
{
this.betCreateModel = new BetCreateModel
{
BookmakerPhoneNumber = bookmakerPhoneNumber
};
this.CreateBetCommand = new DelegateCommand(CreateBet, CanCreateBet);
this.Sports = new ObservableCollection <string>(sports);
this.Tournaments = new ObservableCollection <TournamentBaseModel>(tournaments);
this.Events = new ObservableCollection <EventBaseModel>(events);
this.Coefficients = new ObservableCollection <CoefficientDisplayModel>(coefficients);
this.Clients = new ObservableCollection <ClientDisplayModel>(clients);
this.SortedTournaments.Filter = obj =>
{
TournamentBaseModel t = obj as TournamentBaseModel;
return
(SelectedSport != null &&
t.SportName == SelectedSport);
};
this.SortedEvents.Filter = obj =>
{
EventBaseModel e = obj as EventBaseModel;
return
(SelectedSport != null &&
SelectedTournament != null &&
e.SportName == SelectedSport &&
e.TournamentName == SelectedTournament.Name);
};
this.SortedCoefficients.Filter = obj =>
{
CoefficientBaseModel c = obj as CoefficientBaseModel;
bool valid =
SelectedSport != null &&
SelectedTournament != null &&
SelectedEvent != null &&
c.SportName == SelectedSport &&
c.TournamentName == SelectedTournament.Name &&
c.DateOfEvent == SelectedEvent.DateOfEvent;
if (valid)
{
valid = c.Participants.Count == SelectedEvent.Participants.Count;
if (valid)
{
for (int i = 0; i < c.Participants.Count; i++)
{
var p1 = c.Participants
.OrderBy(p => p.Name)
.ThenBy(p => p.CountryName)
.ThenBy(p => p.SportName)
.ElementAt(i);
var p2 = SelectedEvent.Participants
.OrderBy(p => p.Name)
.ThenBy(p => p.CountryName)
.ThenBy(p => p.SportName)
.ElementAt(i);
valid =
p1.Name == p2.Name &&
p1.CountryName == p2.CountryName &&
p1.SportName == p2.SportName;
if (!valid)
{
break;
}
}
}
}
return(valid);
};
}
public TournamentEventArgs(TournamentBaseModel tournament)
{
this.Tournament = tournament;
}
