public void AssemblerCorrectlyWritesAthleteDto()
{
var athlete = new Athlete();
athlete.Id = 123456;
athlete.Nickname = "TestNickname";
athlete.FirstName = "TestFirstName";
athlete.LastName = "TestLastName";
athlete.Gender = 'M';
athlete.TrainerSizeM = 9.5;
athlete.SpikeSizeM = 8.5;
athlete.Notes = "Some test notes";
athlete.Status = "Current";
var eventArea = new EventArea();
eventArea.EventName = Constants.EventAreas.POLE_VAULT;
var model = new Model();
model.ModelNumber = "1234";
model.ModelName = "model name";
model.Type = "model type";
model.Price = 105.00;
model.Color = "white";
model.IsDiscontinued = false;
var inventoryItem = new InventoryItem();
inventoryItem.SerialNumber = 1;
inventoryItem.Model = model;
inventoryItem.SizeM = 9;
inventoryItem.SizeW = 11;
inventoryItem.Width = "N";
inventoryItem.RequestName = "request1";
inventoryItem.Status = "Requested";
inventoryItem.StatusLastChanged = new DateTime(2012, 10, 31, 12, 0, 0);
inventoryItem.Athlete = athlete;
athlete.EventAreas.Add(eventArea);
athlete.Inventory.Add(inventoryItem);
_mockInventoryItemAssembler.Setup(x => x.WriteDto(inventoryItem)).Returns(new InventoryItemDto());
var athleteDto = _assembler.WriteDto(athlete);
Assert.IsNotNull(athleteDto);
Assert.AreEqual(athlete.Id, athleteDto.Id);
Assert.AreEqual(athlete.Nickname, athleteDto.Nickname);
Assert.AreEqual(athlete.FirstName, athleteDto.FirstName);
Assert.AreEqual(athlete.LastName, athleteDto.LastName);
Assert.AreEqual(athlete.Gender, athleteDto.Gender);
Assert.AreEqual(athlete.TrainerSizeM, athleteDto.TrainerSizeM);
Assert.AreEqual(athlete.TrainerSizeW, athleteDto.TrainerSizeW);
Assert.AreEqual(athlete.SpikeSizeM, athleteDto.SpikeSizeM);
Assert.AreEqual(athlete.SpikeSizeW, athleteDto.SpikeSizeW);
Assert.AreEqual(athlete.Notes, athleteDto.Notes);
Assert.AreEqual(athlete.Status, athleteDto.Status);
Assert.AreEqual(7, athleteDto.EventParticipation.Count);
Assert.AreEqual(1, athleteDto.EventParticipation.Where(x => x.IsParticipant == true).Count());
Assert.AreEqual(1, athleteDto.Inventory.Count);
_mockInventoryItemAssembler.VerifyAll();
}
public AthleteDto WriteDto(Athlete athlete)
{
if (athlete == null)
throw new NullReferenceException();
var athleteDto = new AthleteDto();
var inventoryItemAssembler = ObjectFactory.GetInstance<IInventoryItemAssembler>();
var modelAssembler = ObjectFactory.GetInstance<IModelAssembler>();
athleteDto.Id = athlete.Id;
athleteDto.Nickname = athlete.Nickname;
athleteDto.FirstName = athlete.FirstName;
athleteDto.LastName = athlete.LastName;
athleteDto.Gender = athlete.Gender;
athleteDto.TrainerSizeM = athlete.TrainerSizeM;
athleteDto.TrainerSizeW = athlete.TrainerSizeW;
athleteDto.SpikeSizeM = athlete.SpikeSizeM;
athleteDto.SpikeSizeW = athlete.SpikeSizeW;
athleteDto.Notes = athlete.Notes;
athleteDto.Status = athlete.Status;
athleteDto.EventParticipation = new List<EventAreaDto>(Constants.Constants.ALL_EVENT_AREAS);
foreach (var eventArea in athlete.EventAreas)
athleteDto.EventParticipation.FirstOrDefault(x => x.EventName == eventArea.EventName).IsParticipant = true;
foreach (var inventoryItem in athlete.Inventory)
athleteDto.Inventory.Add(inventoryItemAssembler.WriteDto(inventoryItem));
return athleteDto;
}
public Athlete CreateOrUpdate(Athlete entity)
{
if (entity.IsValid())
{
this.athleteRepository.SaveOrUpdate(entity);
}
return entity;
}
public ActionResult Edit([Bind(Include = "AthleteID,Name,Gender,TeamID")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Entry(athlete).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.TeamID = new SelectList(db.Teams, "TeamID", "Name", athlete.TeamID);
return(View(athlete));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,FirstName,LastName,Age,Gender,SubscriptionLength")] Athlete athlete)
{
if (ModelState.IsValid)
{
_db.Entry(athlete).State = EntityState.Modified;
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(athlete));
}
public async Task <IActionResult> Create([Bind("Id,Family,Given,birthDate,Gender,Identifier,Team,Position")] Athlete athlete)
{
if (ModelState.IsValid)
{
_context.Add(athlete);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(athlete));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,FirstName,LastName,PreferredEmail,AspNetUserId")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Entry(athlete).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(athlete));
}
public ActionResult Index(Search search)
{
if (!ModelState.IsValid)
{
return(View("Error"));
}
var athlete = new Athlete(search.NameAndClass);
var athleteRecordsViewModel = new AthleteRecordsViewModel(athlete);
return(View("Results", athleteRecordsViewModel));
}
public AthleteModel([NotNull] Athlete athlete)
{
EventId = athlete.EventId;
Routines = athlete.Routines;
FirstName = athlete.FirstName;
Id = athlete.Id;
LastName = athlete.LastName;
RunningOrder = athlete.RunningOrder;
Team = athlete.Team;
Total = athlete.Total;
}
private void button3_Click(object sender, EventArgs e)
{
//variable gets event
string selected = listBox1.GetItemText(listBox1.SelectedItem);
//gets total time
double total;
double[] num = new double[7];
num[0] = Convert.ToDouble(textBox2.Text);
num[1] = Convert.ToDouble(textBox3.Text);
num[2] = Convert.ToDouble(textBox4.Text);
num[3] = Convert.ToDouble(textBox5.Text);
num[4] = Convert.ToDouble(textBox6.Text);
num[5] = Convert.ToDouble(textBox7.Text);
num[6] = Convert.ToDouble(textBox8.Text);
total = num[0] + num[1] + num[2] + num[3] + num[4] + num[5] + num[6];
total = total - (num.Min() + num.Max());
total = total / 5;
//class created to store athletes info
Athlete AthleteScore = new Athlete();
//stores name of athlete
AthleteScore.firstName = dataGridView1.SelectedCells[1].Value.ToString();
AthleteScore.lastName = dataGridView1.SelectedCells[2].Value.ToString();
//instance of class used to enter score
Scoring TimeEntry = new Scoring();
//member function adds the Time to database
TimeEntry.EnterScore(total, selected, AthleteScore.firstName, AthleteScore.lastName);
//this will update the score board to reflect the changes
string View = "SELECT * FROM " + SelectedEvent + " ORDER BY Score DESC;";//gets team table from database
using (System.Data.SQLite.SQLiteConnection con = new System.Data.SQLite.SQLiteConnection("data source=OlympiaDB.sqlite"))
{
using (System.Data.SQLite.SQLiteCommand com = new System.Data.SQLite.SQLiteCommand(con))
{
con.Open(); //opens DB
if (con.State == ConnectionState.Open) // if connection.Open was successful
{
//this sends sql commands to database
DataSet ds = new DataSet();
var da = new SQLiteDataAdapter(View, con);
da.Fill(ds);
dataGridView1.DataSource = ds.Tables[0].DefaultView;
}
else
{
MessageBox.Show("Connection failed.");
}
}
con.Close();
}
}
public IActionResult Create([FromBody] Athlete athlete)
{
if (ModelState.IsValid)
{
Guid obj = Guid.NewGuid();
athlete.id = obj.ToString();
_dataAccessProvider.AddAthleteRecord(athlete);
return(Ok());
}
return(BadRequest());
}
public ActionResult Create([Bind(Include = "ID,NAME,GENDER,TeamID")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Athletes.Add(athlete);
db.SaveChanges();
}
ViewBag.TeamID = new SelectList(db.Teams, "ID", "NAME", athlete.TeamID);
return(View(athlete));
}
private async Task CheckForWeeklyReminder(List <Activity> activities, Athlete athlete)
{
var dateToCheck = activities.FirstOrDefault()?.StartDate ?? athlete.SignupDateTimeUtc;
if (dateToCheck < AWeekEarlier)
{
await UpdateReminders(athlete, 1);
await _slackService.PostSlackMessage(_messageFactory.ReminderMessage(WeekReminder, athlete));
}
}
// Add this event handler to the DataGridView
private void dgvAthletes_CellEndEdit(object sender, DataGridViewCellEventArgs e)
{
if (dgvAthletes.RowCount - e.RowIndex == 2)
{
return;
}
var row = dgvAthletes.Rows[e.RowIndex];
athlete = ExtractAthleteFromRow(row);
}
public async Task <IActionResult> Create([Bind("ID,LastName,MiddleName,FirstName,Dob,Gender,Weight,Height")] Athlete athlete)
{
if (ModelState.IsValid)
{
_context.Add(athlete);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(athlete));
}
public IActionResult putAthlete(string username, [FromBody] Athlete athlete)
{
try
{
string attribsToModify = "username = '******', password = '******', full_name = '" + athlete.full_name;
}
}
if (athlete.nationality != null)
{
if (!((athlete.nationality).Equals("")))
{
attribsToModify = attribsToModify + "', nationality = '" + athlete.nationality;
}
}
if (athlete.photo != null)
{
if (!((athlete.photo).Equals("")))
{
attribsToModify = attribsToModify + "', photo = '" + athlete.photo;
}
}
if (athlete.birth_date != DateTime.MinValue)
{
athlete.setAge();
attribsToModify = attribsToModify + "', birth_date = '" + athlete.birth_date + "', age = " + athlete.getAge();;
}
dataBaseHandler.updateDataBase(DataBaseConstants.athlete, attribsToModify, "username = '******'");
return(Ok());
}
else
{
return(BadRequest());
}
}
catch //(Exception e)
{
return(BadRequest());
}
}
public ActionResult Create([Bind(Include = "athlete_id,athlete_age, athlete_name,sport_id")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Save(athlete);
return(RedirectToAction("Index"));
}
ViewBag.sport_id = new SelectList(db.Sports, "sport_id", "sport_name", athlete.sport_id);
return(View("Create", athlete));
}
async Task emailPeopleAboutNewScores(Athlete me, List <Score> newScoresConfirmed, List <Score> newScoresNotYetConfirmed)
{
try
{
ApplicationDbContext db = new ApplicationDbContext();
string link1 = new DeepLinkHelper().BuildLinkToSync(me.AthleteID);
string link2 = new DeepLinkHelper().BuildOpenBybLink_Sync(me.AthleteID);
string myName = me.NameOrUserName;
foreach (Score score in newScoresConfirmed)
{
var athlete = db.Athletes.Single(i => i.AthleteID == score.AthleteBID);
// build the email
string strScore = score.PointsA + " : " + score.PointsB;
if (score.PointsA < score.PointsB)
{
strScore += " (you won)";
}
else if (score.PointsA > score.PointsB)
{
strScore += " (you lost)";
}
string html = string.Format(htmlMessage_NewConfirmedScore, myName, strScore, score.Date.ToShortDateString(), link1, link2);
// send the email
await new EmailService().SendEmailToAthlete(athlete, "New match recorded and auto-confirmed", html);
}
foreach (Score score in newScoresNotYetConfirmed)
{
var athlete = db.Athletes.Single(i => i.AthleteID == score.AthleteBID);
// build the email
string strScore = score.PointsA + " : " + score.PointsB;
if (score.PointsA < score.PointsB)
{
strScore += " (you won)";
}
else if (score.PointsA > score.PointsB)
{
strScore += " (you lost)";
}
string html = string.Format(htmlMessage_NewNotConfirmedScore, myName, strScore, score.Date.ToShortDateString(), link1, link2);
// send the email
await new EmailService().SendEmailToAthlete(athlete, "New match recorded & needs your confirmation", html);
}
}
catch (Exception)
{
}
}
public ActionResult Create([Bind(Include = "age,gradeLevel,firstName,lastName,emailAddress,schoolName,city,state,zipCode,postion,height,weight")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Athletes.Add(athlete);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(athlete));
}
public ActionResult Create([Bind(Include = "AthleteId,FirstName,LastName,BirthDate,HomeCity")] Athlete athlete)
{
if (ModelState.IsValid)
{
db.Athletes.Add(athlete);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(athlete));
}
private async void finish_StravaConnection(string token)
{
if (strava_Token.Length != 0)
{
auth = new StaticAuthentication(token);
client = new StravaClient(auth);
Athlete athlete = await client.Athletes.GetAthleteAsync();
statusText.Text = "Hello " + athlete.FirstName;
}
}
public async Task <IHttpActionResult> GetAthlete(int id)
{
Athlete athlete = await db.Athletes.FindAsync(id);
if (athlete == null)
{
return(NotFound());
}
return(Ok(athlete));
}
public IHttpActionResult GetAthlete(int id)
{
Athlete athlete = db.Athletes.Find(id);
if (athlete == null)
{
return(NotFound());
}
return(Ok(athlete));
}
public void InitializeRoster()
{
for (int i = 0; i < startingRosterCount; i++)
{
rosterList.Add(new Athlete(false));
rosterList [i].SetTeam(this);
}
teamManager = new Athlete(true);
teamManager.SetTeam(this);
}
public ActionResult Create(Athlete athlete)
{
if (ModelState.IsValid)
{
db.Athletes.Add(athlete);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(athlete));
}
public void Report_SuccessfullyReported()
{
Gym gym = new Gym("Gym", 5);
Athlete athlete = new Athlete("Nacepena Batka");
string report = $"Active athletes at Gym: Nacepena Batka";
gym.AddAthlete(athlete);
var result = gym.Report();
Assert.AreEqual(report, result);
}
private void okButton_Click(object sender, EventArgs e)
{
if (NothingSelected())
{
return;
}
Item = _context.Athletes.Find(GetId());
this.Close();
}
public async Task SendEmailToAthlete(Athlete athlete, string subject, string body)
{
string emailAddressOfAthlete = athlete.UserName;
if (string.IsNullOrEmpty(athlete.RealEmail) == false)
{
emailAddressOfAthlete = athlete.RealEmail;
}
await SendEmail(emailAddressOfAthlete, subject, body);
}
public AthleteVM(Athlete x) : base()
{
if (x is Athlete)
{
base.Person = x;
}
else
{
throw new ArgumentException("Athlete must be of type Athlete");
}
}
public IActionResult Get(long id)
{
Athlete athlete = athleteRepository.GetById(id);
if (athlete == null)
{
return(NotFound());
}
return(Json(athlete));
}
public void Distribute()
{
var athlete = new Athlete();
var priorLastChangedDate = _inventoryItem.StatusLastChanged;
_repository.Distribute(_inventoryItem);
Assert.AreEqual(Constants.Inventory.DISTRIBUTED, _inventoryItem.Status);
Assert.IsTrue(_inventoryItem.StatusLastChanged > priorLastChangedDate);
_session.Verify(x => x.SaveOrUpdate(_inventoryItem));
_mockSessionFactory.VerifyAll();
_transaction.Verify(x => x.Commit());
}
public void AssignInventoryItemToAthlete()
{
var newAthleteDto = new AthleteDto() { FirstName = "Jeff", LastName = "Artis-Gray", Nickname = "JArtis-Gray", Gender = 'M', TrainerSizeM = 14, TrainerSizeW = 12, SpikeSizeM = 14, SpikeSizeW = 12, Notes = "Notes about Jeff Artis-Gray", Status = "Future" };
var newAthlete = new Athlete() { FirstName = "Jeff", LastName = "Artis-Gray", Nickname = "JArtis-Gray", Gender = 'M', TrainerSizeM = 14, TrainerSizeW = 12, SpikeSizeM = 14, SpikeSizeW = 12, Notes = "Notes about Jeff Artis-Gray", Status = "Future" };
_mockAthleteAssembler.Setup(x => x.ReadDto(newAthleteDto)).Returns(newAthlete);
InventoryService.AssignInventoryItemToAthlete(_inventoryItemDto, newAthleteDto, String.Empty);
_mockAthleteAssembler.VerifyAll();
_mockInventoryItemAssembler.VerifyAll();
_mockInventoryItemRepository.VerifyAll();
_mockInventoryMovementRepository.VerifyAll();
}
private async Task<bool> Add(Athlete athlete)
{
HttpResponseMessage response = await _client.PostAsJsonAsync<Athlete>("api/athlete/", athlete)
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return true;
//return await response.Content.ReadAsAsync<bool>();
}
else
return false;
}
public Athlete ReadDto(AthleteDto athleteDto)
{
if (athleteDto == null)
throw new NullReferenceException();
var athlete = ObjectFactory.GetInstance<IAthleteRepository>().GetByNickname(athleteDto.Nickname);
if (athlete == null)
athlete = new Athlete();
var eventAreaAssembler = ObjectFactory.GetInstance<IEventAreaAssembler>();
var inventoryItemAssembler = ObjectFactory.GetInstance<IInventoryItemAssembler>();
foreach (var eventAreaDto in athleteDto.EventParticipation)
{
if (eventAreaDto.IsParticipant)
{
var eventArea = eventAreaAssembler.ReadDto(eventAreaDto);
athlete.EventAreas.Add(eventArea);
eventArea.Athletes.Add(athlete);
}
}
if (athleteDto.Inventory != null)
{
foreach (var inventoryItemDto in athleteDto.Inventory)
{
var inventoryItem = inventoryItemAssembler.ReadDto(inventoryItemDto);
athlete.Inventory.Add(inventoryItem);
inventoryItem.Athlete = athlete;
}
}
else
athlete.Inventory = new HashedSet<InventoryItem>();
athlete.Nickname = athleteDto.Nickname;
athlete.FirstName = athleteDto.FirstName;
athlete.LastName = athleteDto.LastName;
athlete.Gender = athleteDto.Gender;
athlete.TrainerSizeM = athleteDto.TrainerSizeM;
athlete.TrainerSizeW = athleteDto.TrainerSizeW;
athlete.SpikeSizeM = athleteDto.SpikeSizeM;
athlete.SpikeSizeW = athleteDto.SpikeSizeW;
athlete.Notes = athleteDto.Notes;
athlete.Status = athleteDto.Status;
return athlete;
}
public ActionResult Add(Athlete athlete)
{
ViewBag.teamsList = ItemListCreator.Teams(_teamRepo);
ViewBag.sportsList = ItemListCreator.Sports();
if (ModelState.IsValid)
{
if (_athRepo.Add(athlete))
{
ViewBag.Success = "Added succesfully";
return View();
}
}
ViewBag.Error = "Error adding an athlete!";
return View();
}
public void Save(Athlete athlete)
{
using (var session = ObjectFactory.GetInstance<IMySessionFactory>().OpenSession())
using (var transaction = session.BeginTransaction())
{
try
{
session.SaveOrUpdate(athlete);
session.Flush();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
/// <summary>
/// This app uses Azure as the backend which utilizes Notifications hubs
/// </summary>
/// <returns>The athlete notification hub registration.</returns>
public Task UpdateAthleteNotificationHubRegistration(Athlete athlete, bool forceSave = false, bool sendTestPush = false)
{
return new Task(() =>
{
if(athlete == null)
throw new ArgumentNullException("athlete");
if(athlete.Id == null || athlete.DeviceToken == null)
return;
var tags = new List<string> {
App.CurrentAthlete.Id,
"All",
};
App.CurrentAthlete.LocalRefresh();
App.CurrentAthlete.Memberships.Select(m => m.LeagueId).ToList().ForEach(tags.Add);
athlete.DevicePlatform = Xamarin.Forms.Device.OS.ToString();
var reg = new DeviceRegistration {
Handle = athlete.DeviceToken,
Platform = athlete.DevicePlatform,
Tags = tags.ToArray()
};
var registrationId = Client.InvokeApiAsync<DeviceRegistration, string>("registerWithHub", reg, HttpMethod.Put, null).Result;
athlete.NotificationRegistrationId = registrationId;
//Used to verify the device is successfully registered with the backend
if(sendTestPush)
{
var qs = new Dictionary<string, string>();
qs.Add("athleteId", athlete.Id);
Client.InvokeApiAsync("sendTestPushNotification", null, HttpMethod.Get, qs).Wait();
}
if(athlete.IsDirty || forceSave)
{
var task = SaveAthlete(athlete);
task.Start();
task.Wait();
}
});
}
public void AssemblerCorrectlyWritesInventoryItemDto()
{
var eventArea = new EventArea() { EventName = Constants.EventAreas.POLE_VAULT };
var poleVaulter = new Athlete() { Nickname = "poleVaulter", FirstName = "Pole", LastName = "Vaulter1", Gender = 'M', Status = "Current" };
var modelDto = new ModelDto();
var inventoryItem = new InventoryItem()
{
SerialNumber = 1,
Model = new Model(),
SizeM = 9,
SizeW = 11,
Width = "N",
RequestName = "request1",
Status = "Requested",
StatusLastChanged = new DateTime(2012, 10, 31, 12, 0, 0),
EventAreaAssignment = eventArea,
Athlete = poleVaulter
};
var movement = new InventoryMovement() { EventType = new InventoryEventType() { EventType = Constants.InventoryEventTypes.ORDER } };
inventoryItem.MovementHistory.Add(movement);
_mockModelAssembler.Setup(x => x.WriteDto(inventoryItem.Model)).Returns(modelDto);
_mockInventoryMovementAssembler.Setup(x => x.WriteDto(movement));
_mockEventAreaAssembler.Setup(x => x.WriteDto(eventArea)).Returns(new EventAreaDto() { EventName = eventArea.EventName });
var inventoryItemDto = _assembler.WriteDto(inventoryItem);
Assert.AreEqual(inventoryItem.SerialNumber, inventoryItemDto.SerialNumber);
Assert.AreEqual(modelDto, inventoryItemDto.ModelDto);
Assert.AreEqual(inventoryItem.SizeM, inventoryItemDto.SizeM);
Assert.AreEqual(inventoryItem.SizeW, inventoryItemDto.SizeW);
Assert.AreEqual(inventoryItem.Width, inventoryItemDto.Width);
Assert.AreEqual(inventoryItem.RequestName, inventoryItemDto.RequestName);
Assert.AreEqual(inventoryItem.Status, inventoryItemDto.Status);
Assert.AreEqual(inventoryItem.StatusLastChanged, inventoryItemDto.StatusLastChanged);
Assert.AreEqual(inventoryItem.EventAreaAssignment.EventName, inventoryItemDto.EventAreaAssignmentDto.EventName);
Assert.AreEqual(1, inventoryItemDto.MovementHistory.Count);
_mockModelAssembler.VerifyAll();
_mockInventoryMovementAssembler.VerifyAll();
_mockEventAreaAssembler.VerifyAll();
}
public void CreateChallenge(Athlete challenger, Athlete challengee, League league)
{
var time = TimeSpan.FromTicks(DateTime.Now.AddMinutes(60).Subtract(DateTime.Today).Ticks);
if(time.Ticks > TimeSpan.TicksPerDay)
time = time.Subtract(TimeSpan.FromTicks(TimeSpan.TicksPerDay));
SelectedTime = time;
SelectedDate = DateTime.Today;
var membership = league.Memberships.SingleOrDefault(m => m.AthleteId == challengee.Id);
Challenge = new Challenge {
BattleForRank = membership.CurrentRank,
ChallengerAthleteId = challenger.Id,
ChallengeeAthleteId = challengee.Id,
ProposedTime = SelectedDateTime,
LeagueId = league.Id,
};
}
public IHttpActionResult Add(Athlete athlete)
{
try
{
_db.Athlete.Add(athlete);
_db.SaveChanges();
return
new ItemCreatedHttpResult<Athlete>(athlete, Request, athlete.AthleteId, "GetAthleteById");
}
catch (Exception ex)
{
HttpResponseMessage responseMsg = new HttpResponseMessage(HttpStatusCode.Conflict);
responseMsg.Content = new StringContent(/*ex.Message.ToString()*/"Either duplicate key or duplicate name",
Encoding.UTF8, "text/plain");
IHttpActionResult response = ResponseMessage(responseMsg);
return response;
}
}
public void LoadData_ReturnsPopulatedOfEventAreaParticipants()
{
var userDto = new UserDto();
var eventAreaDto = new EventAreaDto() { EventName = Constants.EventAreas.POLE_VAULT };
var athlete = new Athlete();
var eventArea = new EventArea();
userDto.EventAreaResponsibilities.Add(eventAreaDto);
eventArea.Athletes.Add(athlete);
_mockEventAreaAssembler.Setup(x => x.ReadDto(eventAreaDto)).Returns(eventArea);
_mockAthleteAssembler.Setup(x => x.WriteDto(athlete)).Returns(new AthleteDto());
var athletesList = InitialDataProvider.LoadData(userDto);
_mockEventAreaAssembler.VerifyAll();
_mockAthleteAssembler.VerifyAll();
Assert.IsNotNull(athletesList);
Assert.AreEqual(1, athletesList.Count());
}
public Task UnregisterAthleteForPush(Athlete athlete)
{
return new Task(() =>
{
if(athlete == null || athlete.NotificationRegistrationId == null)
return;
var values = new Dictionary<string, string> { {
"id",
athlete.NotificationRegistrationId
}
};
var registrationId = Client.InvokeApiAsync<string>("unregister", HttpMethod.Delete, values).Result;
});
}
public Task<List<League>> GetAvailableLeagues(Athlete athlete)
{
return new Task<List<League>>(() =>
{
var memberOf = athlete.Memberships.Select(m => m.LeagueId).ToList();
var existingToJoin = DataManager.Instance.Leagues.Keys.Except(memberOf);
List<League> list;
if(memberOf.Count > 0)
{
list = Client.GetTable<League>().Where(l => !memberOf.Contains(l.Id) && l.IsEnabled && l.IsAcceptingMembers).OrderBy(l => l.Name).ToListAsync().Result;
}
else
{
list = Client.GetTable<League>().Where(l => l.IsEnabled && l.IsAcceptingMembers).OrderBy(l => l.Name).ToListAsync().Result;
}
var toRemoveFromCache = existingToJoin.Except(list.Select(l => l.Id)).ToList();
League removed;
toRemoveFromCache.ForEach(l => DataManager.Instance.Leagues.TryRemove(l, out removed));
EnsureAthletesLoadedForLeagues(list);
list.ForEach(CacheLeague);
return list;
});
}
bool IAthleteRepository.Add(Athlete athlete)
{
Task<bool> addedSuccessfully = Add(athlete);
return addedSuccessfully.Result;
}
private async Task<bool> Update(Athlete athlete)
{
HttpResponseMessage response = await _client.PutAsJsonAsync("api/athlete/", athlete)
.ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return true;
}
else
return false;
}
bool IAthleteRepository.Update(Athlete athlete)
{
Task<bool> isModified = Update(athlete);
return isModified.Result;
}
public AthleteEditViewModel(Athlete athlete = null)
{
Athlete = athlete ?? new Athlete();
}
private static Boolean IsNew(Athlete athlete)
{
return athlete.Id == 0;
}
/// <summary>
/// Registers an athlete with the backend and returns the new athlete profile
/// </summary>
async Task<Athlete> RegisterAthlete(IUserProfile profile)
{
AuthenticationStatus = "Registering athlete";
var athlete = new Athlete(profile);
await AzureService.Instance.AthleteManager.UpsertAsync(athlete);
"You're now an officially registered athlete!".ToToast();
return athlete;
}
public void SetupContext()
{
ObjectFactory.GetInstance<IMySessionFactory>().ExportSchema();
CreateInitialData();
_athlete = new Athlete()
{
Nickname = "AthleteNickname",
FirstName = "Fname",
LastName = "Lname",
Gender = 'M',
TrainerSizeM = 9.5,
SpikeSizeM = 9.5,
Notes = "Some notes",
Status = "Active"
};
_repository = new AthleteRepository();
}
public void Setup()
{
_model = new Model() { ModelNumber = "524395-386", ModelName = "Air Pegasus+ 29 Trail", Type = "Running", Price = 105, Color = "Silver Sage/Team Red/University Red/Total Orange", IsDiscontinued = false };
_inventoryItem = new InventoryItem() { Model = _model, Athlete = _athlete, SizeM = 9, SizeW = 7, Width = "N", RequestName = "request1", Status = Constants.Inventory.REQUESTED, StatusLastChanged = new DateTime(2012, 8, 18, 11, 26, 13) };
_athlete = new Athlete() { FirstName = "Jeff", LastName = "Artis-Gray", Nickname = "JArtis-Gray", Gender = 'M', TrainerSizeM = 14, TrainerSizeW = 12, SpikeSizeM = 14, SpikeSizeW = 12, Notes = "Notes about Jeff Artis-Gray", Status = "Future" };
_athlete.Inventory.Add(_inventoryItem);
_inventoryItem.Athlete = _athlete;
Bootstrapper.BootstrapStructureMap();
ObjectFactory.GetInstance<IMySessionFactory>().ExportSchema();
_inventoryItemRepository = ObjectFactory.GetInstance<IInventoryItemRepository>();
_athleteRepository = ObjectFactory.GetInstance<IAthleteRepository>();
_inventoryItemAssembler = ObjectFactory.GetInstance<IInventoryItemAssembler>();
_athleteAssembler = ObjectFactory.GetInstance<IAthleteAssembler>();
_inventoryItemDto = _inventoryItemAssembler.WriteDto(_inventoryItem);
_athleteDto = _athleteAssembler.WriteDto(_athlete);
ObjectFactory.GetInstance<IModelRepository>().Save(_model);
_athleteRepository.Save(_athlete);
_inventoryItemRepository.Save(_inventoryItem);
_inventoryItemDto.SerialNumber = _inventoryItem.SerialNumber;
_athleteDto.Id = _athlete.Id;
}
public void Setup()
{
_mockInventoryItemAssembler = new Mock<IInventoryItemAssembler>();
_mockAthleteAssembler = new Mock<IAthleteAssembler>();
_mockModelAssembler = new Mock<IModelAssembler>();
_mockInventoryItemRepository = new Mock<IInventoryItemRepository>();
_mockInventoryMovementRepository = new Mock<IInventoryMovementRepository>();
_mockModelRepository = new Mock<IModelRepository>();
_inventoryItemDto = new InventoryItemDto() { ModelDto = new ModelDto() };
_athleteDto = new AthleteDto();
_modelDto = new ModelDto();
_inventoryItem = new InventoryItem();
_athlete = new Athlete();
_model = new Model();
ObjectFactory.Inject(typeof(IInventoryItemAssembler), _mockInventoryItemAssembler.Object);
ObjectFactory.Inject(typeof(IAthleteAssembler), _mockAthleteAssembler.Object);
ObjectFactory.Inject(typeof(IModelAssembler), _mockModelAssembler.Object);
ObjectFactory.Inject(typeof(IInventoryItemRepository), _mockInventoryItemRepository.Object);
ObjectFactory.Inject(typeof(IInventoryMovementRepository), _mockInventoryMovementRepository.Object);
ObjectFactory.Inject(typeof(IModelRepository), _mockModelRepository.Object);
_mockInventoryItemAssembler.Setup(x => x.ReadDto(_inventoryItemDto)).Returns(_inventoryItem);
}
/// <summary>
/// Registers an athlete with the backend and returns the new athlete profile
/// </summary>
async Task<Athlete> RegisterAthlete(GoogleUserProfile profile)
{
AuthenticationStatus = "Registering athlete";
var athlete = new Athlete(profile);
var task = AzureService.Instance.SaveAthlete(athlete);
await RunSafe(task);
if(task.IsCompleted && task.IsFaulted)
return null;
"You're now an officially registered athlete!".ToToast();
return athlete;
}
public Task SaveAthlete(Athlete athlete)
{
return new Task(() =>
{
if(athlete.Id == null)
{
if(athlete.Email == "*****@*****.**")
athlete.IsAdmin = true;
Client.GetTable<Athlete>().InsertAsync(athlete).Wait();
}
else
{
Client.GetTable<Athlete>().UpdateAsync(athlete).Wait();
}
DataManager.Instance.Athletes.AddOrUpdate(athlete);
});
}
/// <summary>
/// Loads all the leagues for specific athlete
/// </summary>
/// <returns>The all leagues by athlete.</returns>
/// <param name="athlete">Athlete.</param>
public Task<List<League>> GetAllLeaguesForAthlete(Athlete athlete)
{
return new Task<List<League>>(() =>
{
var leagueIds = Client.GetTable<Membership>().Where(m => m.AthleteId == athlete.Id && m.AbandonDate == null).Select(m => m.LeagueId).ToListAsync().Result;
//Wipe out any existing memberships related to the athlete
foreach(var m in DataManager.Instance.Memberships.Where(m => m.Value.AthleteId == athlete.Id).ToList())
{
Membership mem;
DataManager.Instance.Memberships.TryRemove(m.Key, out mem);
}
if(leagueIds.Count == 0)
return new List<League>();
var leagues = Client.GetTable<League>().Where(l => leagueIds.Contains(l.Id) && l.IsEnabled).OrderBy(l => l.Name).ToListAsync().Result;
EnsureAthletesLoadedForLeagues(leagues);
leagues.ForEach(CacheLeague);
return leagues;
});
}
public void SaveAthlete()
{
#region Setup objects
var athleteDto = new AthleteDto();
athleteDto.Nickname = "sheredia";
athleteDto.FirstName = "Sarah";
athleteDto.LastName = "Heredia";
athleteDto.Gender = 'F';
athleteDto.TrainerSizeW = 9;
athleteDto.SpikeSizeW = 9.5;
athleteDto.Notes = "Some notes on Sarah";
athleteDto.Status = "Current";
var eventAreaDto = new EventAreaDto();
eventAreaDto.EventName = "Pole Vault";
var modelDto = new ModelDto();
modelDto.ModelNumber = "1234";
modelDto.ModelName = "Model name";
modelDto.Type = "Runner";
modelDto.Color = "White";
modelDto.Price = 105.00;
modelDto.IsDiscontinued = false;
var inventoryItemDto = new InventoryItemDto();
inventoryItemDto.ModelDto = modelDto;
inventoryItemDto.SizeM = 9;
inventoryItemDto.SizeW = 11;
inventoryItemDto.Width = "N";
inventoryItemDto.RequestName = "request1";
inventoryItemDto.Status = "Requested";
//inventoryItemDto.AthleteDto = athleteDto;
inventoryItemDto.StatusLastChanged = DateTime.Now;
athleteDto.EventParticipation.Add(eventAreaDto);
athleteDto.Inventory.Add(inventoryItemDto);
var athlete = new Athlete();
athlete.Nickname = "sheredia";
athlete.FirstName = "Sarah";
athlete.LastName = "Heredia";
athlete.Gender = 'F';
athlete.TrainerSizeW = 9;
athlete.SpikeSizeW = 9.5;
athlete.Notes = "Some notes on Sarah";
athlete.Status = "Current";
var eventArea = new EventArea();
eventArea.EventName = "Pole Vault";
var model = new Model();
model.ModelNumber = "1234";
model.ModelName = "Model name";
model.Type = "Runner";
model.Color = "White";
model.Price = 105.00;
model.IsDiscontinued = false;
var inventoryItem = new InventoryItem();
inventoryItem.Model = model;
inventoryItem.SizeM = 9;
inventoryItem.SizeW = 11;
inventoryItem.Width = "N";
inventoryItem.RequestName = "request1";
inventoryItem.Status = "Requested";
inventoryItem.Athlete = athlete;
inventoryItem.StatusLastChanged = DateTime.Now;
athlete.EventAreas.Add(eventArea);
athlete.Inventory.Add(inventoryItem);
#endregion
_mockAthleteAssembler.Setup(x => x.ReadDto(athleteDto)).Returns(athlete);
_mockAthleteRepository.Setup(x => x.Save(athlete));
_mockAthleteAssembler.Setup(x => x.WriteDto(athlete)).Returns(new AthleteDto());
AthleteService.SaveAthlete(athleteDto);
_mockAthleteAssembler.VerifyAll();
_mockAthleteRepository.VerifyAll();
}
public AthleteEditViewModel()
{
Athlete = new Athlete();
}
