private void dgViewPlayerDetails_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
manipulatePlayer = new PlayerBLL();
int columnIndex = dgViewPlayerDetails.CurrentCell.ColumnIndex;
currentPlayerId = int.Parse(dgViewPlayerDetails.CurrentRow.Cells["playerid"].Value.ToString());
if (dgViewPlayerDetails.CurrentRow.Cells[columnIndex].Value.ToString() == "Update")
{
dataTablePlayerData = manipulatePlayer.GetPlayerDetails();
txtFirstName.Text = dataTablePlayerData.Rows[0][1].ToString();
txtLastName.Text = dataTablePlayerData.Rows[0][2].ToString();
txtPlayerName.Text = dataTablePlayerData.Rows[0][3].ToString();
txtPassword.Text = dataTablePlayerData.Rows[0][4].ToString();
btnRegister.Text = "Update";
}
else if (dgViewPlayerDetails.CurrentRow.Cells[columnIndex].Value.ToString() == "Delete")
{
DialogResult confirmResult = MessageBox.Show("Are you sure to delete this item?", "Confirm Delete", MessageBoxButtons.YesNo);
if (confirmResult == DialogResult.Yes)
{
manipulatePlayer.CurrentPlayerId = currentPlayerId;
manipulatePlayer.DeletePlayer();
retrieveCurrentPlayer();
clearControls();
}
}
}
private void btnRegister_Click(object sender, EventArgs e)
{
registerPlayer = new PlayerBLL();
registerPlayer.FirstName = txtFirstName.Text;
registerPlayer.LastName = txtLastName.Text;
registerPlayer.PlayerName = txtPlayerName.Text;
if (txtPassword.Text == txtConfirmPassword.Text)
{
registerPlayer.Password = txtPassword.Text;
}
else
{
lblErrorMessage.Text = "Your password and Confirm Password didnot matched!!!";
lblErrorMessage.Visible = true;
txtConfirmPassword.ForeColor = Color.Red;
return;
}
txtConfirmPassword.ForeColor = Color.Black;
lblErrorMessage.Visible = false;
registerPlayer.AddPlayerDetails();
MessageBox.Show("Player added successfully !!");
retrieveCurrentPlayer();
clearControls();
}
private void generateAllPLayer()
{
allPlayer = new PlayerBLL();
dataTableAllPlayers = allPlayer.GetPlayerDetails();
int x = 20;
int y = 30;
for (int i = 0; i < dataTableAllPlayers.Rows.Count; i++)
{
Button btn = new Button();
btn.Location = new Point(x, y);
btn.Size = new System.Drawing.Size(100, 50);
btn.Text = dataTableAllPlayers.Rows[i][1].ToString();
btn.UseVisualStyleBackColor = true;
grpBoxPlayerSelection.Controls.Add(btn);
y += 60;
if (y > 150)
{
x += 120;
y = 30;
}
btn.Click += (s, e) => {
Game newGame = new Game(_firstPlayer, btn.Text);
this.Hide();
newGame.ShowDialog();
this.Close();
};
}
}
private void btnPlayerLogin_Click(object sender, EventArgs e)
{
player = new PlayerBLL();
player.PlayerName = txtPlayerName.Text;
player.Password = txtPlayerPassword.Text;
DataTable dtPlayerLoginDetails = player.GetPlayerLoginDetails();
if (dtPlayerLoginDetails.Rows.Count == 1)
{
playerWelcome = new FrmWelcome(txtPlayerName.Text);
this.Hide();
playerWelcome.ShowDialog();
this.Close();
}
else
{
lblLoginError.Text = "Username or Password did not matched!!";
lblLoginError.Visible = true;
return;
}
}
public ActionResult NewTeam()
{
ErrorView err = new ErrorView();
TeamCreateVM tcvm = new TeamCreateVM(err);
string name = Request["txtName"];
string tag = Request["txtTag"];
string page = Request["txtPage"];
string schedule = Request["selSchedule"];
var response = Request["g-recaptcha-response"];
//secret that was generated in key value pair
const string secret = "6Lf7tAQTAAAAADkz1pwOVxH04e6WdLDTqRdmVDBf";
var client = new WebClient();
var reply = client.DownloadString(string.Format("https://www.google.com/recaptcha/api/siteverify?secret={0}&response={1}", secret, response));
var captchaResponse = JsonConvert.DeserializeObject <ReCaptchaValidator>(reply);
if (captchaResponse.Success != "False")
{
if (!String.IsNullOrEmpty(name) && !String.IsNullOrEmpty(tag))
{
if (!_teamBLL.TeamPlayerHasTeam(_sessionHelper.CurrentPlayer.Id))
{
if (!_teamBLL.TeamNameVerify(name))
{
if (!_teamBLL.TeamTagVerify(tag))
{
Team t = new Team(name, tag, page, schedule, DateTime.Now);
PlayerBLL p = new PlayerBLL();
t.Captain = _sessionHelper.CurrentPlayer;
t.SubCaptain = new Player();
if (_teamBLL.TeamCreate(t, _sessionHelper.CurrentPlayer.Id))
{
err.HasError = true;
err.MsgError = "Time cadastrado com sucesso!";
}
else
{
err.HasError = true;
err.MsgError = "Erro ao criar o time";
}
}
else
{
err.HasError = true;
err.MsgError = "Esta tag já foi cadastrada no nosso sistema";
}
}
else
{
err.HasError = true;
err.MsgError = "Este nome já foi cadastrado no nosso sistema";
}
}
else
{
err.HasError = true;
err.MsgError = "Você já possui um time, danadin!";
}
}
else
{
err.HasError = true;
err.MsgError = "Por favor preencha os campos corretamente";
}
}
else
{
err.HasError = true;
err.MsgError = "Captcha inválido";
}
return(View("Create", "_Master2", tcvm));
}
public void retrieveCurrentPlayer()
{
playerdata = new PlayerBLL();
dataTablePlayerData = playerdata.GetCurrentPlayerDetails();
dgViewPlayerDetails.DataSource = dataTablePlayerData;
}
public SCMutation(
LeagueBLL leagueBLL,
PlayerBLL playerBLL,
SettingBLL settingBLL,
TournamentBLL tournamentBLL,
FrameBLL frameBLL
)
{
#region Leagues
FieldAsync <LeagueType>(
"createLeague",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LeagueInputType> >
{
Name = "league"
}
),
resolve: async context =>
{
League league = context.GetArgument <League>("league");
return(await context.TryAsyncResolve(
async c => await leagueBLL.CreateLeagueAsync(league)
));
}
);
FieldAsync <LeagueType>(
"updateLeague",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
},
new QueryArgument <NonNullGraphType <LeagueInputType> >
{
Name = "league"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
League league = context.GetArgument <League>("league");
return(await context.TryAsyncResolve(
async c => await leagueBLL.UpdateLeagueAsync(id, league)
));
}
);
FieldAsync <LeagueType>(
"linkPlayerToLeague",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LeaguePlayerInputType> >
{
Name = "leaguePlayer"
}
),
resolve: async context =>
{
LeaguePlayer leaguePlayer = context.GetArgument <LeaguePlayer>("leaguePlayer");
return(await context.TryAsyncResolve(
async c => await leagueBLL.LinkPlayerToLeagueAsync(leaguePlayer)
));
}
);
FieldAsync <LeagueType>(
"unlinkPlayerFromLeague",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <LeaguePlayerInputType> >
{
Name = "leaguePlayer"
}
),
resolve: async context =>
{
LeaguePlayer leaguePlayer = context.GetArgument <LeaguePlayer>("leaguePlayer");
return(await context.TryAsyncResolve(
async c => await leagueBLL.UnlinkPlayerFromLeagueAsync(leaguePlayer)
));
}
);
FieldAsync <BooleanGraphType>(
"removeLeague",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await leagueBLL.RemoveLeagueAsync(id)
));
}
);
#endregion
#region Players
FieldAsync <PlayerType>(
"createPlayer",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerInputType> >
{
Name = "player"
}
),
resolve: async context =>
{
Player player = context.GetArgument <Player>("player");
return(await context.TryAsyncResolve(
async c => await playerBLL.CreatePlayerAsync(player)
));
}
);
FieldAsync <PlayerType>(
"updatePlayer",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
},
new QueryArgument <NonNullGraphType <PlayerInputType> >
{
Name = "player"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
Player player = context.GetArgument <Player>("player");
return(await context.TryAsyncResolve(
async c => await playerBLL.UpdatePlayerAsync(id, player)
));
}
);
FieldAsync <BooleanGraphType>(
"removePlayer",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await playerBLL.RemovePlayerAsync(id)
));
}
);
#endregion
#region Settings
FieldAsync <SettingType>(
"createSetting",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <SettingInputType> >
{
Name = "setting"
}
),
resolve: async context =>
{
Setting setting = context.GetArgument <Setting>("setting");
return(await context.TryAsyncResolve(
async c => await settingBLL.CreateSettingAsync(setting)
));
}
);
FieldAsync <SettingType>(
"updateSetting",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
},
new QueryArgument <NonNullGraphType <SettingInputType> >
{
Name = "setting"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
Setting setting = context.GetArgument <Setting>("setting");
return(await context.TryAsyncResolve(
async c => await settingBLL.UpdateSettingAsync(id, setting)
));
}
);
FieldAsync <BooleanGraphType>(
"removeSetting",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await settingBLL.RemoveSettingAsync(id)
));
}
);
#endregion
#region Tournaments
FieldAsync <TournamentType>(
"createTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TournamentInputType> >
{
Name = "tournament"
}
),
resolve: async context =>
{
Tournament tournament = context.GetArgument <Tournament>("tournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.CreateTournamentAsync(tournament)
));
}
);
FieldAsync <TournamentType>(
"updateTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
},
new QueryArgument <NonNullGraphType <TournamentInputType> >
{
Name = "tournament"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
Tournament tournament = context.GetArgument <Tournament>("tournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.UpdateTournamentAsync(id, tournament)
));
}
);
FieldAsync <TournamentType>(
"linkPlayerToTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerTournamentInputType> >
{
Name = "playerTournament"
}
),
resolve: async context =>
{
PlayerTournament playerTournament = context.GetArgument <PlayerTournament>("playerTournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.LinkPlayerToTournamentAsync(playerTournament)
));
}
);
FieldAsync <TournamentType>(
"unlinkPlayerFromTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerTournamentInputType> >
{
Name = "playerTournament"
}
),
resolve: async context =>
{
PlayerTournament playerTournament = context.GetArgument <PlayerTournament>("playerTournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.UnlinkPlayerFromTournamentAsync(playerTournament)
));
}
);
FieldAsync <TournamentType>(
"linkPlayerPositionToTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerPositionTournamentInputType> >
{
Name = "playerPositionTournament"
}
),
resolve: async context =>
{
PlayerPositionTournament playerPositionTournament = context.GetArgument <PlayerPositionTournament>("playerPositionTournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.LinkPlayerPositionToTournamentAsync(playerPositionTournament)
));
}
);
FieldAsync <TournamentType>(
"unlinkPlayerPositionFromTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <PlayerPositionTournamentInputType> >
{
Name = "playerPositionTournament"
}
),
resolve: async context =>
{
PlayerPositionTournament playerPositionTournament = context.GetArgument <PlayerPositionTournament>("playerPositionTournament");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.UnlinkPlayerPositionFromTournamentAsync(playerPositionTournament)
));
}
);
FieldAsync <BooleanGraphType>(
"removeTournament",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await tournamentBLL.RemoveTournamentAsync(id)
));
}
);
#endregion
#region Frames
FieldAsync <FrameType>(
"createFrame",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <FrameInputType> >
{
Name = "frame"
}
),
resolve: async context =>
{
Frame frame = context.GetArgument <Frame>("frame");
return(await context.TryAsyncResolve(
async c => await frameBLL.CreateFrameAsync(frame)
));
}
);
FieldAsync <FrameType>(
"updateFrame",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
},
new QueryArgument <NonNullGraphType <FrameInputType> >
{
Name = "frame"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
Frame frame = context.GetArgument <Frame>("frame");
return(await context.TryAsyncResolve(
async c => await frameBLL.UpdateFrameAsync(id, frame)
));
}
);
FieldAsync <BooleanGraphType>(
"removeFrame",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}
),
resolve: async context =>
{
Guid id = context.GetArgument <Guid>("id");
return(await context.TryAsyncResolve(
async c => await frameBLL.RemoveFrameAsync(id)
));
}
);
#endregion
}
