public static bool SaveMeals(IList<Meal> meals)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
IList<bool> result = new List<bool>();
//save meals by date...add to workout dates
foreach (Meal meal in meals)
{
Meal tempMeal = client.Get<Meal>(String.Format(saveMeals, meal.MealDate));
if (tempMeal != null && tempMeal.Foods != null)
{
foreach (var food in meal.Foods)
tempMeal.Foods.Add(food);
result.Add(client.Set<Meal>(String.Format(saveMeals, meal.MealDate), tempMeal));
}
else
{
result.Add(client.Add<Meal>(String.Format(saveMeals, meal.MealDate), meal));
WorkoutClient.AddWorkoutDate(meal.MealDate.Date);
}
}
return !result.Contains(false);
}
}
}
public static Workout RetrieveWorkout(DateTime dateTime)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<Workout>(String.Format(selectWorkout,dateTime));
}
}
}
public static bool SaveExercises(IList<Event> exercises)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Add<IList<Event>>(selectExercises, exercises);
}
}
}
public static bool SaveProfile(IList<CurrentStatistic> profile)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Add<IList<CurrentStatistic>>(getProfile, profile);
}
}
}
public static bool SaveGoals(IList<ContestEventGoal> goals)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Add<IList<ContestEventGoal>>(getGoals, goals);
}
}
}
public static IList<Entities.CurrentStatistic> RetrieveProfile()
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<IList<CurrentStatistic>>(getProfile);
}
}
}
public static IList<Entities.ContestEventGoal> RetrieveGoals()
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<IList<ContestEventGoal>>(getGoals);
}
}
}
public static bool SaveFoods(IList<Food> foods)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Add<IList<Food>>(selectFoods, foods);
}
}
}
public static IList<FoodEntry> GetFoodEntries(DateTime entryDate)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<IList<FoodEntry>>(String.Format(getFoodEntries, entryDate));
}
}
}
public static Food RetrieveCompleteFood(int id)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<Food>(String.Format(completeFood, id.ToString()));
}
}
}
public static IList<DateTime> RetrieveWorkoutDates()
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<IList<DateTime>>(selectWorkoutDates);
}
}
}
public static bool AddContestEvent(ContestEvent contestEvent, int contestId)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
var contestEvents = client.Get<IList<ContestEvent>>(String.Format(selectContestEvents, contestId));
if (contestEvents != null)
contestEvents.Add(contestEvent);
return client.Set<IList<ContestEvent>>(String.Format(selectContestEvents, contestId), contestEvents);
}
}
}
public static bool AddWorkoutDate(DateTime workoutDate)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
IList<DateTime> workoutDates = client.Get<IList<DateTime>>(selectWorkoutDates);
if (!workoutDates.Contains(workoutDate))
workoutDates.Add(workoutDate);
return client.Set<IList<DateTime>>(selectWorkoutDates, workoutDates);
}
}
}
public static bool RemoveContestEvent(ContestEvent contestEvent, int contestId)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
var contestEvents = client.Get<IList<ContestEvent>>(String.Format(selectContestEvents, contestId));
if (contestEvents != null)
{
ContestEvent contestEventToRemove = contestEvents.FirstOrDefault(t => t.EventName.Equals(contestEvent.EventName));
contestEvents.Remove(contestEventToRemove);
}
return client.Set<IList<ContestEvent>>(String.Format(selectContestEvents, contestId), contestEvents);
}
}
}
public static bool RemoveContest(Contest contest)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
var contests = client.Get<IList<Contest>>(selectContests);
if (contests != null)
{
Contest contestToRemove = contests.FirstOrDefault(t => t.ContestId == contest.ContestId);
contests.Remove(contestToRemove);
}
return client.Set<IList<Contest>>(selectContests, contests);
}
}
}
public static bool SaveCompleteFood(Food food, int id)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
//check if food for that id already exists
Food existingFood = client.Get<Food>(String.Format(completeFood, id.ToString()));
if (existingFood != null)
{
return client.Set<Food>(String.Format(completeFood, id.ToString()), existingFood);
}
else
{
return client.Add<Food>(String.Format(completeFood, id.ToString()), food);
}
}
}
}
public static bool SaveFoodEntries(DateTime entryDate, IList<FoodEntry> foodEntries)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
IList<FoodEntry> existingFoodEntries = client.Get<IList<FoodEntry>>(String.Format(getFoodEntries, entryDate));
if (existingFoodEntries != null)
{
foreach (var foodEntry in foodEntries)
{
existingFoodEntries.Add(foodEntry);
}
return client.Set<IList<FoodEntry>>(String.Format(getFoodEntries, entryDate), existingFoodEntries);
}
else
return client.Add<IList<FoodEntry>>(String.Format(getFoodEntries, entryDate), foodEntries);
}
}
}
public static bool SaveWorkout(Workout workout, DateTime dateTime)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
//check if workout for that date already exists
Workout existingWorkout = client.Get<Workout>(String.Format(selectWorkout, dateTime));
if (existingWorkout != null && existingWorkout.ExerciseEntries != null)
{
foreach (var exerciseEntry in workout.ExerciseEntries)
{
existingWorkout.ExerciseEntries.Add(exerciseEntry);
}
return client.Set<Workout>(String.Format(selectWorkout, dateTime), existingWorkout);
}
else
{
AddWorkoutDate(dateTime);
return client.Add<Workout>(String.Format(selectWorkout, dateTime), workout);
}
}
}
}
public Task<bool> UpdateData(dynamic data, string CollectionName)
{
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
using (var redisCache = redisManager.GetCacheClient())
{
var keyItem = $"{DBName}:{CollectionName}:{data._id}";
redisCache.Set<string>(keyItem, JsonConvert.SerializeObject(data));
}
}
return Task.FromResult(true);
}
public Task<bool> InsertData(dynamic data, string CollectionName)
{
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetCacheClient())
{
using (var redisCache = redisManager.GetCacheClient())
{
var counter = this.GetSequence(CollectionName);
data._id = counter;
var keyItem = $"{DBName}:{CollectionName}:{counter}";
//redis.Set<ExpandoObject>(keyItem,data);
redisCache.Set<string>(keyItem, JsonConvert.SerializeObject(data));
}
}
return Task.FromResult(true);
}
public Task<bool> InsertBulkData(IEnumerable<dynamic> data, string CollectionName)
{
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetCacheClient())
{
foreach(dynamic item in data)
{
var counter = this.GetSequence(CollectionName);
item._id = counter;
var keyItem = $"{DBName}:{CollectionName}:{counter}";
redis.Set<string>(keyItem, JsonConvert.SerializeObject(item));
}
}
return Task.FromResult(true);
}
public Task<List<dynamic>> GetDataByStartId(int Limit, long StartId, string CollectionName)
{
var datas = new List<dynamic>();
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
using (var redisCache = redisManager.GetCacheClient())
{
for (long i = StartId; i <= StartId + Limit; i++)
{
var item = $"{DBName}:{CollectionName}:{i}";
string itemstr = redisCache.Get<string>(item);
if (!string.IsNullOrEmpty(itemstr))
{
var node = JsonConvert.DeserializeObject<ExpandoObject>(itemstr, new ExpandoObjectConverter());
datas.Add(node);
}
}
}
return Task.FromResult(datas);
}
}
public Task<dynamic> GetDataById(dynamic Id, string CollectionName)
{
dynamic node = null;
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
using (var redisCache = redisManager.GetCacheClient())
{
var item = $"{DBName}:{CollectionName}:{Id}";
string itemstr = redisCache.Get<string>(item);
if (!string.IsNullOrEmpty(itemstr))
node = JsonConvert.DeserializeObject<ExpandoObject>(itemstr, new ExpandoObjectConverter());
return Task.FromResult<dynamic>(node);
}
}
}
public Task<List<dynamic>> GetAllData(int Limit, string CollectionName)
{
var counter = 0;
var datas = new List<dynamic>();
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
using (var redisCache = redisManager.GetCacheClient())
{
var items = redis.ScanAllKeys($"{DBName}:{CollectionName}:*");
foreach (var item in items)
{
string node = redisCache.Get<string>(item);
if (!string.IsNullOrEmpty(node))
datas.Add(JsonConvert.DeserializeObject<ExpandoObject>(node, new ExpandoObjectConverter()));
counter++;
if (counter >= Limit) break;
}
}
return Task.FromResult(datas);
}
}
public Task<List<dynamic>> GetAllData(string CollectionName)
{
var datas = new List<dynamic>();
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
using (var redisNative = redisManager.GetCacheClient())
{
var items = redis.ScanAllKeys($"{DBName}:{CollectionName}:*");
foreach (var item in items)
{
/*
dynamic node = redisNative.Get<ExpandoObject>(item);
if (node != null)
datas.Add(node);
*/
dynamic node = redisNative.Get<string>(item);
if (!string.IsNullOrEmpty(node))
datas.Add(JsonConvert.DeserializeObject<ExpandoObject>(node, new ExpandoObjectConverter()));
}
}
return Task.FromResult(datas);
}
}
public static IList<ContestEvent> RetrieveContestEvents(int contestId)
{
using (var redisManager = new PooledRedisClientManager("[email protected]:9038"))
{
using (var client = redisManager.GetCacheClient())
{
return client.Get<IList<ContestEvent>>(String.Format(selectContestEvents, contestId));
}
}
}
