protected void Page_Load(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(Request["w"]))
{
aqufitEntities entities = new aqufitEntities();
long wid = Convert.ToInt64(Request["w"]);
// TODO: need security
Workout workout = entities.UserStreamSet.Include("WorkoutExtendeds").Include("UserSetting").OfType<Workout>().FirstOrDefault(w => w.Id == wid);
if (workout != null)
{
Affine.Data.json.Workout json = new Affine.Data.json.Workout()
{
Calories = workout.Calories,
Date = workout.Date.ToShortDateString(),
Description = workout.Description,
Distance = workout.Distance,
Duration = workout.Duration,
Emotion = workout.Emotion,
Id = workout.Id,
Title = workout.Title,
PortalKey = workout.PortalKey,
UserKey = workout.UserSetting.UserKey,
Weather = workout.Weather,
};
if (workout.WorkoutExtendeds.FirstOrDefault() != null)
{
WorkoutExtended ext = workout.WorkoutExtendeds.First();
Affine.Data.json.WorkoutExtended jsonWorkoutExtended = new Affine.Data.json.WorkoutExtended()
{
Id = ext.Id,
LatMax = ext.LatMax,
LatMin = ext.LatMin,
LngMax = ext.LngMax,
LngMin = ext.LngMin
};
Affine.Data.json.WorkoutSample[] samples = entities.WorkoutSamples.Where(s => s.WorkoutExtended.Id == ext.Id).OrderBy(s => s.SampleNumber)
.Select(s => new Affine.Data.json.WorkoutSample()
{
Date = s.Date,
Time = 0,
Distance = s.Distance,
Elevation = s.Elevation,
HeartRate = s.HeartRate,
Id = s.Id,
Lat = s.Lat,
Lng = s.Lng,
SampleNumber = s.SampleNumber
}).ToArray();
foreach (Affine.Data.json.WorkoutSample s in samples)
{
s.Time = s.Date.Ticks;
}
jsonWorkoutExtended.WorkoutSamples = samples;
json.WorkoutExtended = jsonWorkoutExtended;
}
JavaScriptSerializer jserializer = new JavaScriptSerializer();
Response.Write( jserializer.Serialize(json) );
}
}
else if (Request["ed"] != null && Request["u"] != null && Request["sd"] != null)
{
long uid = Convert.ToInt64(Request["u"]);
DateTime endDate = DateTime.Parse(Request["ed"]);
DateTime startDate = DateTime.Parse(Request["sd"]).ToUniversalTime();
endDate = endDate.AddDays(1).ToUniversalTime();
aqufitEntities entities = new aqufitEntities();
IList<Affine.Data.json.Workout> ret = new List<Affine.Data.json.Workout>();
IList<Workout> workoutList = entities.UserStreamSet.Include("UserSetting").OfType<Workout>().
Where(w => w.UserSetting.UserKey == uid && w.Date.CompareTo(endDate) <= 0 && w.Date.CompareTo(startDate) >= 0 ).OrderByDescending(w => w.Date).ToList();
workoutList = workoutList.Reverse().ToList();
foreach (Workout workout in workoutList)
{
Affine.Data.json.Workout json = new Affine.Data.json.Workout()
{
Calories = workout.Calories,
TimeStamp = workout.TimeStamp,
Date = workout.Date.ToShortDateString(),
Description = workout.Description,
Distance = workout.Distance,
Duration = workout.Duration,
Emotion = workout.Emotion,
Id = workout.Id,
Title = workout.Title,
PortalKey = workout.PortalKey,
UserKey = workout.UserSetting.UserKey,
Weather = workout.Weather,
DataSrc = workout.DataSrc
};
ret.Add(json);
}
// TODO: need a case for empty data
JavaScriptSerializer jserializer = new JavaScriptSerializer();
Response.Write(jserializer.Serialize(ret.ToArray()));
}
else
{
Response.Write("{ERROR:'invalid request'}");
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CA - this will need to be cleaned up a lot.. but here is the iteration one version
// ** People can view workouts in 4 modes (everyone, watchlist, friends, just them)
// -In the case of running, cycling, swimming, and STANDARD crossfit Wods... we are going to
// be storing peoples best times for (distance rnages) and standard wods... so in these cases
// we can shorted the query time when we do an "everyone" query
// -Watch list and friends we do the work of getting every time that person did the workout.. not just
// there best times.
// -Same for the (you only) view
//
private void LoadFlexDataForWorkout(Workout workout, Affine.Utils.ConstsUtil.GraphContext context)
{
Affine.Data.Managers.IDataManager dataManager = Affine.Data.Managers.LINQ.DataManager.Instance;
JavaScriptSerializer serializer = new JavaScriptSerializer();
// onload we send friend, watch, and group member data that is needed to the app
aqufitEntities entities = new aqufitEntities();
IList <long> friendIds = entities.UserFriends.Where(f => (f.SrcUserSettingKey == ProfileSettings.Id || f.DestUserSettingKey == ProfileSettings.Id)).Select(f => (f.SrcUserSettingKey == ProfileSettings.Id ? f.DestUserSettingKey : f.SrcUserSettingKey)).ToList();
friendIds.Add(ProfileSettings.Id);
// send the persons profile through
var profile = new { UserName = ProfileSettings.UserName, Id = ProfileSettings.Id, FirstName = ProfileSettings.UserFirstName, LastName = ProfileSettings.UserLastName };
hiddenProfileJson.Value = serializer.Serialize(profile);
var friends = entities.UserSettings.OfType <User>().Where(LinqUtils.BuildContainsExpression <User, long>(s => s.Id, friendIds)).Select(u => new { Id = u.Id, Un = u.UserName, Fn = u.UserFirstName, Ln = u.UserLastName }).ToArray();
hiddenFriendJson.Value = serializer.Serialize(friends);
// get groups
long[] groupIds = entities.UserFriends.Where(f => (f.SrcUserSettingKey == ProfileSettings.Id || f.DestUserSettingKey == ProfileSettings.Id) && f.Relationship > 0).Select(f => f.SrcUserSettingKey == ProfileSettings.Id ? f.DestUserSettingKey : f.SrcUserSettingKey).ToArray();
UserSettings[] groupList = entities.UserSettings.OfType <Group>().Where(LinqUtils.BuildContainsExpression <UserSettings, long>(us => us.Id, groupIds)).OrderBy(f => f.UserName).ToArray();
var groups = entities.UserSettings.OfType <Group>().Where(LinqUtils.BuildContainsExpression <Group, long>(s => s.Id, groupIds)).Select(u => new { Id = u.Id, Un = u.UserName }).ToArray();
hiddenGroupJson.Value = serializer.Serialize(groups);
// next we load the workout compare to all (friends)
Affine.WebService.StreamService ss = new WebService.StreamService();
//hiddenWorkout.Value = ss.getWorkout(workout.Id);
Affine.Data.json.Workout jsonWorkout = dataManager.workoutToJsonWorkout(workout);
Affine.Data.json.WOD wod = null;
Affine.Data.json.WorkoutData[] jsonWorkoutData = null;
//var workoutJson = new { Id = workout.Id, WorkoutTypeKey = workout.WorkoutTypeKey, Title = workout.Title, Date = workout.Date.ToLocalTime().ToShortDateString(), DataSrc = workout.DataSrc };
Affine.Utils.UnitsUtil.MeasureUnit weight = base.WeightUnits;
if (workout.WorkoutTypeKey == (int)Affine.Utils.WorkoutUtil.WorkoutType.CROSSFIT)
{
if (context == Utils.ConstsUtil.GraphContext.DEFAULT)
{ // default context for crossfit is the watchlist
context = Utils.ConstsUtil.GraphContext.WATCHLIST;
}
// if this is a crossfit workout
// we want to get ALL the same WoDs for you and your friends
IQueryable <Workout> workoutDataQuery = context == Utils.ConstsUtil.GraphContext.EVERYONE ?
entities.UserStreamSet.Include("UserSettings").OfType <Workout>().Where(w => w.WOD.Id == workout.WOD.Id).AsQueryable()
:
context == Utils.ConstsUtil.GraphContext.WATCHLIST ?
entities.UserStreamSet.Include("UserSettings").OfType <Workout>().Where(w => w.WOD.Id == workout.WOD.Id).Where(LinqUtils.BuildContainsExpression <Workout, long>(w => w.UserSetting.Id, friendIds)).AsQueryable()
:
context == Utils.ConstsUtil.GraphContext.FRIENDS ?
entities.UserStreamSet.Include("UserSettings").OfType <Workout>().Where(w => w.WOD.Id == workout.WOD.Id).Where(LinqUtils.BuildContainsExpression <Workout, long>(w => w.UserSetting.Id, friendIds)).AsQueryable()
:
entities.UserStreamSet.Include("UserSettings").OfType <Workout>().Where(w => w.WOD.Id == workout.WOD.Id && w.UserSetting.Id == ProfileSettings.Id).AsQueryable();
var workoutData = workoutDataQuery.Select(w => new { Id = w.Id, UsKey = w.UserSetting.Id, Un = w.UserSetting.UserName, T = w.Duration, S = w.Score, M = w.Max, Rx = w.RxD, D = w.Date }).ToArray();
wod = new Affine.Data.json.WOD()
{
Id = workout.WOD.Id, Standard = workout.WOD.Standard, Type = workout.WOD.WODType.Id, Name = workout.WOD.Name, Description = workout.WOD.Description
};
if (wod.Type == (int)Affine.Utils.WorkoutUtil.WodType.TIMED)
{ // time in sec
jsonWorkoutData = workoutData.OrderByDescending(w => w.T).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.Un + "_" + w.Id, Id = w.Id, S = (double)w.T, Un = w.Un, D = w.D.ToLocalTime().ToShortDateString(), Rx = (w.Rx.HasValue ? w.Rx.Value : false)
}).ToArray();
}
else if (wod.Type == (int)Affine.Utils.WorkoutUtil.WodType.MAX_WEIGHT)
{
jsonWorkoutData = workoutData.OrderByDescending(w => w.M).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.Un + "_" + w.Id, Id = w.Id, S = Math.Round(Affine.Utils.UnitsUtil.systemDefaultToUnits(Convert.ToDouble(w.M), weight), 2), Un = w.Un, D = w.D.ToLocalTime().ToShortDateString(), Rx = (w.Rx.HasValue ? w.Rx.Value : false)
}).ToArray();
}
else
{
jsonWorkoutData = workoutData.OrderByDescending(w => w.S).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.Un + "_" + w.Id, Id = w.Id, S = Math.Round(Convert.ToDouble(w.S), 2), Un = w.Un, D = w.D.ToLocalTime().ToShortDateString(), Rx = (w.Rx.HasValue ? w.Rx.Value : false)
}).ToArray();
}
}
else
{ // for now this will handle "running, swimming, walking, cycling"
if (context == Utils.ConstsUtil.GraphContext.DEFAULT)
{
if (workout.DataSrc == (short)Utils.WorkoutUtil.DataSrc.MANUAL_NO_MAP || workout.DataSrc == (short)Utils.WorkoutUtil.DataSrc.MANUAL_WITH_MAP)
{
context = Utils.ConstsUtil.GraphContext.EVERYONE;
}
else if (workout.DataSrc == (short)Utils.WorkoutUtil.DataSrc.NIKE_NO_MAP)
{
context = Utils.ConstsUtil.GraphContext.WATCHLIST;
}
// TODO: not sure about this one....
/*
* else if (workout.DataSrc == (short)Utils.WorkoutUtil.DataSrc.MANUAL_WITH_MAP)
* { // TODO: ?? this is a special case that we want to compare all the times of people that have logged a run for the route.
* long mapRouteKey = entities.UserStreamSet.OfType<Workout>().Where(w => w.Id == workout.Id).Select(w => w.WorkoutExtendeds.FirstOrDefault().MapRoute.Id).FirstOrDefault();
* IQueryable<Workout> workoutQuery = entities.WorkoutExtendeds.Include("UserStream").Where(we => we.MapRoute != null && we.MapRoute.Id == mapRouteKey).Select(we => we.UserStream).OfType<Workout>().OrderBy(w => w.Duration).Take(5000);
* workoutQuery.Select(w => w.UserSetting).ToArray(); // hydrate.. not working above so do it here.
* Workout[] data = workoutQuery.ToArray();
* var wd = data.OrderByDescending(w => w.Duration).Select(w => new
* {
* UId = w.UserSetting.UserName + "_" + w.Id,
* Id = w.Id,
* S = w.Duration,
* Un = w.UserSetting.UserName,
* D = w.Date.ToLocalTime().ToShortDateString()
* }).ToArray();
* var ret = new { WOD = new { }, WorkoutData = wd, Workout = workoutJson, Context = (int)context };
* hiddenWorkoutData.Value = serializer.Serialize(ret);
* }*/
else
{
context = Utils.ConstsUtil.GraphContext.ME;
}
}
if (context == Utils.ConstsUtil.GraphContext.EVERYONE)
{ // we want to compare achievments...
IQueryable <Workout> workoutQuery = entities.Achievements.Include("UserStream").Include("UserStream.UserSetting").Where(a =>
a.AchievementType.WorkoutType.Id == workout.WorkoutTypeKey &&
workout.Distance >= a.AchievementType.DistanceRangeA &&
workout.Distance < a.AchievementType.DistanceRangeB).Take(5000).Select(a => a.UserStream).OfType <Workout>().AsQueryable();
workoutQuery = workoutQuery.Union(entities.UserStreamSet.OfType <Workout>().Where(w => w.Id == workout.Id));
workoutQuery.Select(w => w.UserSetting).ToArray(); // hydrate.. not working above so do it here.
Workout[] data = workoutQuery.ToArray();
jsonWorkoutData = data.OrderByDescending(w => w.Duration).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.UserSetting.UserName + "_" + w.Id,
Id = w.Id,
S = w.Duration.Value,
Un = w.UserSetting.UserName,
D = w.Date.ToLocalTime().ToShortDateString()
}).ToArray();
}
else if (context == Utils.ConstsUtil.GraphContext.WATCHLIST || context == Utils.ConstsUtil.GraphContext.FRIENDS)
{
IQueryable <Workout> workoutQuery = entities.Achievements.Include("UserStream").Include("UserStream.UserSetting").Where(a =>
a.AchievementType.WorkoutType.Id == workout.WorkoutTypeKey &&
workout.Distance >= a.AchievementType.DistanceRangeA &&
workout.Distance < a.AchievementType.DistanceRangeB).
Where(LinqUtils.BuildContainsExpression <Achievement, long>(a => a.UserSetting.Id, friendIds)).Take(5000).Select(a => a.UserStream).OfType <Workout>().AsQueryable();
workoutQuery = workoutQuery.Union(entities.UserStreamSet.OfType <Workout>().Where(w => w.Id == workout.Id));
workoutQuery.Select(w => w.UserSetting).ToArray(); // hydrate.. not working above so do it here.
Workout[] data = workoutQuery.ToArray();
jsonWorkoutData = data.OrderByDescending(w => w.Duration).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.UserSetting.UserName + "_" + w.Id,
Id = w.Id,
S = w.Duration.Value,
Un = w.UserSetting.UserName,
D = w.Date.ToLocalTime().ToShortDateString()
}).ToArray();
}
else if (context == Utils.ConstsUtil.GraphContext.ME) // this is just you for the ranges.. since no map data
{
IQueryable <Workout> workoutQuery = entities.Achievements.Include("UserStream").Include("UserStream.UserSetting").Where(a => a.UserSetting.Id == ProfileSettings.Id &&
a.AchievementType.WorkoutType.Id == workout.WorkoutTypeKey &&
workout.Distance >= a.AchievementType.DistanceRangeA &&
workout.Distance < a.AchievementType.DistanceRangeB).
Take(5000).Select(a => a.UserStream).OfType <Workout>().AsQueryable();
workoutQuery = workoutQuery.Union(entities.UserStreamSet.OfType <Workout>().Where(w => w.Id == workout.Id));
workoutQuery.Select(w => w.UserSetting).ToArray(); // hydrate.. not working above so do it here.
Workout[] data = workoutQuery.ToArray();
jsonWorkoutData = data.OrderByDescending(w => w.Duration).Select(w => new Affine.Data.json.WorkoutData()
{
UId = w.UserSetting.UserName + "_" + w.Id,
Id = w.Id,
S = w.Duration.Value,
Un = w.UserSetting.UserName,
D = w.Date.ToLocalTime().ToShortDateString()
}).ToArray();
}
}
var retWorkout = new { WOD = wod, WorkoutData = jsonWorkoutData, Workout = jsonWorkout, Context = (int)context };
hiddenWorkoutData.Value = serializer.Serialize(retWorkout);
}
public string getWorkout(long wid)
{
aqufitEntities entities = new aqufitEntities();
Workout workout = entities.UserStreamSet.Include("WorkoutExtendeds").Include("WorkoutExtendeds.MapRoute").Include("UserSetting").OfType<Workout>().FirstOrDefault(w => w.Id == wid);
if (workout != null)
{
Affine.Data.json.Workout json = new Affine.Data.json.Workout()
{
Calories = workout.Calories,
Date = workout.Date.ToLocalTime().ToShortDateString(),
Description = workout.Description,
Distance = workout.Distance,
Duration = workout.Duration,
Emotion = workout.Emotion,
Id = workout.Id,
Title = workout.Title,
PortalKey = workout.PortalKey,
UserKey = workout.UserSetting.UserKey,
Weather = workout.Weather,
DataSrc = workout.DataSrc,
WorkoutTypeKey = Convert.ToInt64( workout.WorkoutTypeKey )
};
if (workout.WorkoutExtendeds.FirstOrDefault() != null)
{
WorkoutExtended ext = workout.WorkoutExtendeds.First();
Affine.Data.json.WorkoutExtended jsonWorkoutExtended = new Affine.Data.json.WorkoutExtended()
{
Id = ext.Id,
LatMax = ext.LatMax,
LatMin = ext.LatMin,
LngMax = ext.LngMax,
LngMin = ext.LngMin
};
Affine.Data.json.WorkoutSample[] samples = entities.WorkoutSamples.Where(s => s.WorkoutExtended.Id == ext.Id).OrderBy(s => s.SampleNumber)
.Select(s => new Affine.Data.json.WorkoutSample()
{
Date = s.Date,
Time = 0,
Distance = s.Distance,
Elevation = s.Elevation,
HeartRate = s.HeartRate,
Id = s.Id,
Lat = s.Lat,
Lng = s.Lng,
SampleNumber = s.SampleNumber
}).ToArray();
foreach (Affine.Data.json.WorkoutSample s in samples)
{
s.Time = s.Date.Ticks;
}
jsonWorkoutExtended.WorkoutSamples = samples;
json.WorkoutExtended = jsonWorkoutExtended;
if (ext.MapRoute != null)
{
MapRoute mr = ext.MapRoute;
Affine.Data.json.MapRoute jsonMapRoute = new Affine.Data.json.MapRoute()
{
Id = mr.Id,
LatMax = mr.LatMax,
LatMin = mr.LatMin,
LngMax = mr.LngMax,
LngMin = mr.LngMin,
City = mr.City,
Name = mr.Name,
PortalKey = mr.PortalKey,
Rating = mr.Rating,
RouteDistance = mr.RouteDistance,
UserKey = workout.UserSetting.Id,
Region = mr.Region
};
Affine.Data.json.MapRoutePoint[] points = entities.MapRoutePoints.Where( mp => mp.MapRoute.Id == mr.Id ).OrderBy( mp => mp.Order ).Select(p => new Affine.Data.json.MapRoutePoint()
{
Id = p.Id,
Lat = p.Lat,
Lng = p.Lng,
Order = p.Order
}).ToArray();
jsonMapRoute.MapRoutePoints = points;
json.WorkoutExtended.MapRoute = jsonMapRoute;
}
}
JavaScriptSerializer jserializer = new JavaScriptSerializer();
return jserializer.Serialize(json);
}
return "";
}
protected void Page_Load(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(Request["w"]))
{
aqufitEntities entities = new aqufitEntities();
long wid = Convert.ToInt64(Request["w"]);
// TODO: need security
Workout workout = entities.UserStreamSet.Include("WorkoutExtendeds").Include("UserSetting").OfType <Workout>().FirstOrDefault(w => w.Id == wid);
if (workout != null)
{
Affine.Data.json.Workout json = new Affine.Data.json.Workout()
{
Calories = workout.Calories,
Date = workout.Date.ToShortDateString(),
Description = workout.Description,
Distance = workout.Distance,
Duration = workout.Duration,
Emotion = workout.Emotion,
Id = workout.Id,
Title = workout.Title,
PortalKey = workout.PortalKey,
UserKey = workout.UserSetting.UserKey,
Weather = workout.Weather,
};
if (workout.WorkoutExtendeds.FirstOrDefault() != null)
{
WorkoutExtended ext = workout.WorkoutExtendeds.First();
Affine.Data.json.WorkoutExtended jsonWorkoutExtended = new Affine.Data.json.WorkoutExtended()
{
Id = ext.Id,
LatMax = ext.LatMax,
LatMin = ext.LatMin,
LngMax = ext.LngMax,
LngMin = ext.LngMin
};
Affine.Data.json.WorkoutSample[] samples = entities.WorkoutSamples.Where(s => s.WorkoutExtended.Id == ext.Id).OrderBy(s => s.SampleNumber)
.Select(s => new Affine.Data.json.WorkoutSample()
{
Date = s.Date,
Time = 0,
Distance = s.Distance,
Elevation = s.Elevation,
HeartRate = s.HeartRate,
Id = s.Id,
Lat = s.Lat,
Lng = s.Lng,
SampleNumber = s.SampleNumber
}).ToArray();
foreach (Affine.Data.json.WorkoutSample s in samples)
{
s.Time = s.Date.Ticks;
}
jsonWorkoutExtended.WorkoutSamples = samples;
json.WorkoutExtended = jsonWorkoutExtended;
}
JavaScriptSerializer jserializer = new JavaScriptSerializer();
Response.Write(jserializer.Serialize(json));
}
}
else if (Request["ed"] != null && Request["u"] != null && Request["sd"] != null)
{
long uid = Convert.ToInt64(Request["u"]);
DateTime endDate = DateTime.Parse(Request["ed"]);
DateTime startDate = DateTime.Parse(Request["sd"]).ToUniversalTime();
endDate = endDate.AddDays(1).ToUniversalTime();
aqufitEntities entities = new aqufitEntities();
IList <Affine.Data.json.Workout> ret = new List <Affine.Data.json.Workout>();
IList <Workout> workoutList = entities.UserStreamSet.Include("UserSetting").OfType <Workout>().
Where(w => w.UserSetting.UserKey == uid && w.Date.CompareTo(endDate) <= 0 && w.Date.CompareTo(startDate) >= 0).OrderByDescending(w => w.Date).ToList();
workoutList = workoutList.Reverse().ToList();
foreach (Workout workout in workoutList)
{
Affine.Data.json.Workout json = new Affine.Data.json.Workout()
{
Calories = workout.Calories,
TimeStamp = workout.TimeStamp,
Date = workout.Date.ToShortDateString(),
Description = workout.Description,
Distance = workout.Distance,
Duration = workout.Duration,
Emotion = workout.Emotion,
Id = workout.Id,
Title = workout.Title,
PortalKey = workout.PortalKey,
UserKey = workout.UserSetting.UserKey,
Weather = workout.Weather,
DataSrc = workout.DataSrc
};
ret.Add(json);
}
// TODO: need a case for empty data
JavaScriptSerializer jserializer = new JavaScriptSerializer();
Response.Write(jserializer.Serialize(ret.ToArray()));
}
else
{
Response.Write("{ERROR:'invalid request'}");
}
}
