/// <summary>
/// Opens a new Division Dates form so selected division "frame" can have dates added
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void addDivisionButton_Click(object sender, EventArgs e)
{
dm = (DivisionModel)(divisionsComboBox.SelectedItem);
selectedDivisions.Add(dm);
sdtp.DivisionID = dm.DivisionID;
sdm.DivisionID = dm.DivisionID;
sdm.SeasonID = season.SeasonID;
GlobalConfig.Connection.createSeasonDivisions(sdm);
sdtp.SeasonDivisionsID = sdm.SeasonDivisionsID;
DivisionDatesForm ddf = new DivisionDatesForm(this, sdm, dm);
ddf.Show();
this.Hide();
ddf.FormClosing += closeForm;
}
public ActionResult Create(DivisionModel m)
{
var d = new Division {
Name = "New Division"
};
d.ProgId = m.TagProgramId;
d.ProgDivs.Add(new ProgDiv {
ProgId = m.TagProgramId.Value
});
CurrentDatabase.Divisions.InsertOnSubmit(d);
CurrentDatabase.SubmitChanges();
CurrentDatabase.Refresh(RefreshMode.OverwriteCurrentValues, d);
var di = m.DivisionItem(d.Id).Single();
return(View("Row", di));
}
public ActionResult Edit(DivisionModel model, FormCollection frm, bool continueEditing)
{
if (!_permissionService.Authorize("ManageDivision"))
{
return(AccessDeniedView());
}
var user = _userContext.CurrentUser;
// Check for duplicate division, if any
var checkDivision = _smsService.CheckDivisionExists(model.Name, model.Id);
if (checkDivision)
{
ModelState.AddModelError("Name", "A Division with the same name already exists. Please choose a different name.");
}
if (ModelState.IsValid)
{
var objDivision = _smsService.GetDivisionById(model.Id);
if (objDivision != null)
{
model.CreatedOn = objDivision.CreatedOn;
objDivision = model.ToEntity(objDivision);
objDivision.ModifiedOn = DateTime.Now;
_smsService.UpdateDivision(objDivision);
}
}
else
{
model.AvailableAcadmicYears = _smsService.GetAllAcadmicYears().Select(x => new SelectListItem()
{
Text = x.Name.Trim(),
Value = x.Id.ToString(),
Selected = x.IsActive
}).ToList();
return(View(model));
}
SuccessNotification("Division updated successfully.");
if (continueEditing)
{
return(RedirectToAction("Edit", new { id = model.Id }));
}
return(RedirectToAction("List"));
}
public ActionResult Create()
{
if (!_permissionService.Authorize("ManageDivision"))
{
return(AccessDeniedView());
}
var model = new DivisionModel();
model.AvailableAcadmicYears = _smsService.GetAllAcadmicYears().Select(x => new SelectListItem()
{
Text = x.Name.Trim(),
Value = x.Id.ToString(),
Selected = x.IsActive
}).ToList();
return(View(model));
}
public IHttpActionResult PutDivisionModel(Guid id, [FromBody] YachtModel[] yachtModelList)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
DivisionModel division = db.Divisions.Include("Yachts")
.Single(d => d.Id == id);
var guidList = new List <Guid>();
foreach (var yacht in yachtModelList)
{
guidList.Add(yacht.Id);
}
var yachts = db.Yachts
.Where(y => guidList.Contains(y.Id))
.ToList();
division.Yachts.RemoveAll(y => !guidList.Contains(y.Id));
foreach (var yacht in yachts)
{
division.Yachts.Add(yacht);
}
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DivisionModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <bool> CreateDivision(string ManagerEmail, string Division)
{
// Set division id
var newDivision = new DivisionModel();
newDivision.id = new Guid();
// get the user that is going to be the manager
var manager = await _userManager.FindByEmailAsync(ManagerEmail);
// get a list of all divisions
var divisions = await _context.Divisions.ToArrayAsync();
// compare new manager id to current managers, and division name to current divisions
// if new manager is already a manager or division alread exists return false
foreach (var division in divisions)
{
if (manager.Id.Equals(division.managerId.ToString()) || division.Division.Equals(Division))
{
return(false);
}
}
// Set manager
newDivision.managerId = new Guid(manager.Id);
// Set division
newDivision.Division = Division;
// Set employee division to division they are a manager of
manager.division = Division;
manager.exempt = true;
// update employee
_context.Employees.Update(manager);
// save changes
var save = await _context.SaveChangesAsync();
// Add division to db
_context.Divisions.Add(newDivision);
// Save db
var saveResult = await _context.SaveChangesAsync();
// save of employee and division must be true
return(saveResult == 1 && save == 1);
}
private Dictionary <DivisionModel, List <GameModel> > GenerateGames
(SeasonDivisionsModel sdm, DivisionModel d, TeamModel[] teams)
{
divGames = new Dictionary <DivisionModel, List <GameModel> >();
// Create a List to hold games in the division
List <GameModel> roundGames = new List <GameModel>();
// New Game Model for each game
GameModel game = new GameModel();
int numberOfTeams = teams.Length;
//
int numberofGamesPerRound = numberOfTeams / 2;
// round robin number of rounds is one less than the number of teams
int numberOfRounds = numberOfTeams - 1;
RoundModel rm = new RoundModel();
Console.WriteLine($"{d.DivisionName}");
for (int i = 0; i < numberOfRounds; i++)
{
Console.WriteLine($"Round Number {i + 1}");
// g + 1 else get a blank team team rounds start at 1
rm = GlobalConfig.Connection.getRoundModel(sdm, i + 1);
for (int g = 0; g < numberofGamesPerRound; g++)
{
game.RoundID = rm.RoundID;
game.GameDate = rm.RoundDate;
//Console.WriteLine($"Round {a + 1}");
Console.WriteLine($"{teams[g].TeamName} PLAYS {teams[numberOfTeams - 1 - g].TeamName} ");
game.HomeTeamModel = teams[g];
game.HomeTeamPlayers = teams[g].TeamMembers;
game.AwayTeamModel = teams[numberOfTeams - 1 - g];
game.AwayTeamPlayers = teams[numberOfTeams - 1 - g].TeamMembers;
roundGames.Add(game);
GlobalConfig.Connection.CreateGame(game);
}
RotateTeams(teams);
}
divGames.Add(d, roundGames);
return(divGames);
}
public IHttpActionResult PostDivisionModel(Guid id, Guid[] yachtIdList)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
DivisionModel division = db.Divisions.Include("Yachts")
.Single(d => d.Id == id);
var guidList = new List <Guid>();
foreach (var yacht in division.Yachts)
{
guidList.Add(yacht.Id);
}
foreach (var yachtModelId in yachtIdList)
{
if (!guidList.Contains(yachtModelId))
{
var yacht = db.Yachts
.Where(y => y.Id == yachtModelId)
.FirstOrDefault();
division.Yachts.Add(yacht);
}
}
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!DivisionModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.Created));
}
public static Task <int> UpsertDivision(DivisionModel division)
{
try
{
if (IsConnected && IsDeviceIdValid)
{
var result = AutoMapperConfiguration.Mapper.Map <DivisionDTO>(division);
_ = result;
return(_proxy.UpsertDivisionAsync(result));
}
return(Task.FromResult(0));
}
catch (FaultException ex)
{
_ = ex;
return(Task.FromResult(0));
}
}
/*
* CREATORS
*/
/// <summary>
/// Saves a new Division Model to the Database
/// </summary>
/// <param name="model"></param>
/// <returns>The Division information, including the unique identifier</returns>
public DivisionModel CreateDivision(DivisionModel model)
{
using (IDbConnection connection = new MySqlConnection(GlobalConfig.CnnString(db)))
{
var p = new DynamicParameters();
p.Add("@DivisionID", 0, dbType: DbType.Int32, direction: ParameterDirection.Output);
p.Add("@DivisionName", model.DivisionName);
p.Add("@DivisionNumber", model.DivisionNumber);
connection.Execute("spDivision", p, commandType: CommandType.StoredProcedure);
// grabs newly created ID from database and returns it as part of the current Person Model
// https://stackoverflow.com/questions/13151861/fetch-last-inserted-id-form-stored-procedure-in-mysql
var id = p.Get <int?>("DivisionID");
model.DivisionID = Convert.ToInt32(id);
return(model);
}
}
/// <summary>
/// Adds selected team to selected Division in current season
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void addTeamButton_Click(object sender, EventArgs e)
{
dm = (DivisionModel)(teamsDivisionComboBox.SelectedItem);
if (dm != null)
{
TeamModel tm = (TeamModel)teamsComboBox.SelectedItem;
if (tm != null)
{
selectedTeams.Add(tm);
dtm = new DivisionTeamsModel();
dtm.SeasonDivisionsID = sdm.SeasonDivisionsID;
dtm.DivisionID = dm.DivisionID;
dtm.TeamID = tm.TeamID;
GlobalConfig.Connection.CreateDivisionTeams(dtm);
sdtp.DivisionTeamsID = dtm.DivisionTeamsID;
wireupTeamsListBox();
wireUpTeamsComboBox();
wireUpPlayersTeamComboBox();
}
}
}
public async Task <IActionResult> AddDepartment(DivisionModel model)
{
if (ModelState.IsValid)
{
var divObj = _mapper.Map <Division>(model);
divObj.ClientId = (int)_workContext.CurrentCustomer.ClientId;
var result = await _systemManagement.InsertDivision(divObj);
if (result)
{
SuccessNotification("The department data has been save successfully.");
return(RedirectToAction("AddDepartment"));
}
else
{
ModelState.AddModelError("", "Something went wrong while saving record");
}
}
return(View(model));
}
public JsonResult Insert(DivisionModel divisionModel)
{
var myContent = JsonConvert.SerializeObject(divisionModel);
var buffer = System.Text.Encoding.UTF8.GetBytes(myContent);
var byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
if (divisionModel.Id == 0) //input
{
var result = client.PostAsync("divisi", byteContent).Result;
return(new JsonResult {
Data = result, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
else //update
{
var result = client.PutAsync("divisi/" + divisionModel.Id, byteContent).Result;
return(new JsonResult {
Data = result, JsonRequestBehavior = JsonRequestBehavior.AllowGet
});
}
}
// Method for adjusting size of divisions on the EditLeague View.
private static void AdjustDivisionSize(TournamentModel t, int divisionsToAdd, int divisionsToRemove, int numberOfDivisions)
{
List <DivisionModel> newDivisions = new List <DivisionModel>();
if (divisionsToAdd > 0)
{
for (int i = numberOfDivisions + 1; i <= numberOfDivisions + divisionsToAdd; i++)
{
DivisionModel d = new DivisionModel {
DivisionName = "Division " + i
};
for (int j = 0; j < 2; j++)
{
GroupModel y = new GroupModel();
if (j == 0)
{
y.GroupName = "Group A";
}
else if (j == 1)
{
y.GroupName = "Group B";
}
d.Groups.Add(y);
}
newDivisions.Add(d);
}
GlobalConfiguration.Connection.SaveNewDivision(t.Id, newDivisions);
}
else if (divisionsToRemove > 0)
{
for (int i = numberOfDivisions - 1; i >= numberOfDivisions - divisionsToRemove; i--)
{
newDivisions.Add(t.DivisionsEntered[i]);
t.DivisionsEntered.RemoveAt(i);
}
GlobalConfiguration.Connection.RemoveDivisions(t.Id, newDivisions);
}
}
public SeasonDivisionsModel GetSeasonDivisionModel(DivisionModel model)
{
List <SeasonDivisionsModel> output;
using (IDbConnection connection = new MySqlConnection(GlobalConfig.CnnString(db)))
{
var p = new DynamicParameters();
p.Add("@InDivisionID", model.DivisionID);
p.Add("@InSeasonID", model.SeasonID);
output = connection.Query <SeasonDivisionsModel>("spGetSeasonDivisionsModel", p, commandType: CommandType.StoredProcedure).ToList();
}
SeasonDivisionsModel sm = new SeasonDivisionsModel();
foreach (SeasonDivisionsModel x in output)
{
sm.SeasonDivisionsID = x.SeasonDivisionsID;
sm.SeasonID = model.SeasonID;
sm.DivisionID = model.DivisionID;
sm.StartDate = x.StartDate;
}
return(sm);
}
public void testBuildGameDataMaxDivison()
{
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 300000;
gs.totalPicks = 20;
int numPrizeLevels = 12;
PrizeLevel[] prizes = new PrizeLevel[numPrizeLevels];
PrizeLevels pls = new PrizeLevels();
for (int i = 0; i < numPrizeLevels; i++)
{
prizes[i] = new PrizeLevel();
prizes[i].isInstantWin = false;
prizes[i].numCollections = i + 1;
prizes[i].prizeValue = 100 * i;
pls.addPrizeLevel(prizes[i]);
}
int numberOfDivions = 30;
DivisionModel[] divisions = new DivisionModel[numberOfDivions];
DivisionsModel dms = new DivisionsModel();
Random rand = new Random();
for (int i = 0; i < numberOfDivions; i++)
{
divisions[i] = new DivisionModel();
divisions[i].addPrizeLevel(prizes[rand.Next(0, 12)]);
dms.addDivision(divisions[i]);
}
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "T:\\Work\\JunkOut\\MaxTest.txt");
}
public ActionResult Div([FromBody] DivisionModel division)
{
try
{
// Verifies if the model is valid, if not, returns a bad request response.
// the verification is based on the attributes defined in the DTO.
if (!ModelState.IsValid)
{
MicroserviceException badRequestResponse = new MicroserviceException()
{
ErrorCode = "InternalError",
ErrorMessage = "Unable to process request:" + ModelState.Values,
ErrorStatus = 400
};
return(BadRequest(badRequestResponse));
}
else
{
// Finds the value of the header with the tracking id
StringValues trackingId;
Request.Headers.TryGetValue("X-Evi-Tracking-Id", out trackingId);
var response = _calculatorService.Division(division, trackingId);
return(Ok(response));
}
}
// Catches and manages all of the server's errors and responds the client with a controlled object.
catch (Exception err)
{
MicroserviceException internalServerErrorResponse = new MicroserviceException()
{
ErrorCode = "InternalError",
ErrorMessage = "An unexpected error condition was triggered which made impossible to fulfill the request. Please try again or contact support" + err.InnerException,
ErrorStatus = 500
};
Log.Error($"Calculator::Exception:: {internalServerErrorResponse}");
return(StatusCode(500, internalServerErrorResponse));
}
}
public ActionResult Edit(DivisionModel viewModel)
{
var strMessage = string.Empty;
try
{
if (ModelState.IsValid)
{
var model = _DivisionService.BMSUnit.DivisionRepository.GetByID(viewModel.Id);
#region Current User
viewModel.IUser = model.IUser;
viewModel.IDate = model.IDate;
var userName = HttpContext.User.Identity.Name;
viewModel.EUser = userName;
viewModel.EDate = DateTime.Now;
#endregion
var entity = viewModel.ToEntity();
_DivisionService.BMSUnit.DivisionRepository.Update(entity);
_DivisionService.BMSUnit.DivisionRepository.SaveChanges();
return(Content(Boolean.TrueString));
}
strMessage = Common.GetModelStateErrorMessage(ModelState);
}
catch (Exception ex)
{
strMessage = CommonExceptionMessage.GetExceptionMessage(ex, CommonAction.Update);
}
return(Content(strMessage));
}
/// <summary>
/// Returns generated gameplay
/// </summary>
/// <param name="prizeLevels">The prize levels of the current project configuration</param>
/// <param name="currentDivision">The division currently being generated</param>
/// <param name="gameSetup">The game configurations</param>
/// <returns>String representation of gameplay</returns>
public string GenerateGameplay(List <PrizeLevelModel> prizeLevels, DivisionModel currentDivision, GameSetupModel gameSetup, List <int> complexities, int prizeLevelIndex, WordManager manager, bool isRandomized)
{
StringBuilder gameplay = new StringBuilder();
List <Word> wordList = manager.GetWordSet();
LogWriter.GetInstance().WriteLog("Creating words list");
foreach (Word currentWord in wordList)
{
gameplay.Append(currentWord.ToString());
gameplay.Append(":").Append((char)('A' + complexities.IndexOf(currentWord.GetComplexity())));
if (wordList.IndexOf(currentWord) < wordList.Count - 1)
{
gameplay.Append(",");
}
}
gameplay.Append("|");
LogWriter.GetInstance().WriteLog("Finished creating words list");
// letter logic goes here
List <char> callLetters = new List <char>();
char terminator = ' ';
LogWriter.GetInstance().WriteLog("Determining min/max call letters");
int minimumNumLetters = -1;
int maximumNumLetters = -1;
if (isRandomized)
{
int minValue = Int32.MaxValue;
int maxCallLetterValue = 0;
foreach (int complexity in complexities)
{
maxCallLetterValue += complexity;
if (complexity < minValue)
{
minValue = complexity;
}
}
minimumNumLetters = minValue;
maximumNumLetters = maxCallLetterValue < 10 ? maxCallLetterValue : 10;
}
else
{
minimumNumLetters = gameSetup.CallLettersModel.MinCallLetters;
maximumNumLetters = gameSetup.CallLettersModel.MaxCallLetters;
}
LogWriter.GetInstance().WriteLog("Selected min/max call letters");
int seed = (int)((DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) % Int32.MaxValue);
Random rand = new Random(seed);
int numCallLetters = rand.Next(minimumNumLetters, maximumNumLetters + 1);
if (currentDivision.Multiplier == 0)
{
LogWriter.GetInstance().WriteLog("Generating loss set");
callLetters = manager.GetLossSet(numCallLetters, gameSetup.CallLettersModel.NumCallLettersPerRowInHistory);
terminator = '*';
LogWriter.GetInstance().WriteLog("Finished creating loss set");
}
else
{
LogWriter.GetInstance().WriteLog("Generating win set");
callLetters = manager.GetWinSet(complexities[prizeLevelIndex], numCallLetters, gameSetup.CallLettersModel.NumCallLettersPerRowInHistory);
terminator = currentDivision.Multiplier.ToString().ToCharArray()[0];
LogWriter.GetInstance().WriteLog("Finished creating win set");
}
foreach (char currentLetter in callLetters)
{
gameplay.Append(currentLetter).Append(',');
}
gameplay.Append(terminator).Append("\n");
return(gameplay.ToString());
}
public SeasonDivisionsModel GetSeasonDivisionModel(DivisionModel dm)
{
throw new NotImplementedException();
}
public void EditDivision(DivisionModel model)
{
throw new NotImplementedException();
}
public DivisionModel CreateDivision(DivisionModel model)
{
throw new NotImplementedException();
}
private void SetCurrentDivision(DivisionModel division) => LocalClient.Division = division;
private void SaveProject(PlantOrderModel plantOrder, DivisionModel division)
{
}
public ActionResult Create()
{
DivisionModel divisionModel = new DivisionModel();
return(View(divisionModel));
}
public static DivisionModel Divide(DivisionModel division)
{
division.Result = division.Numerator / division.Denominator;
return(division);
}
public ActionResult Create(DivisionModel divisionModel)
{
return(View(divisionModel));
}
public ActionResult Results(DivisionModel m)
{
return(View(m));
}
public ActionResult Index()
{
var m = new DivisionModel();
return(View(m));
}
/// <summary>
/// Creates new file and writes generated gameplay into it
/// </summary>
/// <param name="targetFilePath">Path to the file being written to</param>
/// <param name="validPath">Valid words list file path</param>
/// <param name="bannedPath">Banned words list file path</param>
/// <param name="allModel">Project configuration</param>
public void CreateGeneratedFile(string targetFilePath, string validPath, string bannedPath, AllModelsModel allModel)
{
List <PrizeLevelModel> prizeLevels = new List <PrizeLevelModel>(allModel.PrizeLevelsModel.PrizeLevelList);
List <DivisionModel> divisions = new List <DivisionModel>(allModel.DivisionsModel.DivisionList);
GameSetupModel gameModel = allModel.GameSetupModel;
PlayGenerator generator = new PlayGenerator(validPath, bannedPath);
StringBuilder gameplay = new StringBuilder();
int numPermutations = allModel.DivisionsModel.NumPermutations;
List <int> complexities = new List <int>();
LogWriter.GetInstance().WriteLog("Generating complexities");
// sets complexities for entire generation
if (!allModel.PrizeLevelsModel.Randomize)
{
foreach (PrizeLevelModel currentPrizeLevel in prizeLevels)
{
complexities.Add(currentPrizeLevel.UniqueLetterCount);
}
LogWriter.GetInstance().WriteLog("Finished non-random complexities");
}
for (int i = 0; i < numPermutations; i++)
{
// creates new complexities list for each permutation
if (allModel.PrizeLevelsModel.Randomize)
{
LogWriter.GetInstance().WriteLog("Generating random complexities");
complexities.Clear();
WordListManager lists = new WordListManager(validPath, bannedPath, 1, 30);
List <int> potentialComplexities = new List <int>();
for (int complexityIndex = lists.GetLeastComplexCount(); complexityIndex < lists.GetMostComplexCount(); complexityIndex++)
{
if (lists.HasComplexity(complexityIndex))
{
potentialComplexities.Add(complexityIndex);
}
}
potentialComplexities.Shuffle();
foreach (PrizeLevelModel currentPrizeLevel in prizeLevels)
{
int seed = (int)((DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) % Int32.MaxValue);
Random rand = new Random(seed);
int nextComplexityIndex = rand.Next(0, potentialComplexities.Count);
int nextComplexityValue = potentialComplexities[nextComplexityIndex];
potentialComplexities.Remove(nextComplexityValue);
complexities.Add(nextComplexityValue);
}
LogWriter.GetInstance().WriteLog("Finished randomized complexities");
}
LogWriter.GetInstance().WriteLog("Creating WordManager");
WordManager manager = new WordManager(prizeLevels.Count, complexities, validPath, bannedPath);
LogWriter.GetInstance().WriteLog("Finished creating WordManager");
foreach (DivisionModel currentDivision in divisions)
{
LogWriter.GetInstance().WriteLog("Generating gameplay");
string winPermutation = generator.GenerateGameplay(prizeLevels, currentDivision, gameModel, complexities, prizeLevels.IndexOf(currentDivision.PrizeLevel), manager, allModel.PrizeLevelsModel.Randomize);
gameplay.Append(winPermutation);
LogWriter.GetInstance().WriteLog("Finished generating gameplay");
}
// lose division
DivisionModel loss = new DivisionModel(allModel.DivisionsModel);
loss.Multiplier = 0;
gameplay.Append(generator.GenerateGameplay(prizeLevels, loss, gameModel, complexities, -1, manager, allModel.PrizeLevelsModel.Randomize));
}
File.WriteAllText(targetFilePath, gameplay.ToString());
}
