public TrainingPlan WorkoutPlanOperation(Token token, WorkoutPlanOperationParam param)
{
var securityInfo = SecurityManager.EnsureAuthentication(token);
var service = new WorkoutPlanService(Session, securityInfo, Configuration);
return(service.WorkoutPlanOperation(param));
}
private void usrProgressIndicatorButtons1_OkClick(object sender, CancellationSourceEventArgs e)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
if (Publish)
{
param.Operation = SupplementsCycleDefinitionOperation.Publish;
}
else
{
param.Operation = SupplementsCycleDefinitionOperation.AddToFavorites;
}
try
{
ServiceManager.WorkoutPlanOperation(param);
WorkoutPlansReposidory.Instance.ClearCache();
ThreadSafeClose(true);
}
catch (ProfileRankException ex)
{
UIHelper.Invoke(() => ExceptionHandler.Default.Process(ex, string.Format("PublishWorkoutPlanWindow_ErrProfileRank".TranslateStrength(), Portable.Constants.StrengthTrainingEntriesCount), ErrorWindow.MessageBox), Dispatcher);
ThreadSafeClose(false);
}
}
public void DeletePlan_DataInfo_Refresh()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = createWorkoutPlanObject(profile);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
plan = Service.SaveWorkoutPlan(data.Token, plan);
});
var dbProfile = Session.Get <Profile>(profile.GlobalId);
var oldHash = dbProfile.DataInfo.WorkoutPlanHash;
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
TimerService.UtcNow = DateTime.UtcNow.AddHours(1);
WorkoutPlanOperationParam param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Delete;
Service.WorkoutPlanOperation(data.Token, param);
});
dbProfile = Session.Get <Profile>(profile.GlobalId);
Assert.AreNotEqual(oldHash, dbProfile.DataInfo.WorkoutPlanHash);
}
public void DeletePlan()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = createWorkoutPlanObject(profile);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
plan = Service.SaveWorkoutPlan(data.Token, plan);
});
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
WorkoutPlanOperationParam param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Delete;
Service.WorkoutPlanOperation(data.Token, param);
});
var count = Session.QueryOver <BodyArchitect.Model.TrainingPlan>().RowCount();
Assert.AreEqual(0, count);
}
public void RemoveFromFavorites_Twice()
{
var plan = CreatePlan(Session, profiles[1], "plan1");
profiles[0].FavoriteWorkoutPlans.Add(plan);
insertToDatabase(profiles[0]);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.RemoveFromFavorites;
service.WorkoutPlanOperation(data.Token, param);
});
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.RemoveFromFavorites;
service.WorkoutPlanOperation(data.Token, param);
});
}
private void deleteSelectedTrainingPlan()
{
var plan = TrainingPlan;
if (plan == null || plan.Status == PublishStatus.Published || plan.Profile.GlobalId != UserContext.Current.CurrentProfile.GlobalId)
{
return;
}
if (!UIHelper.EnsurePremiumLicence())
{
return;
}
if (BAMessageBox.AskYesNo(StrengthTrainingEntryStrings.QRemoveTrainingPlan) == MessageBoxResult.Yes)
{
ParentWindow.RunAsynchronousOperation(delegate
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Delete;
ServiceManager.WorkoutPlanOperation(param);
WorkoutPlansReposidory.Instance.ClearCache();
Dispatcher.BeginInvoke(new Action <PageContext>(Fill), this.pageContext);
}, asyncOperationStateChange);
//try
//{
//}
//catch (Exception ex)
//{
// ExceptionHandler.Default.Process(ex, StrengthTrainingEntryStrings.ErrorDuringDeleteTrainingPlan, ErrorWindow.EMailReport);
//}
}
}
public void PublishWorkoutPlan_DataInfo_Refresh()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = (Service.V2.Model.TrainingPlans.TrainingPlan)workoutPlans["test1-4"].Tag;
Assert.AreEqual(BodyArchitect.Service.V2.Model.PublishStatus.Private, plan.Status);
var oldHash = profiles[0].DataInfo.WorkoutPlanHash;
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Publish;
Service.WorkoutPlanOperation(data.Token, param);
});
var dbPlan = Session.Get <TrainingPlan>(plan.GlobalId);
Assert.AreEqual(PublishStatus.Published, dbPlan.Status);
Assert.IsNotNull(dbPlan.PublishDate);
var dbProfile = Session.Get <Profile>(plan.Profile.GlobalId);
Assert.AreNotEqual(oldHash, dbProfile.DataInfo.WorkoutPlanHash);
}
public TrainingPlan WorkoutPlanOperation(Token token, WorkoutPlanOperationParam param)
{
return(exceptionHandling(token, () =>
{
return InternalService.WorkoutPlanOperation(token, param);
}));
}
public TrainingPlan WorkoutPlanOperation(WorkoutPlanOperationParam param)
{
Log.WriteWarning("WorkoutPlanFavoritesOperation: Username={0},userDto.GlobalId={1}", SecurityInfo.SessionData.Profile.UserName, param.Operation);
if (!SecurityInfo.Licence.IsPremium)
{
throw new LicenceException("This feature is allowed for Premium account");
}
var session = Session;
TrainingPlan result = null;
using (var tx = session.BeginSaveTransaction())
{
var profileDb = session.Load <Profile>(SecurityInfo.SessionData.Profile.GlobalId);
var workoutPlanDb = session.Get <BodyArchitect.Model.TrainingPlan>(param.WorkoutPlanId);
if (param.Operation == SupplementsCycleDefinitionOperation.AddToFavorites)
{
if (workoutPlanDb.Profile == profileDb || workoutPlanDb.Status == PublishStatus.Private)
{
throw new InvalidOperationException("Cannot add/remove your workout plan to the favorite list");
}
if (profileDb.FavoriteWorkoutPlans.Contains(workoutPlanDb))
{
throw new ObjectIsFavoriteException("Plan is in favorites list already");
}
profileDb.FavoriteWorkoutPlans.Add(workoutPlanDb);
}
else if (param.Operation == SupplementsCycleDefinitionOperation.RemoveFromFavorites)
{
if (profileDb.FavoriteWorkoutPlans.Contains(workoutPlanDb))
{
profileDb.FavoriteWorkoutPlans.Remove(workoutPlanDb);
}
else
{
throw new ObjectIsNotFavoriteException("Plan is not in favorites list");
}
}
else if (param.Operation == SupplementsCycleDefinitionOperation.Publish)
{
workoutPlanDb = publishWorkoutPlan(workoutPlanDb, profileDb);
result = workoutPlanDb.Map <TrainingPlan>();
}
else if (param.Operation == SupplementsCycleDefinitionOperation.Delete)
{
DeleteWorkoutPlan(param.WorkoutPlanId);
}
profileDb.DataInfo.WorkoutPlanHash = Guid.NewGuid();
session.SaveOrUpdate(profileDb);
tx.Commit();
return(result);
}
}
private void btnAddToFavorites_Click(object sender, EventArgs e)
{
if (!UpgradeAccountControl.EnsureAccountType(ApplicationStrings.Feature_Premium_CreatingWorkoutPlans, this))
{
return;
}
progressBar.ShowProgress(true);
var m = new ServiceManager <WorkoutPlanOperationCompletedEventArgs>(delegate(BodyArchitectAccessServiceClient client1, EventHandler <WorkoutPlanOperationCompletedEventArgs> operationCompleted)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = SelectedPlan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.AddToFavorites;
client1.WorkoutPlanOperationAsync(ApplicationState.Current.SessionData.Token, param);
client1.WorkoutPlanOperationCompleted -= operationCompleted;
client1.WorkoutPlanOperationCompleted += operationCompleted;
});
m.OperationCompleted += (s1, a1) =>
{
progressBar.ShowProgress(false);
FaultException <BAServiceException> serviceEx = a1.Error as FaultException <BAServiceException>;
if (serviceEx != null && serviceEx.Detail.ErrorCode == ErrorCode.LicenceException)
{
BAMessageBox.ShowInfo(ApplicationStrings.ErrLicence);
return;
}
if (a1.Error != null)
{
BAMessageBox.ShowError(ApplicationStrings.ErrCannotAddPlanToFavorites);
return;
}
else
{
ApplicationState.Current.Cache.TrainingPlans.Items.Add(SelectedPlan.GlobalId, SelectedPlan);
}
updateApplicationBar();
};
if (!m.Run())
{
progressBar.ShowProgress(false);
if (ApplicationState.Current.IsOffline)
{
BAMessageBox.ShowError(ApplicationStrings.ErrOfflineMode);
}
else
{
BAMessageBox.ShowError(ApplicationStrings.ErrNoNetwork);
}
}
}
public void TestPublishWorkoutPlan_CrossProfile()
{
var profile = (ProfileDTO)profiles[1].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = (Service.V2.Model.TrainingPlans.TrainingPlan)workoutPlans["test1-2"].Tag;
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Publish;
Service.WorkoutPlanOperation(data.Token, param);
});
}
public void AddToFavorites_PrivatePlan()
{
var plan = CreatePlan(Session, profiles[0], "plan1", isPublished: false);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.AddToFavorites;
service.WorkoutPlanOperation(data.Token, param);
});
}
public static bool RemoveFromFavorites(this TrainingPlan plan)
{
if (plan == null || !plan.IsFavorite() || plan.IsMine())
{
return(false);
}
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.RemoveFromFavorites;
ServiceManager.WorkoutPlanOperation(param);
WorkoutPlansReposidory.Instance.Remove(plan.GlobalId);
return(true);
}
public void AddToFavorites_DataInfo_Refresh_ForPlanOwner()
{
var plan = CreatePlan(Session, profiles[0], "plan1");
var oldHash = profiles[0].DataInfo.WorkoutPlanHash;
ProfileDTO profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = CreateNewSession(profile1, ClientInformation, new LoginData());
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.AddToFavorites;
Service.WorkoutPlanOperation(data.Token, param);
});
var dbProfile = Session.Get <Profile>(profiles[0].GlobalId);
Assert.AreEqual(oldHash, dbProfile.DataInfo.WorkoutPlanHash);
}
public void AddToFavorites_PlanFromCurrentProfile()
{
var plan = CreatePlan(Session, profiles[0], "plan1");
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.AddToFavorites;
service.WorkoutPlanOperation(data.Token, param);
});
var dbProfile = Session.Get <Profile>(profile.GlobalId);
Assert.AreEqual(1, dbProfile.FavoriteWorkoutPlans.Count);
Assert.AreEqual(plan.GlobalId, dbProfile.FavoriteWorkoutPlans.ElementAt(0).GlobalId);
}
private void mnuRemoveFromFavorites_Click(object sender, RoutedEventArgs e)
{
var item = (WorkoutPlanViewModel)(sender as FrameworkElement).DataContext;
progressBar.ShowProgress(true);
var m = new ServiceManager <WorkoutPlanOperationCompletedEventArgs>(delegate(BodyArchitectAccessServiceClient client1, EventHandler <WorkoutPlanOperationCompletedEventArgs> operationCompleted)
{
WorkoutPlanOperationParam param = new WorkoutPlanOperationParam();
param.Operation = SupplementsCycleDefinitionOperation.RemoveFromFavorites;
param.WorkoutPlanId = item.Plan.GlobalId;
client1.WorkoutPlanOperationAsync(ApplicationState.Current.SessionData.Token, param);
client1.WorkoutPlanOperationCompleted -= operationCompleted;
client1.WorkoutPlanOperationCompleted += operationCompleted;
});
m.OperationCompleted += (s1, a1) =>
{
progressBar.ShowProgress(false);
if (a1.Error != null)
{
BAMessageBox.ShowError(ApplicationStrings.ErrCannotRemovePlanFromFavorites);
return;
}
else
{
ApplicationState.Current.Cache.TrainingPlans.Items.Remove(item.Plan.GlobalId);
viewModel.RemoveFromFavorites(item);
}
};
if (!m.Run())
{
progressBar.ShowProgress(false);
if (ApplicationState.Current.IsOffline)
{
BAMessageBox.ShowError(ApplicationStrings.ErrOfflineMode);
}
else
{
BAMessageBox.ShowError(ApplicationStrings.ErrNoNetwork);
}
}
}
public void TestPublishWorkoutPlan_Statistics()
{
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = (Service.V2.Model.TrainingPlans.TrainingPlan)workoutPlans["test1-4"].Tag;
Assert.AreEqual(BodyArchitect.Service.V2.Model.PublishStatus.Private, plan.Status);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Publish;
Service.WorkoutPlanOperation(data.Token, param);
});
var dbProfile = Session.Get <Profile>(profile.GlobalId);
Assert.AreEqual(5, dbProfile.Statistics.WorkoutPlansCount);
}
public void TestPublishWorkoutPlan_WithMissingExercise()
{
var missingExercise = CreateExercise(Session, null, "Missing", "--");
missingExercise.IsDeleted = true;
insertToDatabase(missingExercise);
var profile = (ProfileDTO)profiles[0].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = createPlan(profiles[0], "test1-3", PublishStatus.Private, TrainingPlanDifficult.Beginner, TrainingType.PushPull, missingExercise);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Publish;
Service.WorkoutPlanOperation(data.Token, param);
});
}
public void RemoveFromFavorites_DataInfo_Refresh()
{
var plan = CreatePlan(Session, profiles[0], "plan1");
//now add plan to favorites
profiles[1].FavoriteWorkoutPlans.Add(plan);
insertToDatabase(profiles[1]);
var oldHash = profiles[0].DataInfo.WorkoutPlanHash;
ProfileDTO profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = CreateNewSession(profile1, ClientInformation, new LoginData());
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
var param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.RemoveFromFavorites;
Service.WorkoutPlanOperation(data.Token, param);
});
var dbProfile = Session.Get <Profile>(profile1.GlobalId);
Assert.AreNotEqual(dbProfile.DataInfo.WorkoutPlanHash, oldHash);
}
public void SecurityBug()
{
var profile = (ProfileDTO)profiles[0].Tag;
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = CreateNewSession(profile, ClientInformation);
var plan = createWorkoutPlanObject(profile);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
plan = Service.SaveWorkoutPlan(data.Token, plan);
});
data = CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService Service)
{
WorkoutPlanOperationParam param = new WorkoutPlanOperationParam();
param.WorkoutPlanId = plan.GlobalId;
param.Operation = SupplementsCycleDefinitionOperation.Delete;
Service.WorkoutPlanOperation(data.Token, param);
});
}
public static TrainingPlan WorkoutPlanOperation(WorkoutPlanOperationParam param)
{
return(exceptionHandling(() => Instance.WorkoutPlanOperation(Token, param)));
}
