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.");
}
}
