public FitnessClass Delete(FitnessClass Class) { var result = _context.Remove(Class); _context.SaveChanges(); return(result.Entity); }
public static int Save(FitnessClass fitnessClassToSave) { int result = 0; ExecuteTypeEnum queryId = ExecuteTypeEnum.InsertItem; if (fitnessClassToSave.FitnessClassId > 0) { queryId = ExecuteTypeEnum.UpdateItem; } using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString)) { using (SqlCommand myCommand = new SqlCommand("usp_ExecuteFitnessClass", myConnection)) { myCommand.CommandType = CommandType.StoredProcedure; myCommand.Parameters.AddWithValue("@QueryId", queryId); myCommand.Parameters.AddWithValue("@FitnessClassId", fitnessClassToSave.FitnessClassId); myCommand.Parameters.AddWithValue("@FitnessClassName", fitnessClassToSave.FitnessClassName); myCommand.Parameters.Add(HelperDAL.GetReturnParameterInt("ReturnValue")); myConnection.Open(); myCommand.ExecuteNonQuery(); result = (int)myCommand.Parameters["@ReturnValue"].Value; } myConnection.Close(); } return(result); }
public async Task <IActionResult> EnrollMember([Bind("enrolledRegisrationId,classSessionId,memberId")] ClassEnrollee classEnrollee) { if (ModelState.IsValid) { _context.Add(classEnrollee); await _context.SaveChangesAsync(); // update Member's balance int memID = Int32.Parse(Request.Form["memberId"].ToString()); int cID = Int32.Parse(Request.Form["classSessionId"].ToString()); var mem = _context.Members.Where(m => m.memberId == memID).Single();; Member member = (Member)mem; var fclass = _context.ClassSessions.Where(c => c.classSessionId == cID).Include(f => f.FitnessClass).Single(); FitnessClass fc = (FitnessClass)fclass.FitnessClass; double balance = member.currentAmountOwed + fc.fitnessclassFee; member.currentAmountOwed = balance; _context.Update(member); await _context.SaveChangesAsync(); return(RedirectToAction("Index")); } ViewData["classSessionId"] = new SelectList(_context.ClassSessions, "classSessionId", "classSessionId", classEnrollee.classSessionId); ViewData["memberId"] = new SelectList(_context.Members, "memberId", "memberId", classEnrollee.memberId); return(View(classEnrollee)); }
public async Task <IActionResult> Edit(int id, [Bind("fitnessclassId,fitnessclassTitle,fitnessclassDescription,fitnessclassDuration,fitnessclassCaloriesBurnedApprox,fitnessclassMaxEnrollees,fitnessclassFee")] FitnessClass fitnessClass) { if (id != fitnessClass.fitnessclassId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(fitnessClass); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!FitnessClassExists(fitnessClass.fitnessclassId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(fitnessClass)); }
public FitnessClass Create(FitnessClass FitnessClass) { var result = _context.Add <FitnessClass>(FitnessClass); _context.SaveChanges(); return(result.Entity); }
public void Post(FitnessClassDTO value) { FitnessClass model = new FitnessClass() { Name = value.Name, Img = value.Img }; IFitnessClassRepository.Create(model); // am creat o clasa // trebuie sa introducem si in tabela de intersectie for (int i = 0; i < value.InstructorId.Count; i++) { InstructorFitnessClass InstructorClass = new InstructorFitnessClass() { FitnessClassId = model.Id, InstructorId = value.InstructorId[i] }; IInstructorClassRepository.Create(InstructorClass); } for (int i = 0; i < value.GymClubId.Count; i++) { GymClubFitnessClass GymClubClass = new GymClubFitnessClass() { FitnessClassId = model.Id, GymClubId = value.GymClubId[i] }; IGymClubClassRepository.Create(GymClubClass); } }
public void FitnessClassEdited(FitnessClass fclass) { var oldValue = model.Classes.First(fc => fc.Id == fclass.Id); model.Classes.Remove(oldValue); model.Classes.Add(fclass); }
/// <summary> /// Finds Fit DataSources using the deprecated Fitness.SensorsApi. /// </summary> private async Task FindFitnessDataSourcesWithSensorsApi() { DataSourcesRequest request = new DataSourcesRequest.Builder() .SetDataTypes(DataType.TypeLocationSample) .SetDataSourceTypes(DataSource.TypeRaw) .Build(); var client = FitnessClass.GetSensorsClient(this, GoogleAccount); var dataSourcesResult = await FitnessClass.SensorsApi.FindDataSourcesAsync(client.AsGoogleApiClient(), request); Log.Info(TAG, "Result: " + dataSourcesResult.Status); foreach (DataSource dataSource in dataSourcesResult.DataSources) { Log.Info(TAG, "Data source found: " + dataSource); Log.Info(TAG, "Data Source type: " + dataSource.DataType.Name); // NOTE: We used DataType.Name here as the test for equality between DataType was false. // The reason for this should be determined. // Let's register a listener to receive Activity data! if ((dataSource.DataType.Name == DataType.TypeLocationSample.Name) && (_dataPointListener == null)) { Log.Info(TAG, "Data source for LOCATION_SAMPLE found! Registering."); await RegisterFitnessDataListener(dataSource, DataType.TypeLocationSample); } } }
public bool DeleteFitnessClass(FitnessClass fclass) { var tobedeleted = _db.Classes.Find(fclass.Id); _db.Classes.Remove(tobedeleted); return(tobedeleted != null); }
private async Task RegisterFitnessDataListener(DataSource dataSource, DataType dataType) { var request = new SensorRequest.Builder() .SetDataSource(dataSource) // Optional but recommended for custom data sets. .SetDataType(dataType) // Can't be omitted. .SetSamplingRate(10, TimeUnit.Seconds) .Build(); _dataPointListener = new OnDataPointListener(); var client = FitnessClass.GetSensorsClient(this, GoogleAccount); // NOTE: There is no way to check on the result of the AddAsync() method. // We use the sensors client Add() with an OnComplete callback to obtain // the complete status. client.Add(request, _dataPointListener) .AddOnCompleteListener(this, new OnCompleteListener { OnCompleteCallback = (success) => { if (success) { Log.Info(TAG, "Listener registered."); } else { Log.Info(TAG, "Listener not registered."); } } }); }
public FitnessClassCRUD(FitnessClass fc, WindowType type) { InitializeComponent(); service = Service.Service.Instance; this.type = type; fitnessClass = fc; }
public static FitnessClass GetItem(int fitnessClassId) { FitnessClass tempItem = null; using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString)) { using (SqlCommand myCommand = new SqlCommand("usp_GetFitnessClass", myConnection)) { myCommand.CommandType = CommandType.StoredProcedure; myCommand.Parameters.AddWithValue("@QueryID", SelectTypeEnum.GetItem); myCommand.Parameters.AddWithValue("@FitnessClassId", fitnessClassId); myConnection.Open(); using (SqlDataReader myReader = myCommand.ExecuteReader()) { if (myReader.Read()) { tempItem = FillDataRecord(myReader); } myReader.Close(); } } } return(tempItem); }
private void btnAddClass_Click(object sender, RoutedEventArgs e) { FitnessClass fc = new FitnessClass(); var window = new FitnessClassCRUD(fc, WindowType.NewEntity); window.ChangesMade += FitnessClassAdded; window.Show(); }
private void btnEditClass_Click(object sender, RoutedEventArgs e) { FitnessClass selected = dgrdClasses.SelectedItem as FitnessClass; var window = new FitnessClassCRUD(selected, WindowType.EditEntity); window.ChangesMade += FitnessClassEdited; window.Show(); }
public static int Save(FitnessClass fitnessClassToSave) { int fitnessClassId = SaveFitnessClass(fitnessClassToSave); fitnessClassToSave.FitnessClassId = fitnessClassId; return(FitnessClassDAL.Save(fitnessClassToSave)); }
public void UpdateFitnessClass(FitnessClass updatedFitnessClass) { var fitnessClass = _context.FitnessClass.Where(x => x.ID == updatedFitnessClass.ID).FirstOrDefault(); fitnessClass.Name = updatedFitnessClass.Name; fitnessClass.Instructor = updatedFitnessClass.Instructor; fitnessClass.Description = updatedFitnessClass.Description; }
public static int SaveFitnessClass(FitnessClass fitnessClassToSave) { FitnessClass tempClass = new FitnessClass(); tempClass.FitnessClassId = fitnessClassToSave.FitnessClassId; tempClass.FitnessClassName = fitnessClassToSave.FitnessClassName; return(FitnessClassManager.Save(tempClass)); }
private void btnDeleteClass_Click(object sender, RoutedEventArgs e) { FitnessClass selected = dgrdClasses.SelectedItem as FitnessClass; bool result = service.DeleteFitnessClass(selected); if (result) { model.Classes.Remove(selected); } }
public async Task <IActionResult> Create([Bind("fitnessclassId,fitnessclassTitle,fitnessclassDescription,fitnessclassDuration,fitnessclassCaloriesBurnedApprox,fitnessclassMaxEnrollees,fitnessclassFee")] FitnessClass fitnessClass) { if (ModelState.IsValid) { _context.Add(fitnessClass); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(fitnessClass)); }
public FitnessClass AddFitnessClass(FitnessClass fclass) { FitnessClass result = null; if (fclass != null) { result = _db.Classes.Add(fclass); _db.Entry(fclass).State = EntityState.Added; _db.SaveChanges(); } return(result); }
public void Put(int id, FitnessClassDTO value) { FitnessClass model = IFitnessClassRepository.Get(id); if (value.Name != null) { model.Name = value.Name; } if (value.Img != null) { model.Img = value.Img; } IFitnessClassRepository.Update(model); //trebuie sa putem face update si la lista de instructori si sali de fitness if (value.InstructorId != null) { IEnumerable <InstructorFitnessClass> MyInstructorClasses = IInstructorClassRepository.GetAll().Where(x => x.FitnessClassId == id); foreach (InstructorFitnessClass MyInstructorClass in MyInstructorClasses) { IInstructorClassRepository.Delete(MyInstructorClass); } for (int i = 0; i < value.InstructorId.Count; i++) { InstructorFitnessClass InstructorClass = new InstructorFitnessClass() { FitnessClassId = model.Id, InstructorId = value.InstructorId[i] }; IInstructorClassRepository.Create(InstructorClass); } } if (value.GymClubId != null) { IEnumerable <GymClubFitnessClass> MyGymClubClasses = IGymClubClassRepository.GetAll().Where(x => x.FitnessClassId == id); foreach (GymClubFitnessClass MyGymClubClass in MyGymClubClasses) { IGymClubClassRepository.Delete(MyGymClubClass); } for (int i = 0; i < value.GymClubId.Count; i++) { GymClubFitnessClass GymClubClass = new GymClubFitnessClass() { FitnessClassId = model.Id, GymClubId = value.GymClubId[i] }; IGymClubClassRepository.Create(GymClubClass); } } }
public FitnessClass EditFitnessClass(FitnessClass fclass) { FitnessClass result = null; if (fclass != null) { var oldValue = _db.Classes.First(fc => fc.Id == fclass.Id); _db.Classes.Remove(oldValue); result = _db.Classes.Add(fclass); _db.Entry(result).State = EntityState.Added; } return(result); }
public FitnessClassDetailsDTO Get(int id) { FitnessClass FitnessClass = IFitnessClassRepository.Get(id); FitnessClassDetailsDTO MyClass = new FitnessClassDetailsDTO() { Name = FitnessClass.Name, Img = FitnessClass.Img }; IEnumerable <InstructorFitnessClass> MyInstructorClasses = IInstructorClassRepository.GetAll().Where(x => x.FitnessClassId == FitnessClass.Id); if (MyInstructorClasses != null) { List <string> InstructorNameList = new List <string>(); foreach (InstructorFitnessClass MyInstructorClass in MyInstructorClasses) { Instructor MyInstructor = IInstructorRepository.GetAll().SingleOrDefault(x => x.Id == MyInstructorClass.InstructorId); InstructorNameList.Add(MyInstructor.FirstName + " " + MyInstructor.LastName); } MyClass.InstructorName = InstructorNameList; } IEnumerable <GymClubFitnessClass> MyGymClubClasses = IGymClubClassRepository.GetAll().Where(x => x.FitnessClassId == FitnessClass.Id); if (MyGymClubClasses != null) { List <string> GymClubNameList = new List <string>(); foreach (GymClubFitnessClass MyGymClubClass in MyGymClubClasses) { GymClub MyGymClub = IGymClubRepository.GetAll().SingleOrDefault(x => x.Id == MyGymClubClass.GymClubId); GymClubNameList.Add(MyGymClub.Name); } MyClass.GymClubName = GymClubNameList; } IEnumerable <Song> MySongs = ISongRepository.GetAll().Where(x => x.FitnessClassId == FitnessClass.Id); if (MySongs != null) { List <string> SongNameList = new List <string>(); foreach (Song MySong in MySongs) { SongNameList.Add(MySong.Name); } MyClass.SongName = SongNameList; } return(MyClass); }
private void btnConfirm_Click(object sender, RoutedEventArgs e) { if (type == WindowType.NewEntity) { //fitnessClass.Discipline = cmbDisciplines.SelectedItem as Discipline; //fitnessClass.Instructor = cmbInstructor.SelectedItem as Instructor; //fitnessClass.Gym = cmbGym.SelectedItem as Gym; fitnessClass = service.AddFitnessClass(fitnessClass); } else { fitnessClass = service.EditFitnessClass(fitnessClass); } this.Close(); ChangesMade?.Invoke(fitnessClass); }
private static FitnessClass FillDataRecord(IDataRecord myDataRecord) { FitnessClass myObject = new FitnessClass(); myObject.FitnessClassId = myDataRecord.GetInt32(myDataRecord.GetOrdinal("FitnessClassId")); myObject.InstructorFitnessClassId = myDataRecord.GetInt32(myDataRecord.GetOrdinal("InstructorFitnessClassId")); if (!myDataRecord.IsDBNull(myDataRecord.GetOrdinal("FitnessClassName"))) { myObject.FitnessClassName = myDataRecord.GetString(myDataRecord.GetOrdinal("FitnessClassName")); } return(myObject); }
private FitnessClassDTO FitnessClassItemToDTO(FitnessClass fitnessClass) { FitnessClassDTO tempItem = new FitnessClassDTO(); if (fitnessClass != null) { tempItem.FitnessClassId = fitnessClass.FitnessClassId; if (!string.IsNullOrEmpty(fitnessClass.FitnessClassName)) { tempItem.FitnessClassName = fitnessClass.FitnessClassName; } if (!string.IsNullOrEmpty(fitnessClass.InstructorFitnessClassId.ToString())) { tempItem.InstructorFitnessClassId = fitnessClass.InstructorFitnessClassId; } } return(tempItem); }
// utility function that gets the basal metabolic rate averaged over a week private async Task <double> GetBasalAvg(DateTime endDate) { float basalAvg = 0; long startDate = endDate.AddDays(-7).ToJavaTimeStamp(); var readRequest = new DataReadRequest.Builder() .Aggregate(DataType.TypeBasalMetabolicRate, DataType.AggregateBasalMetabolicRateSummary) .BucketByTime(1, TimeUnit.Days) .SetTimeRange(startDate, endDate.ToJavaTimeStamp(), TimeUnit.Milliseconds).Build(); var response = await FitnessClass.GetHistoryClient(_currentActivity, GoogleSignIn.GetLastSignedInAccount(_currentActivity)) .ReadDataAsync(readRequest); if (response.Status.IsSuccess) { var avgsN = 0; foreach (var bucket in response.Buckets) { // in the com.google.bmr.summary data type, each data point represents // the average, maximum and minimum basal metabolic rate, in kcal per day, over the time interval of the data point. var dataSet = bucket.GetDataSet(DataType.AggregateBasalMetabolicRateSummary); foreach (var dataPoint in dataSet.DataPoints) { var avg = dataPoint.GetValue(Field.FieldAverage).AsFloat(); if (avg > 0) { basalAvg += avg; avgsN++; } } } // do the average of the averages if (avgsN != 0) { basalAvg /= avgsN; // this a daily average } return(basalAvg); } throw new Exception(response.Status.StatusMessage); }
private void BindFitnessClass() { int fitnessClassId = Request.QueryString["FitnessClassId"].ToInt(); if (fitnessClassId > 0) { FitnessClass personLookup = FitnessClassDAL.GetItem(fitnessClassId); if (personLookup != null) { lblFitnessClassId.Text = personLookup.FitnessClassId.ToString(); lblFitnessClassName.Text = personLookup.FitnessClassName; lblDescription.Text = personLookup.Description; } else lblMessage.Text = "Fitness Class could not be found."; } else lblMessage.Text = "Invalid ID. Fitness Class record could not be found."; }
public IActionResult AddEditClass(FitnessClass fitnessClass) { if (ModelState.IsValid) { var classExists = _unitOfWork.FitnessClass.GetFitnessClassByID(fitnessClass.ID) != null ? true : false; if (!classExists) { _unitOfWork.FitnessClass.AddFitnessClass(fitnessClass); _unitOfWork.Complete(); return(View(fitnessClass)); } else { _unitOfWork.FitnessClass.UpdateFitnessClass(fitnessClass); _unitOfWork.Complete(); } } return(View()); }
private async Task UnregisterFitnessDataListener() { if (_dataPointListener == null) { return; } var client = FitnessClass.GetSensorsClient(this, GoogleAccount); var status = await client.RemoveAsync(_dataPointListener); if (status.BooleanValue()) { Log.Info(TAG, "Listener was removed!"); _dataPointListener = null; } else { Log.Info(TAG, "Listener was not removed."); } }