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(); }