private void btnDelete_Click(object sender, EventArgs e)
{
string teamToBeDELETED = lbTeamList.SelectedItem.ToString();
TeamsEntity selT = storeHelper.TeamsList.FirstOrDefault(w => w.TeamName == teamToBeDELETED);
List <WrestlersEntity> wrests = storeHelper.WrestlersList.Where(w => w.TeamName == teamToBeDELETED).ToList();
foreach (WrestlersEntity w in wrests)
{
w.TeamName = "";
wHelper.SaveWrestlersList(w);
}
string file = string.Concat(Directory.GetCurrentDirectory(), "\\Saves\\Main\\Teams\\" + selT.TeamID + ".dat");
if (File.Exists(file))
{
File.Delete(file);
}
EditMain main = new EditMain();
main.Show();
this.Hide();
}
public ModTeamsAdjMems(string orgName, string teamName)
{
InitializeComponent();
OrgName = orgName;
TeamName = teamName;
PromotionsEntity promo = pHelper.PopulatePromotionsList().FirstOrDefault(p => p.Name == OrgName);
TeamsEntity team = tHelper.PopulateTeamsList().FirstOrDefault(t => t.TeamName == TeamName);
storeHelper.BrandsList = bHelper.PopulateBrandsList().Where(b => b.ConnOrgName == promo.Name).ToList();
storeHelper.WrestlersList = wHelper.PopulateWrestlersList().Where(w => w.CurrentCompanyName == promo.Name).ToList();
List <WrestlersEntity> teamW = storeHelper.WrestlersList.Where(w => w.TeamName != "").ToList();
List <WrestlersEntity> roster = storeHelper.WrestlersList.Except(teamW).ToList();
foreach (WrestlersEntity w in roster)
{
lbRoster.Items.Add(w.Name);
}
foreach (WrestlersEntity w in teamW)
{
if (w.TeamName == TeamName)
{
lbSelWrestlers.Items.Add(w.Name);
}
}
lbRoster.Enabled = false;
lbSelWrestlers.Enabled = false;
btnSave.Enabled = false;
}
/// <summary>
/// Transfer the owner of the team to another user
/// </summary>
/// <param name="teamName">The team name</param>
/// <param name="newOwner">The new owner username</param>
/// <param name="jwtUsername">The JWT request username</param>
/// <returns></returns>
public async Task <TeamsEntity> TransferOwner(string teamName, string newOwner, string jwtUsername)
{
TeamsEntity teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(teamName);
if (teamsEntity == null)
{
throw new Exception("No team found");
}
if (teamsEntity.TeamOwner != jwtUsername)
{
throw new Exception("Can only transfer owner of the team if you are the current owner");
}
UsersEntity userEntity = await this._dynamoDbService.GetItemAsync <UsersEntity>(newOwner);
if (userEntity == null)
{
throw new Exception("Username is not a valid user");
}
teamsEntity.TeamOwner = newOwner;
if (!teamsEntity.AdminUsers.Contains(newOwner))
{
teamsEntity.AdminUsers.Add(newOwner);
}
if (!teamsEntity.Users.Contains(newOwner))
{
teamsEntity.Users.Add(newOwner);
}
return(await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamsEntity));
}
/// <summary>
///
/// </summary>
/// <param name="teamName"></param>
/// <param name="username"></param>
/// <param name="jwtUsername"></param>
/// <returns></returns>
public async Task <TeamsEntity> RevokeAdminUserPermission(string teamName, string username, string jwtUsername)
{
TeamsEntity teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(teamName);
if (teamsEntity == null)
{
throw new Exception("No team found");
}
if (!teamsEntity.AdminUsers.Contains(jwtUsername))
{
throw new Exception("Do not have permission to remove a user");
}
if (teamsEntity.TeamOwner == username)
{
throw new Exception("Can not remove the owner of the team");
}
if (!teamsEntity.Users.Contains(username))
{
throw new Exception("Username does not exist in the team");
}
teamsEntity.Users = teamsEntity.Users.Where(u => u != username).ToList();
return(await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamsEntity));
}
/// <summary>
/// Checks if the user can update the package
/// </summary>
/// <param name="adminUsers"></param>
/// <param name="jwtUsername"></param>
/// <param name="team"></param>
/// <returns>bool</returns>
private async Task <bool> AllowedToUpdatePackageAsync(string team,
IList <string> adminUsers,
string jwtUsername)
{
if (!string.IsNullOrEmpty(team))
{
TeamsEntity teamDetails = await this._dynamoDbService.GetItemAsync <TeamsEntity>(team);
if (teamDetails == null)
{
return(false);
}
if (teamDetails.AdminUsers.Contains(jwtUsername))
{
return(true);
}
}
else if (adminUsers.Contains(jwtUsername))
{
return(true);
}
return(false);
}
public ModTeamsTitles(string teamName, string orgName)
{
InitializeComponent();
TeamName = teamName;
OrgName = orgName;
PromotionsEntity promo = pHelper.PopulatePromotionsList().FirstOrDefault(p => p.Name == OrgName);
TeamsEntity team = teHelper.PopulateTeamsList().FirstOrDefault(t => t.TeamName == TeamName);
BrandsEntity brand = bHelper.PopulateBrandsList().FirstOrDefault(b => b.ConnOrgName == promo.Name && b.Name == team.BrandName);
storeHelper.TitlesList = tHelper.PopulateTitlesList().Where(t => t.OwnerOrgName == promo.Name).ToList();
if (brand == null)
{
List <TitlesEntity> titles = storeHelper.TitlesList.Where(t => t.Specialization != "Singles Championship").ToList();
List <TitlesEntity> ownedTitles = storeHelper.TitlesList.Where(t => t.Specialization != "Singles Championship" &&
!String.IsNullOrWhiteSpace(t.HolderName1) &&
!String.IsNullOrWhiteSpace(t.HolderName2) ||
!String.IsNullOrWhiteSpace(t.HolderName3) ||
!String.IsNullOrWhiteSpace(t.HolderName4)).ToList();
foreach (TitlesEntity t in titles)
{
lbAllTeamTitles.Items.Add(t.Name);
}
foreach (TitlesEntity ot in ownedTitles)
{
if (lbSelTeamTitles.Items.Count < 7)
{
lbSelTeamTitles.Items.Add(ot.Name);
}
}
}
else
{
List <TitlesEntity> titles = storeHelper.TitlesList.Where(t => t.Specialization != "Singles Championship" && t.BrandName == brand.Name).ToList();
List <TitlesEntity> ownedTitles = storeHelper.TitlesList.Where(t => t.Specialization != "Singles Championship" &&
t.BrandName == brand.Name &&
!String.IsNullOrWhiteSpace(t.HolderName1) &&
!String.IsNullOrWhiteSpace(t.HolderName2) ||
!String.IsNullOrWhiteSpace(t.HolderName3) ||
!String.IsNullOrWhiteSpace(t.HolderName4)).ToList();
foreach (TitlesEntity t in titles)
{
lbAllTeamTitles.Items.Add(t.Name);
}
foreach (TitlesEntity ot in ownedTitles)
{
lbSelTeamTitles.Items.Add(ot.Name);
}
}
}
private void btnSelMembers_Click(object sender, EventArgs e)
{
string asscCo;
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == lbTeamList.SelectedItem.ToString());
asscCo = team.OrgName;
TeamAddWrestlers wrest = new TeamAddWrestlers(team.TeamName, asscCo);
wrest.Show();
}
private void lbTeamList_SelectedIndexChanged(object sender, EventArgs e)
{
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == lbTeamList.SelectedItem.ToString());
tbNewName.Text = team.TeamName;
tbWins.Text = team.Wins.ToString();
tbLosses.Text = team.Losses.ToString();
tbDraws.Text = team.Draws.ToString();
cbxAsscCo.SelectedItem = team.OrgName;
btnDelete.Enabled = true;
btnEditTeam.Enabled = true;
}
private void cbxTeams_SelectedIndexChanged(object sender, EventArgs e)
{
btnEditTeam.Enabled = true;
btnDelTeam.Enabled = true;
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == cbxTeams.SelectedItem.ToString());
tbNewName.Text = team.TeamName;
cbxAsscBrand.SelectedItem = team.BrandName;
tbWins.Text = team.Wins.ToString();
tbLosses.Text = team.Losses.ToString();
tbDraws.Text = team.Draws.ToString();
}
/// <summary>
/// This unpublishs a package if it was created before 72 hours ago
/// </summary>
/// <param name="packageName">The package name</param>
/// <param name="jwtUsername">The JWT username</param>
/// <returns></returns>
public async Task UnpublishPackage(string packageName,
string jwtUsername)
{
UsersEntity user = await this._dynamoDbService.GetItemAsync <UsersEntity>(jwtUsername);
TeamsEntity team = null;
PackageDetailsEntity packageDetails = await this._dynamoDbService.GetItemAsync <PackageDetailsEntity>(packageName);
if (packageDetails == null)
{
throw new Exception("Package does not exist");
}
if (packageDetails.Team != null)
{
team = await this._dynamoDbService.GetItemAsync <TeamsEntity>(packageDetails.Team);
if (!team.AdminUsers.Contains(jwtUsername))
{
throw new Exception("You are not allowed to unpublish this package");
}
}
else
{
if (!packageDetails.AdminUsers.Contains(jwtUsername))
{
throw new Exception("You are not allowed to unpublish this package");
}
}
DateTime unpublishedMaxDate = packageDetails.CreatedOn.AddDays(3);
if (unpublishedMaxDate > DateTime.UtcNow)
{
throw new Exception("You can only unpublish a package 72 hours after it has been created. Please mark it as deprecated");
}
await this._dynamoDbService.DeleteItemAsync <PackageDetailsEntity>(packageName);
if (team != null)
{
team.Packages = team.Packages.Where(p => p != packageName).ToList();
await this._dynamoDbService.PutItemAsync <TeamsEntity>(team);
}
else
{
user.Packages = user.Packages.Where(p => p != packageName).ToList();
await this._dynamoDbService.PutItemAsync <UsersEntity>(user);
}
}
public TeamAddWrestlers(string teamName, string coName)
{
InitializeComponent();
TeamName = teamName;
CoName = coName;
storeHelper.WrestlersList = wHelper.PopulateWrestlersList();
storeHelper.TeamsList = tHelper.PopulateTeamsList();
TeamsEntity currTeam = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == TeamName);
List <string> teamMemsList = new List <string>();
teamMemsList.Add(currTeam.MemberName1);
teamMemsList.Add(currTeam.MemberName2);
teamMemsList.Add(currTeam.MemberName3);
teamMemsList.Add(currTeam.MemberName4);
List <WrestlersEntity> promoWrest = storeHelper.WrestlersList.Where(w => w.CurrentCompanyName == coName).ToList();
List <string> allNames = new List <string>();
foreach (WrestlersEntity all in promoWrest)
{
allNames.Add(all.Name);
}
List <string> withoutMems = allNames.Except(teamMemsList).ToList();
foreach (string a in withoutMems)
{
lbRoster.Items.Add(a);
}
foreach (string team in teamMemsList)
{
if (string.IsNullOrWhiteSpace(team))
{
}
else
{
lbSelected.Items.Add(team);
}
}
}
private void button4_Click(object sender, EventArgs e)
{
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == cbxTeams.SelectedItem.ToString());
team.TeamName = tbNewName.Text;
team.BrandName = cbxAsscBrand.SelectedItem.ToString();
team.Wins = Convert.ToInt32(tbWins.Text);
team.Losses = Convert.ToInt32(tbLosses.Text);
team.Draws = Convert.ToInt32(tbDraws.Text);
tHelper.SaveTeamsList(team);
ModifyMain main = new ModifyMain(OrgName);
main.Show();
this.Hide();
}
private void button4_Click(object sender, EventArgs e)
{
foreach (var t in lbSelTeamTitles.Items)
{
TitlesEntity title = tHelper.PopulateTitlesList().FirstOrDefault(ti => ti.Name == t.ToString());
TeamsEntity team = teHelper.PopulateTeamsList().FirstOrDefault(te => te.TeamName == TeamName);
title.HolderName1 = team.MemberName1;
title.HolderName2 = team.MemberName2;
title.HolderName3 = team.MemberName3;
title.HolderName4 = team.MemberName4;
tHelper.SaveTitlesList(title);
}
;
this.Hide();
}
/// <summary>
///
/// </summary>
/// <param name="packageName"></param>
/// <param name="jwtUsername"></param>
/// <param name="deprecate"></param>
/// <returns></returns>
public async Task UpdateDeprecateValueInPackage(string packageName,
string jwtUsername,
bool deprecate)
{
PackageDetailsEntity packageDetails =
await this._dynamoDbService.GetItemAsync <PackageDetailsEntity>(packageName);
if (packageDetails == null)
{
throw new Exception("This package does not exist");
}
// if the package is already deprecate do not
// call anymore api logic
if (packageDetails.Deprecated == deprecate)
{
return;
}
// is team
if (!string.IsNullOrEmpty(packageDetails.Team))
{
TeamsEntity teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(packageDetails.Team);
if (!teamsEntity.AdminUsers.Contains(jwtUsername))
{
throw new Exception("You are not allowed to mark this package as deprecated");
}
packageDetails.Deprecated = deprecate;
}
// it is a normal user who owns the package
else
{
if (!packageDetails.AdminUsers.Contains(jwtUsername))
{
throw new Exception("You are not allowed to mark this package as deprecated");
}
}
packageDetails.Deprecated = deprecate;
await this._dynamoDbService.PutItemAsync <PackageDetailsEntity>(packageDetails);
}
/// <summary>
/// Create a team
/// </summary>
/// <param name="teamName"></param>
/// <param name="isPrivate"></param>
/// <param name="username"></param>
/// <returns></returns>
public async Task <TeamsEntity> CreateTeam(string teamName, bool isPrivate, string username)
{
// need to check if team name already exists - will do that later
TeamsEntity teamEntity = new TeamsEntity()
{
TeamName = teamName,
TeamOwner = username,
AdminUsers = new List <string>()
{
username
},
Users = new List <string>()
{
username
},
Private = isPrivate,
Packages = new List <string>(),
Deprecated = false,
};
return(await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamEntity));
}
private void btnDelTeam_Click(object sender, EventArgs e)
{
string selBrand = cbxTeams.SelectedItem.ToString();
for (int i = cbxTeams.Items.Count - 1; i >= 0; --i)
{
if (cbxTeams.Items[i].ToString().Contains(selBrand))
{
cbxTeams.Items.RemoveAt(i);
}
}
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == cbxTeams.SelectedItem.ToString());
string file = string.Concat(Directory.GetCurrentDirectory(), "\\Saves\\Main\\Teams\\" + team.TeamID + ".dat");
if (File.Exists(file))
{
File.Delete(file);
}
cbxTeams.Refresh();
}
/// <summary>
/// Add user to a team
/// </summary>
/// <param name="teamName"></param>
/// <param name="newUser"></param>
/// <param name="isAdmin"></param>
/// <param name="adminUser"></param>
/// <returns></returns>
public async Task <TeamsEntity> AddUser(string teamName, string newUser, bool isAdmin, string adminUser)
{
UsersEntity userEntity = await this._dynamoDbService.GetItemAsync <UsersEntity>(newUser);
if (userEntity == null)
{
throw new Exception("Username is not a valid user");
}
// if (userEntity.Teams != null && !userEntity.Teams.Contains(teamName)) - need this line as some calls may not be needed
TeamsEntity teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(teamName);
if (teamsEntity == null)
{
throw new Exception("No team found");
}
if (teamsEntity.AdminUsers.Contains(adminUser))
{
if (isAdmin && !teamsEntity.AdminUsers.Contains(newUser))
{
teamsEntity.AdminUsers.Add(newUser);
}
if (!teamsEntity.Users.Contains(newUser))
{
teamsEntity.Users.Add(newUser);
}
return(await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamsEntity));
}
else
{
throw new Exception("Not allowed to update this team");
}
}
public void SaveTeamsList(TeamsEntity team)
{
FileStream stream = new FileStream(Directory.GetCurrentDirectory() + "\\Saves\\Main\\Teams\\" + team.TeamID + ".dat", FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream);
writer.WriteLine(team.TeamID);
writer.WriteLine(team.TeamName);
writer.WriteLine(team.OrgName);
writer.WriteLine(team.BrandName);
writer.WriteLine(team.Wins);
writer.WriteLine(team.Losses);
writer.WriteLine(team.Draws);
writer.WriteLine(team.MemberName1);
writer.WriteLine(team.MemberName2);
writer.WriteLine(team.MemberName3);
writer.WriteLine(team.MemberName4);
writer.Close();
stream.Close();
}
/// <summary>
///
/// </summary>
/// <param name="packageFiles"></param>
/// <param name="ethereumPmMetaData"></param>
/// <param name="jwtUsername"></param>
/// <returns></returns>
public async Task UploadPackageAsync(PackageFiles packageFiles,
EthereumPmMetaData ethereumPmMetaData,
string jwtUsername)
{
PackageDetailsEntity packageDetails =
await this._dynamoDbService.GetItemAsync <PackageDetailsEntity>(packageFiles.PackageName);
// if it is null then its a brand new package
if (packageDetails == null)
{
// should be in a transaction which i will put in, as if one of these
// fails then i want to roll back all the data, i don't really want to
// to insert then delete so will look at dynamodb to see if this rollback
// logic exists
TeamsEntity teamsEntity = null;
// if it is a package for a team
if (!string.IsNullOrEmpty(ethereumPmMetaData.Team))
{
teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(ethereumPmMetaData.Team);
if (teamsEntity == null)
{
throw new Exception("Team does not exists");
}
packageDetails = new PackageDetailsEntity
{
PackageName = packageFiles.PackageName,
Version = new List <string> {
packageFiles.Version
},
Description = ethereumPmMetaData.Description,
Keywords = ethereumPmMetaData.Keywords,
Private = ethereumPmMetaData.Private,
Team = ethereumPmMetaData.Team,
GitHub = ethereumPmMetaData.GitHub,
Owner = ethereumPmMetaData.Team,
LatestVersion = packageFiles.Version,
Deprecated = false,
CreatedOn = DateTime.UtcNow
};
}
else
{
packageDetails = new PackageDetailsEntity
{
PackageName = packageFiles.PackageName,
Version = new List <string> {
packageFiles.Version
},
Description = ethereumPmMetaData.Description,
Keywords = ethereumPmMetaData.Keywords,
Private = ethereumPmMetaData.Private,
Team = ethereumPmMetaData.Team,
GitHub = ethereumPmMetaData.GitHub,
Owner = jwtUsername,
LatestVersion = packageFiles.Version,
Deprecated = false,
AdminUsers = new List <string> {
jwtUsername
},
Users = new List <string> {
jwtUsername
},
CreatedOn = DateTime.UtcNow
};
}
await this._dynamoDbService.PutItemAsync <PackageDetailsEntity>(packageDetails);
if (teamsEntity != null)
{
if (teamsEntity.Packages == null || teamsEntity.Packages.GetType() != typeof(List <string>))
{
teamsEntity.Packages = new List <string>();
}
teamsEntity.Packages.Add(packageFiles.PackageName);
await this._dynamoDbService.PutItemAsync <TeamsEntity>(teamsEntity);
}
else
{
// as they have authenticated with the request the user should always exist
// do not want to do a load on db to check each time
UsersEntity usersEntity = await this._dynamoDbService.GetItemAsync <UsersEntity>(jwtUsername);
if (usersEntity.Packages == null || usersEntity.Packages.GetType() != typeof(List <string>))
{
usersEntity.Packages = new List <string>();
}
usersEntity.Packages.Add(packageFiles.PackageName);
await this._dynamoDbService.PutItemAsync <UsersEntity>(usersEntity);
}
}
else
{
if (!this.UpdatingPackageHigherVersionThenCurrent(packageDetails.LatestVersion, packageFiles.Version))
{
throw new Exception("Your package version is not higher then the current one");
}
bool allowedToUpdatePackage =
await this.AllowedToUpdatePackageAsync(packageDetails.Team, packageDetails.AdminUsers, jwtUsername);
if (!allowedToUpdatePackage)
{
throw new Exception("You are not allowed to update this package");
}
packageDetails.Version.Add(packageFiles.Version);
packageDetails.GitHub = ethereumPmMetaData.GitHub;
packageDetails.LatestVersion = packageFiles.Version;
packageDetails.Description = ethereumPmMetaData.Description;
packageDetails.Keywords = ethereumPmMetaData.Keywords;
await this._dynamoDbService.PutItemAsync <PackageDetailsEntity>(packageDetails);
}
// upload the files last, this means it all has been successfully inserted into
// the db
string keyName = $"{packageFiles.PackageName}/{packageFiles.Version}";
await this._s3Service.UploadFilesAsync(packageFiles.Files.ToS3Files(), keyName);
}
private void button4_Click(object sender, EventArgs e)
{
if (isEdit)
{
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == lbTeamList.SelectedItem.ToString());
foreach (TeamsEntity t in storeHelper.TeamsList)
{
if (team.TeamID == t.TeamID)
{
if (tbNewName.Text == "")
{
tbNewName.BackColor = Color.MistyRose;
}
else
{
int wins = 0;
int losses = 0;
int draws = 0;
string asscCo;
int tempWins = 0;
int tempLoss = 0;
int tempDraws = 0;
if (tbWins.Text == "" ||
tbLosses.Text == "" ||
tbDraws.Text == "")
{
wins = 0;
losses = 0;
draws = 0;
}
else if (int.TryParse(tbWins.Text, out tempWins) &&
int.TryParse(tbLosses.Text, out tempLoss) &&
int.TryParse(tbDraws.Text, out tempDraws))
{
wins = tempWins;
losses = tempLoss;
draws = tempDraws;
if (string.IsNullOrWhiteSpace(cbxAsscCo.SelectedItem.ToString()))
{
asscCo = "";
}
else
{
asscCo = cbxAsscCo.SelectedItem.ToString();
}
team.TeamName = tbNewName.Text;
team.OrgName = asscCo;
team.Wins = wins;
team.Losses = losses;
team.Draws = draws;
tHelper.SaveTeamsList(team);
EditMain main = new EditMain();
main.Show();
this.Hide();
}
else
{
tbWins.BackColor = Color.MistyRose;
tbLosses.BackColor = Color.MistyRose;
tbDraws.BackColor = Color.MistyRose;
}
}
}
}
}
else
{
if (tbNewName.Text == "")
{
tbNewName.BackColor = Color.MistyRose;
}
else
{
int wins = 0;
int losses = 0;
int draws = 0;
string asscCo;
int tempWins = 0;
int tempLoss = 0;
int tempDraws = 0;
if (tbWins.Text == "" ||
tbLosses.Text == "" ||
tbDraws.Text == "")
{
wins = 0;
losses = 0;
draws = 0;
}
else if (int.TryParse(tbWins.Text, out tempWins) &&
int.TryParse(tbLosses.Text, out tempLoss) &&
int.TryParse(tbDraws.Text, out tempDraws))
{
wins = tempWins;
losses = tempLoss;
draws = tempDraws;
TeamsEntity team = storeHelper.TeamsList.FirstOrDefault(t => t.TeamName == lbTeamList.SelectedItem.ToString());
if (string.IsNullOrWhiteSpace(cbxAsscCo.SelectedItem.ToString()))
{
asscCo = "";
}
else
{
asscCo = cbxAsscCo.SelectedItem.ToString();
}
TeamsEntity newTeam = new TeamsEntity()
{
TeamID = idHelper.CurrentID(false, false, false, false, true, false, false),
TeamName = tbNewName.Text,
OrgName = asscCo,
Wins = wins,
Losses = losses,
Draws = draws
};
tHelper.SaveTeamsList(newTeam);
EditMain main = new EditMain();
main.Show();
this.Hide();
}
else
{
tbWins.BackColor = Color.MistyRose;
tbLosses.BackColor = Color.MistyRose;
tbDraws.BackColor = Color.MistyRose;
}
}
}
}
/// <summary>
/// Gets all the package files from s3
/// </summary>
/// <param name="packageName">The package name</param>
/// <param name="version">The version requested</param>
/// <param name="jwtUsername"></param>
/// <returns>A read only collection of package files</returns>
public async Task <PackageFiles> GetPackageFilesAsync(string packageName,
string version,
string jwtUsername)
{
PackageDetailsEntity packageDetails =
await this._dynamoDbService.GetItemAsync <PackageDetailsEntity>(packageName);
if (packageDetails == null)
{
throw new Exception("Package does not exist");
}
// if it is a private package lets check this person can install it
if (packageDetails.Private)
{
// is team
if (!string.IsNullOrEmpty(packageDetails.Team))
{
TeamsEntity teamsEntity = await this._dynamoDbService.GetItemAsync <TeamsEntity>(packageDetails.Team);
if (!teamsEntity.Users.Contains(jwtUsername))
{
throw new Exception("You are not allowed to install this package");
}
}
// it is a normal user who owns the package
else
{
if (!packageDetails.Users.Contains(jwtUsername))
{
throw new Exception("You are not allowed to install this package");
}
}
}
IList <PackageFile> files = new List <PackageFile>();
ListObjectsV2Response packageFilesResponse;
string prefix = $"{packageName}/{version}/";
do
{
ListObjectsV2Request requestPackages = new ListObjectsV2Request()
{
BucketName = this._s3Service.GetBucketName(),
Prefix = prefix
};
packageFilesResponse = await this._s3client.ListObjectsV2Async(requestPackages);
foreach (S3Object entry in packageFilesResponse.S3Objects)
{
if (entry.Key != prefix)
{
GetObjectRequest request = new GetObjectRequest
{
BucketName = entry.BucketName,
Key = entry.Key
};
using (var response = await this._s3client.GetObjectAsync(request))
{
using (var responseStream = response.ResponseStream)
{
using (var reader = new StreamReader(responseStream))
{
string name = this.ParsePackageFileName(prefix, entry.Key);
string responseContent = reader.ReadToEnd();
files.Add(new PackageFile(name, responseContent));
}
}
}
}
}
} while (packageFilesResponse.IsTruncated);
return(new PackageFiles(version, packageName, (IReadOnlyCollection <PackageFile>)files));
}
private void button4_Click(object sender, EventArgs e)
{
if (lbRoster.Items.Count > 1)
{
foreach (var unSel in lbRoster.Items)
{
foreach (WrestlersEntity w in storeHelper.WrestlersList)
{
if (unSel.ToString() == w.Name && w.TeamName == TeamName)
{
w.TeamName = "";
wHelper.SaveWrestlersList(w);
}
}
}
}
if (lbSelected.Items.Count >= 2)
{
List <WrestlersEntity> all = wHelper.PopulateWrestlersList();
TeamsEntity t = storeHelper.TeamsList.FirstOrDefault(tw => tw.TeamName == TeamName);
WrestlersEntity w1 = new WrestlersEntity();
WrestlersEntity w2 = new WrestlersEntity();
WrestlersEntity w3 = new WrestlersEntity();
WrestlersEntity w4 = new WrestlersEntity();
if (lbSelected.Items.Count == 2)
{
w1 = all.FirstOrDefault(s => s.Name == lbSelected.Items[0].ToString());
w2 = all.FirstOrDefault(s => s.Name == lbSelected.Items[1].ToString());
w1.TeamName = TeamName;
w2.TeamName = TeamName;
t.MemberName1 = w1.Name;
t.MemberName2 = w2.Name;
wHelper.SaveWrestlersList(w1);
wHelper.SaveWrestlersList(w2);
tHelper.SaveTeamsList(t);
this.Hide();
}
else if (lbSelected.Items.Count == 3)
{
w1 = all.FirstOrDefault(s => s.Name == lbSelected.Items[0].ToString());
w2 = all.FirstOrDefault(s => s.Name == lbSelected.Items[1].ToString());
w3 = all.FirstOrDefault(s => s.Name == lbSelected.Items[2].ToString());
w1.TeamName = TeamName;
w2.TeamName = TeamName;
w3.TeamName = TeamName;
t.MemberName1 = w1.Name;
t.MemberName2 = w2.Name;
t.MemberName3 = w3.Name;
wHelper.SaveWrestlersList(w1);
wHelper.SaveWrestlersList(w2);
wHelper.SaveWrestlersList(w3);
tHelper.SaveTeamsList(t);
this.Hide();
}
else if (lbSelected.Items.Count == 4)
{
w1 = all.FirstOrDefault(s => s.Name == lbSelected.Items[0].ToString());
w2 = all.FirstOrDefault(s => s.Name == lbSelected.Items[1].ToString());
w3 = all.FirstOrDefault(s => s.Name == lbSelected.Items[2].ToString());
w4 = all.FirstOrDefault(s => s.Name == lbSelected.Items[3].ToString());
w1.TeamName = TeamName;
w2.TeamName = TeamName;
w3.TeamName = TeamName;
w4.TeamName = TeamName;
t.MemberName1 = w1.Name;
t.MemberName2 = w2.Name;
t.MemberName3 = w3.Name;
t.MemberName4 = w4.Name;
wHelper.SaveWrestlersList(w1);
wHelper.SaveWrestlersList(w2);
wHelper.SaveWrestlersList(w3);
wHelper.SaveWrestlersList(w4);
tHelper.SaveTeamsList(t);
this.Hide();
}
}
}
private void btnSave_Click(object sender, EventArgs e)
{
TeamsEntity newTeam = new TeamsEntity();
List <WrestlersEntity> wrestUpdate = new List <WrestlersEntity>();
for (int i = 0; i < lbSelWrestlers.Items.Count; i++)
{
switch (lbSelWrestlers.Items.Count)
{
case 2:
newTeam = new TeamsEntity()
{
TeamName = TeamName,
OrgName = OrgName,
Wins = 0,
Losses = 0,
Draws = 0,
MemberName1 = lbSelWrestlers.Items[0].ToString(),
MemberName2 = lbSelWrestlers.Items[1].ToString()
};
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[0].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[1].ToString()));
break;
case 3:
newTeam = new TeamsEntity()
{
TeamName = TeamName,
OrgName = OrgName,
Wins = 0,
Losses = 0,
Draws = 0,
MemberName1 = lbSelWrestlers.Items[0].ToString(),
MemberName2 = lbSelWrestlers.Items[1].ToString(),
MemberName3 = lbSelWrestlers.Items[2].ToString()
};
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[0].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[1].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[2].ToString()));
break;
case 4:
newTeam = new TeamsEntity()
{
TeamName = TeamName,
OrgName = OrgName,
Wins = 0,
Losses = 0,
Draws = 0,
MemberName1 = lbSelWrestlers.Items[0].ToString(),
MemberName2 = lbSelWrestlers.Items[1].ToString(),
MemberName3 = lbSelWrestlers.Items[2].ToString(),
MemberName4 = lbSelWrestlers.Items[3].ToString()
};
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[0].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[1].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[2].ToString()));
wrestUpdate.Add(storeHelper.WrestlersList.FirstOrDefault(w => w.Name == lbSelWrestlers.Items[3].ToString()));
break;
default:
lbSelWrestlers.BackColor = Color.MistyRose;
break;
}
}
foreach (WrestlersEntity w in wrestUpdate)
{
w.TeamName = TeamName;
wHelper.SaveWrestlersList(w);
}
tHelper.SaveTeamsList(newTeam);
this.Hide();
}
public List <TeamsEntity> PopulateTeamsList()
{
List <TeamsEntity> teamList = new List <TeamsEntity>();
string dir = string.Concat(Directory.GetCurrentDirectory(), "\\Saves\\Main\\Teams");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(string.Concat(Directory.GetCurrentDirectory(), "\\Saves\\Main\\Teams"));
}
else
{
FileInfo[] files = (new DirectoryInfo(dir).GetFiles("*.dat"));
if (files.Length > 0)
{
for (int i = 0; i < files.Length; i++)
{
try
{
FileInfo info = files[i];
using (StreamReader reader = new StreamReader(info.FullName))
{
TeamsEntity team = new TeamsEntity();
string id = reader.ReadLine();
team.TeamID = Convert.ToInt32(id);
team.TeamName = reader.ReadLine();
team.OrgName = reader.ReadLine();
team.BrandName = reader.ReadLine();
string wins = reader.ReadLine();
team.Wins = Convert.ToInt32(wins);
string losses = reader.ReadLine();
team.Losses = Convert.ToInt32(losses);
string draws = reader.ReadLine();
team.Draws = Convert.ToInt32(draws);
team.MemberName1 = reader.ReadLine();
team.MemberName2 = reader.ReadLine();
team.MemberName3 = reader.ReadLine();
team.MemberName4 = reader.ReadLine();
reader.Close();
teamList.Add(team);
//stream.Close();
}
}
catch (Exception e)
{
dir = string.Concat(Directory.GetCurrentDirectory(), "\\Logs");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(string.Concat(Directory.GetCurrentDirectory(), "\\Logs"));
}
string log = "Log - " + DateTime.Today.Ticks.ToString();
FileStream stream = new FileStream(Directory.GetCurrentDirectory() + "\\Logs\\" + log + ".dat", FileMode.Create, FileAccess.Write);
StreamWriter writer = new StreamWriter(stream);
string err = e.ToString();
writer.WriteLine(err + "\n");
writer.Close();
stream.Close();
}
}
}
}
return(teamList);
}
