public static void WorkoutPlanFavoritesOperation(WorkoutPlanDTO planDto, FavoriteOperation operation)
{
exceptionHandling(delegate
{
Instance.WorkoutPlanFavoritesOperation(Token, planDto, operation);
});
}
public static WorkoutPlanDTO PublishWorkoutPlan(WorkoutPlanDTO planDto)
{
return(exceptionHandling(delegate
{
return Instance.PublishWorkoutPlan(Token, planDto);
}));
}
public static WorkoutPlanDTO VoteWorkoutPlan(WorkoutPlanDTO dto)
{
return(exceptionHandling(delegate
{
return Instance.VoteWorkoutPlan(Token, dto);
}));
}
public static void DeleteWorkoutPlan(WorkoutPlanDTO dto)
{
exceptionHandling(delegate
{
Instance.DeleteWorkoutPlan(Token, dto);
});
}
void editTrainingPlan(BodyArchitect.Service.Model.TrainingPlans.TrainingPlan plan)
{
ControlHelper.RunWithExceptionHandling(delegate
{
WorkoutPlanDTO planDto = (WorkoutPlanDTO)plan.Tag;
TrainingPlanEditorWindow wnd = new TrainingPlanEditorWindow();
wnd.Fill(plan);
if (wnd.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
ParentWindow.RunAsynchronousOperation(delegate
{
TrainingPlanChecker checker = new TrainingPlanChecker();
checker.Process(wnd.TrainingPlan);
planDto.SetTrainingPlan(wnd.TrainingPlan);
XmlSerializationTrainingPlanFormatter formatter = new XmlSerializationTrainingPlanFormatter();
planDto.PlanContent = formatter.ToXml(wnd.TrainingPlan).ToString();
planDto.Profile = UserContext.CurrentProfile;
ServiceManager.SaveTrainingPlan(planDto);
ObjectsReposidory.ClearWorkoutPlansCache();
ParentWindow.SynchronizationContext.Send(delegate
{
Fill();
}, null);
});
}
});
}
public static WorkoutPlanDTO SaveTrainingPlan(WorkoutPlanDTO dto)
{
return(exceptionHandling(delegate
{
return Instance.SaveWorkoutPlan(Token, dto);
}));
}
private void btnClone_Click(object sender, EventArgs e)
{
var plan = TrainingPlan;
if (plan == null)
{
return;
}
ParentWindow.RunAsynchronousOperation(delegate
{
var workoutPlan = plan.ToTrainingPlan();
workoutPlan.BasedOnId = plan.GlobalId;
var copyPlan = workoutPlan.Clone();
copyPlan.BasedOnId = plan.GlobalId;
copyPlan.GlobalId = Guid.NewGuid();
copyPlan.Name = StrengthTrainingEntryStrings.TrainingPlanNewName;
WorkoutPlanDTO dto = new WorkoutPlanDTO();
copyPlan.Tag = dto;
dto.SetTrainingPlan(copyPlan);
ParentWindow.SynchronizationContext.Send(delegate
{
editTrainingPlan(copyPlan);
}, null);
}, asyncOperationStateChange);
}
protected virtual void OnOpenPlanRequest(WorkoutPlanDTO plan)
{
if (OpenPlanRequest != null)
{
OpenPlanRequest(this, new WorkoutPlanEventArgs(plan));
}
}
protected virtual void OnDeletePlanRequest(WorkoutPlanDTO plan)
{
if (DeletePlanRequest != null)
{
DeletePlanRequest(this, new WorkoutPlanEventArgs(plan));
}
}
string getNodeBitmap(WorkoutPlanDTO plan)
{
if (plan.IsMine())
{
return("Owner");
}
return("TrainingPlan");
}
public static TrainingPlan ToTrainingPlan(this WorkoutPlanDTO plan)
{
plan.LoadContent();
XmlSerializationTrainingPlanFormatter formatter = new XmlSerializationTrainingPlanFormatter();
var newPlan = formatter.FromXml(plan.PlanContent);
return(newPlan);
}
public static Node CreateNode(WorkoutPlanDTO planDto)
{
string difficultText = new EnumLocalizer(StrengthTrainingEntryStrings.ResourceManager).Translate(planDto.Difficult);
Node item = new Node(new[] { planDto.Name, planDto.Author, planDto.TrainingType.ToString(), difficultText,
planDto.CreationDate.ToLocalTime().ToShortDateString() });
item.Tag = planDto;
return(item);
}
//public static bool IsFavorite(this ExerciseDTO exercise)
//{
// if(exercise==null)
// {
// return false;
// }
// EnsureExercisesLoaded();
// var res = (from e in dictExercises.Values where e.GlobalId == exercise.GlobalId && e.Profile != null && !e.IsMine() select e).Count();
// return res > 0;
//}
public static bool IsFavorite(this WorkoutPlanDTO plan)
{
EnsurePlansLoaded();
if (dictPlans == null)
{
return(false);
}
var res = (from e in dictPlans.Values where e.GlobalId == plan.GlobalId && e.Profile != null && !e.IsMine() select e).Count();
return(res > 0);
}
public static bool RemoveFromFavorites(this WorkoutPlanDTO plan)
{
if (plan == null || !plan.IsFavorite() || plan.IsMine())
{
return(false);
}
ServiceManager.WorkoutPlanFavoritesOperation(plan, FavoriteOperation.Remove);
ObjectsReposidory.ClearWorkoutPlansCache();
return(true);
}
int getStateImageIndex(WorkoutPlanDTO plan)
{
if (plan.IsFavorite())
{
return(7);
}
else if (plan.Status == PublishStatus.Published)
{
return(5);
}
return(6);
}
protected override Image GetNodeBitmap(Node node)
{
WorkoutPlanDTO dto = node.Tag as WorkoutPlanDTO;
if (dto != null)
{
if (dto.Status == PublishStatus.Published)
{
return(imageList1.Images["Published"]);
}
return(imageList1.Images["TrainingPlan"]);
}
return(null);
}
public static void Open(this WorkoutPlanDTO plan)
{
if (plan == null)
{
return;
}
HtmlPreviewWindow wnd = new HtmlPreviewWindow();
using (TrainingPlanHtmlExporter htmlExporter = new TrainingPlanHtmlExporter(plan.ToTrainingPlan()))
{
wnd.Fill(htmlExporter);
wnd.ShowDialog();
}
//var plan = ServiceManager.GetTrainingPlan(TrainingPlan);
}
public void TestVotePlan_Statistics()
{
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
WorkoutPlanDTO dto = (WorkoutPlanDTO)workoutPlans["test1-1"].Tag;
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteWorkoutPlan(data.Token, dto);
});
var dbProfile = Session.Get <Profile>(profile1.Id);
Assert.AreEqual(1, dbProfile.Statistics.VotingsCount);
}
public static bool AddToFavorites(this WorkoutPlanDTO plan)
{
if (plan == null || plan.IsFavorite() || plan.IsMine())
{
return(false);
}
PublishWorkoutPlanWindow dlg = new PublishWorkoutPlanWindow();
dlg.Fill(plan, false);
if (dlg.ShowDialog() == DialogResult.Cancel)
{
return(false);
}
ObjectsReposidory.ClearWorkoutPlansCache();
return(true);
}
public void TestVotePlan_DisabledSendMessage()
{
profiles[0].Settings.NotificationWorkoutPlanVoted = false;
insertToDatabase(profiles[0]);
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
WorkoutPlanDTO dto = (WorkoutPlanDTO)workoutPlans["test1-1"].Tag;
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteWorkoutPlan(data.Token, dto);
});
var messages = Session.QueryOver <Message>().Where(x => x.Receiver == profiles[0] && x.MessageType == MessageType.WorkoutPlanVoted).SingleOrDefault();
Assert.IsNull(messages);
}
protected void AddWorkoutPlan(WorkoutPlanDTO plan)
{
UserDTO author = plan.IsMine()? UserContext.CurrentProfile: plan.Profile;
string publishedDate = plan.PublishDate.HasValue ? plan.PublishDate.Value.ToLocalTime().ToString() : "";
ListViewItem item = new ListViewItem(new string[] { plan.Name,
plan.TrainingType.ToString(),
EnumLocalizer.Default.Translate(plan.Difficult),
author.UserName,
plan.Rating.ToString("F2"),
publishedDate,
EnumLocalizer.Default.Translate(plan.Purpose),
plan.DaysCount.ToString(),
Language.GetLanguage(plan.Language).DisplayName });
item.ImageKey = getNodeBitmap(plan);
item.StateImageIndex = getStateImageIndex(plan);
item.Tag = plan;
selectAGroup(item);
Items.Add(item);
}
private void selectAGroup(ListViewItem item)
{
WorkoutPlanDTO plan = (WorkoutPlanDTO)item.Tag;
if (ShowGroups)
{
if (plan.IsFavorite())
{
item.Group = Groups["Favorites"];
}
else if (plan.IsMine())
{
item.Group = Groups["Mine"];
}
else
{
item.Group = Groups["Others"];
}
}
}
public static void LoadContent(this WorkoutPlanDTO plan, bool force = false)
{
if (plan.PlanContent == null || force)
{
var newPlan = ServiceManager.GetTrainingPlan(plan.GlobalId);
plan.Author = newPlan.Author;
plan.DaysCount = newPlan.DaysCount;
plan.Difficult = newPlan.Difficult;
plan.Language = newPlan.Language;
plan.PublishDate = newPlan.PublishDate;
plan.Status = newPlan.Status;
plan.Rating = newPlan.Rating;
plan.UserRating = newPlan.UserRating;
plan.UserShortComment = newPlan.UserShortComment;
plan.Purpose = newPlan.Purpose;
plan.PlanContent = newPlan.PlanContent;
plan.TrainingType = newPlan.TrainingType;
plan.Version = newPlan.Version;
}
}
public void Fill(WorkoutPlanDTO plan, bool publish)
{
this.plan = plan;
Publish = publish;
lblPublishDescription.Visible = publish;
lblAddToFavoriteDescription.Visible = !publish;
if (Publish)
{
usrProgressIndicatorButtons1.OkButton.Image = Icons.Publish;
pictureBox1.Image = StrengthTrainingResources.BigPublish;
usrProgressIndicatorButtons1.OkButton.Text = ApplicationStrings.PublishButton;
}
else
{
Text = StrengthTrainingEntryStrings.PublishWorkoutPlanWindow_AddToFavorites_Text;
pictureBox1.Image = StrengthTrainingResources.BigAddFavorite;
usrProgressIndicatorButtons1.OkButton.Image = Icons.Favorite;
usrProgressIndicatorButtons1.OkButton.Text = ApplicationStrings.AddButton;
}
}
public void TestVotePlan_SendMessage()
{
//var profile = (ProfileDTO)profiles[0].Tag;
var profile1 = (ProfileDTO)profiles[1].Tag;
SessionData data = SecurityManager.CreateNewSession(profile1, ClientInformation);
RunServiceMethod(delegate(InternalBodyArchitectService service)
{
WorkoutPlanDTO dto = (WorkoutPlanDTO)workoutPlans["test1-1"].Tag;
dto.UserRating = 3;
dto.UserShortComment = "test";
service.VoteWorkoutPlan(data.Token, dto);
});
var messages = Session.QueryOver <Message>().Where(x => x.Receiver == profiles[0] && x.MessageType == MessageType.WorkoutPlanVoted).SingleOrDefault();
Assert.IsNotNull(messages);
Assert.AreEqual(4, messages.Content.Split(',').Length);
Assert.AreEqual(workoutPlans["test1-1"].Name, messages.Content.Split(',')[0]);
Assert.AreEqual(profile1.UserName, messages.Content.Split(',')[1]);
Assert.AreEqual(3, int.Parse(messages.Content.Split(',')[3]));
}
public WorkoutPlanEventArgs(WorkoutPlanDTO workoutPlan)
{
WorkoutPlan = workoutPlan;
}
public WorkoutPlanDTO PublishWorkoutPlan(Token token, WorkoutPlanDTO planDto)
{
throw new NotImplementedException();
}
public void WorkoutPlanFavoritesOperation(Token token, WorkoutPlanDTO planDto, FavoriteOperation operation)
{
throw new NotImplementedException();
}
public void DeleteWorkoutPlan(Token token, WorkoutPlanDTO dto)
{
throw new NotImplementedException();
}
public WorkoutPlanDTO SaveWorkoutPlan(Token token, WorkoutPlanDTO dto)
{
throw new NotImplementedException();
}
