IEnumerator LoadLocalJson()
{
//Debug.Log("111");
WWW www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/CriteriaInfo.json");
yield return(www);
Debug.Log(www.text);
ListCritera = JsonConvert.DeserializeObject <CriteriaList>(www.text);
www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/MachineInfo.json");
yield return(www);
Debug.Log(www.text);
ListMachine = JsonConvert.DeserializeObject <MachineList>(www.text);
www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/SubCriteriaInfo.json");
yield return(www);
Debug.Log(www.text);
ListSubCriteria = JsonConvert.DeserializeObject <SubCriteriaList>(www.text);
www = new WWW(Application.dataPath + "/Resources/ConfigProfiles/AspectInfo.json");
yield return(www);
Debug.Log(www.text);
ListAspect = JsonConvert.DeserializeObject <AspectList>(www.text);
OnInitStatisticsData();
}
public List <TrainingExercise> FindTrainingExercise(CriteriaList <TrainingExerciseCriteria> trainingExerciseCriteriaList)
{
var trainingExercises = _trainingExerciseModule.Find(trainingExerciseCriteriaList);
FindTrainingExerciseSet(trainingExercises);
return(trainingExercises);
}
/// <summary>
/// Event thrown when Right Arrow is touched
/// Switch criteria and save current one
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void OnRightButtonClickedAsync(object sender, EventArgs e)
{
SaveCriteria();
int index = CriteriaList.IndexOf(CurrentCriteria);
Criteria leftCriteria = CriteriaList[index + 1];
changeCriteria(leftCriteria, index + 1);
}
public static async Task <List <TrainingWeek> > FindTrainingWeeksAsync(CriteriaList <TrainingWeekCriteria> trainingWeekCriteriaList, TrainingWeekScenario trainingWeekScenario)
{
if (trainingWeekCriteriaList == null)
{
return(null);
}
var trainingWeekFinder = new TrainingWeekFinder();
trainingWeekFinder.TrainingWeekCriteriaList = trainingWeekCriteriaList;
trainingWeekFinder.TrainingWeekScenario = trainingWeekScenario;
return(await HttpConnector.Instance.PostAsync <TrainingWeekFinder, List <TrainingWeek> > ("Api/TrainingWeeks/Find", trainingWeekFinder));
}
public List <TrainingWeek> FindTrainingWeek(CriteriaList <TrainingWeekCriteria> trainingWeekCriteriaList, TrainingWeekScenario trainingWeekScenario)
{
List <TrainingWeek> trainingWeeks = _trainingWeekModule.Find(trainingWeekCriteriaList);
if (trainingWeekScenario != null && trainingWeekScenario.ManageTrainingDay)
{
foreach (TrainingWeek trainingJournal in trainingWeeks)
{
CompleteTrainingWeekWithTrainingDay(trainingJournal, trainingWeekScenario.TrainingDayScenario);
}
}
return(trainingWeeks);
}
public void LoadAllData()
{
//StartCoroutine(LoadLocalJson());
TextAsset str1 = Resources.Load <TextAsset>("ConfigProfiles/CriteriaInfo");
TextAsset str2 = Resources.Load <TextAsset>("ConfigProfiles/MachineInfo");
TextAsset str3 = Resources.Load <TextAsset>("ConfigProfiles/SubCriteriaInfo");
TextAsset str4 = Resources.Load <TextAsset>("ConfigProfiles/AspectInfo");
ListCritera = JsonConvert.DeserializeObject <CriteriaList>(str1.text);
ListMachine = JsonConvert.DeserializeObject <MachineList>(str2.text);
ListSubCriteria = JsonConvert.DeserializeObject <SubCriteriaList>(str3.text);
ListAspect = JsonConvert.DeserializeObject <AspectList>(str4.text);
OnInitStatisticsData();
}
/// <summary>
/// Find datas
/// </summary>
/// <returns></returns>
public List<TrainingWeek> Find(CriteriaList<TrainingWeekCriteria> trainingWeekCriteriaList = null)
{
List<TrainingWeek> resultList = null;
IQueryable<TrainingWeekRow> rowList = _dbContext.TrainingWeek;
CriteriaTransformer.CompleteQuery(ref rowList, trainingWeekCriteriaList);
rowList = rowList.OrderBy(t => t.UserId).OrderByDescending(t => t.Year).ThenByDescending(t => t.WeekOfYear);
if (rowList != null && rowList.Count() > 0)
{
resultList = new List<TrainingWeek>();
foreach (var trainingJournalRow in rowList)
{
resultList.Add(TrainingWeekTransformer.ToBean(trainingJournalRow));
}
}
return resultList;
}
internal List <TrainingDay> FindTrainingDay(TUnitType userUnit, TrainingDayCriteria trainingDayCriteria, TrainingDayScenario trainingDayScenario)
{
var trainingDays = _trainingDayModule.Find(userUnit, trainingDayCriteria);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise && trainingDays != null && trainingDays.Count > 0)
{
var criteriaList = new CriteriaList <TrainingExerciseCriteria>();
string userId = null;
foreach (var trainingDay in trainingDays)
{
criteriaList.Add(CreateTrainingExerciseCriteria(trainingDay));
if (userId == null)
{
userId = trainingDay.UserId;
}
}
var trainingExerciseList = _trainingExercisesService.FindTrainingExercise(criteriaList);
if (trainingExerciseList != null)
{
foreach (var trainingDay in trainingDays)
{
foreach (var trainingExercise in trainingExerciseList)
{
if (trainingExercise != null &&
(trainingDay.UserId != null && trainingDay.UserId == trainingExercise.UserId) &&
(trainingDay.Year == trainingExercise.Year) &&
(trainingDay.WeekOfYear == trainingExercise.WeekOfYear) &&
(trainingDay.DayOfWeek == trainingExercise.DayOfWeek) &&
(trainingDay.TrainingDayId == trainingExercise.TrainingDayId))
{
if (trainingDay.TrainingExercises == null)
{
trainingDay.TrainingExercises = new List <TrainingExercise>();
}
trainingDay.TrainingExercises.Add(trainingExercise);
}
}
}
}
}
return(trainingDays);
}
/// <summary>
/// Find datas
/// </summary>
/// <returns></returns>
public List <TrainingExerciseSet> Find(CriteriaList <TrainingExerciseSetCriteria> trainingExerciseSetCriteriaList = null)
{
List <TrainingExerciseSet> resultList = null;
IQueryable <TrainingExerciseSetRow> rowList = _dbContext.TrainingExerciseSet;
CriteriaTransformer.CompleteQuery(ref rowList, trainingExerciseSetCriteriaList);
rowList = rowList.OrderBy(t => t.TrainingExerciseId);
if (rowList != null)
{
foreach (var row in rowList)
{
if (resultList == null)
{
resultList = new List <TrainingExerciseSet>();
}
resultList.Add(TrainingExerciseSetTransformer.ToBean(row));
}
}
return(resultList);
}
/// <summary>
/// Find datas
/// </summary>
/// <returns></returns>
public List <TrainingWeek> Find(CriteriaList <TrainingWeekCriteria> trainingWeekCriteriaList = null)
{
List <TrainingWeek> resultList = null;
IQueryable <TrainingWeekRow> rowList = _dbContext.TrainingWeek;
CriteriaTransformer.CompleteQuery(ref rowList, trainingWeekCriteriaList);
rowList = rowList.OrderBy(t => t.UserId).OrderByDescending(t => t.Year).ThenByDescending(t => t.WeekOfYear);
if (rowList != null)
{
foreach (var trainingJournalRow in rowList)
{
if (resultList == null)
{
resultList = new List <TrainingWeek>();
}
resultList.Add(TrainingWeekTransformer.ToBean(trainingJournalRow));
}
}
return(resultList);
}
private List <TrainingExercise> FindTrainingExerciseSet(List <TrainingExercise> trainingExercises)
{
if (trainingExercises != null && trainingExercises.Count > 0)
{
var criteriaList = new CriteriaList <TrainingExerciseSetCriteria>();
foreach (var trainingExercise in trainingExercises)
{
criteriaList.Add(CreateTrainingExerciseSetCriteria(trainingExercise));
}
var trainingExerciseSetList = _trainingExerciseSetModule.Find(criteriaList);
if (trainingExerciseSetList != null)
{
foreach (var trainingExerciseSet in trainingExerciseSetList)
{
foreach (var trainingExercise in trainingExercises)
{
if (trainingExerciseSet != null &&
(trainingExercise.UserId != null && trainingExercise.UserId == trainingExerciseSet.UserId) &&
(trainingExercise.Year == trainingExerciseSet.Year) &&
(trainingExercise.WeekOfYear == trainingExerciseSet.WeekOfYear) &&
(trainingExercise.DayOfWeek == trainingExerciseSet.DayOfWeek) &&
(trainingExercise.TrainingDayId == trainingExerciseSet.TrainingDayId) &&
(trainingExercise.Id == trainingExerciseSet.TrainingExerciseId))
{
if (trainingExercise.TrainingExerciseSets == null)
{
trainingExercise.TrainingExerciseSets = new List <TrainingExerciseSet>();
}
trainingExercise.TrainingExerciseSets.Add(trainingExerciseSet);
}
}
}
}
}
return(trainingExercises);
}
/// <summary>
/// Gets a list of records based on criteriaList passed in. Supports OR searches as well.
/// If a sub-object search is done, HQL will be built.
/// </summary>
/// <typeparam name="T">Business entity object type</typeparam>
/// <typeparam name="objectID">object identity</typeparam>
/// <returns>Business entity object</returns>
public List <T> GetTypeSafeList <T>(CriteriaList criteriaList) where T : new()
{
bool doHQLSearch = false;
foreach (Criteria criteria in criteriaList)
{
Predicate <Criterion> filterBySubObject = new Predicate <Criterion>(buildSubObjectList);
Predicate <SortCriterion> sortBySubObject = new Predicate <SortCriterion>(buildSubObjectList);
List <Criterion> subObjectCriterionList = criteria.FindAll(filterBySubObject);
List <Criterion> logicalOperatorCriterionList = criteria.FindAll(delegate(Criterion lci) { return(lci.LogicalOperator.Equals(LogicalOperatorType.OR)); });
if (criteriaList.SortCriteria != null && criteriaList.SortCriteria.Count > 0)
{
List <SortCriterion> subObjectSortCriterionList = criteriaList.SortCriteria.FindAll(sortBySubObject);
if (subObjectSortCriterionList.Count > 0)
{
doHQLSearch = true;
break;
}
}
if (subObjectCriterionList.Count > 0 || logicalOperatorCriterionList.Count > 0)
{
doHQLSearch = true;
break;
}
}
//No sub object searches. Use ExecCriteria method
if (doHQLSearch == false)
{
List <CriteriaItem> critList = new List <CriteriaItem>();
foreach (Criteria criteria in criteriaList)
{
foreach (Criterion criterion in criteria)
{
switch (criterion.RelationalOperator)
{
case RelationalOperatorType.EQUALS:
case RelationalOperatorType.GREATERTHAN:
case RelationalOperatorType.LESSTHAN:
case RelationalOperatorType.GREATERTHAN_EQUAL:
case RelationalOperatorType.LESSTHAN_EQUAL:
critList.Add(new CriteriaItem(criterion.FieldName, criterion.FieldValue, (criteriaType)criterion.RelationalOperator));
break;
case RelationalOperatorType.STARTSWITH:
critList.Add(new CriteriaItem(criterion.FieldName, criterion.FieldValue, criteriaType.Like, ASA.Common.MatchMode.Start));
break;
case RelationalOperatorType.ENDSWITH:
critList.Add(new CriteriaItem(criterion.FieldName, criterion.FieldValue, criteriaType.Like, ASA.Common.MatchMode.End));
break;
case RelationalOperatorType.CONTAINS:
critList.Add(new CriteriaItem(criterion.FieldName, criterion.FieldValue, criteriaType.Like, ASA.Common.MatchMode.Anywhere));
break;
case RelationalOperatorType.IN:
List <object> inList = new List <object>();
string separator = ",";
string[] stringList = criterion.FieldValue.ToString().Split(separator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
for (int x = 0; x < stringList.Length; x++)
{
inList.Add((object)stringList[x]);
}
critList.Add(new CriteriaItem(criterion.FieldName, inList));
break;
}
}
}
IList <SortCriterion> sortList = null;
if (criteriaList.SortCriteria != null && criteriaList.SortCriteria.Count > 0)
{
sortList = (IList <SortCriterion>)criteriaList.SortCriteria;
}
//set rows to return to -1 so all rows matching criteria are returned.
// If MaxEntities is 0 or negative number return all rows matching the criteria
if (criteriaList.MaxEntities < 1)
{
return(ExecCriteria <T>(sortList, critList, -1));
}
else
{
return(ExecCriteria <T>(sortList, critList, criteriaList.MaxEntities));
}
}
else
{
return(ExecuteHQLSearch <T>(criteriaList));
}
}
public static async Task <bool> SynchronizeTrainingWeeksAsync(SQLiteConnection dbContext)
{
bool result = false;
try
{
//Synchronize TrainingWeek with server (with trainingday and exercise)
var criteria = new TrainingWeekCriteria();
criteria.UserId = new StringCriteria()
{
Equal = UserData.Instance.UserInfo.UserId
};
TrainingWeekScenario trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = false
};
var trainingWeekService = new TrainingWeekService(dbContext);
//retreive local data
var localTrainingWeekList = trainingWeekService.FindTrainingWeek(criteria, trainingWeekScenario);
//retreive online data
var criteriaList = new CriteriaList <TrainingWeekCriteria>()
{
criteria
};
var onlineTrainingWeekList = await TrainingWeekWebService.FindTrainingWeeksAsync(criteriaList, trainingWeekScenario);
bool found;
//Delete local data if not found on server
if (localTrainingWeekList != null)
{
var deletedTrainingWeekList = new List <TrainingWeek>();
foreach (var localTrainingWeek in localTrainingWeekList)
{
found = false;
if (onlineTrainingWeekList != null)
{
foreach (var onlineTrainingWeek in onlineTrainingWeekList)
{
if (TrainingWeekKey.IsEqualByKey(onlineTrainingWeek, localTrainingWeek))
{
found = true;
break;
}
}
}
if (!found)
{
deletedTrainingWeekList.Add(localTrainingWeek);
}
}
if (deletedTrainingWeekList.Count > 0)
{
var deletedTrainingWeekKeyList = new List <TrainingWeekKey>();
foreach (var key in deletedTrainingWeekList)
{
deletedTrainingWeekKeyList.Add(key);
}
//Delete in local database
trainingWeekService.DeleteTrainingWeekList(deletedTrainingWeekKeyList);
foreach (var deleteTrainingWeek in deletedTrainingWeekList)
{
localTrainingWeekList.Remove(deleteTrainingWeek);
}
}
}
//if modification date online != local, get full trainingWeek online data and save them on local database
var synchronizeTrainingWeekList = new List <TrainingWeek>();
if (onlineTrainingWeekList != null)
{
foreach (var onlineTrainingWeek in onlineTrainingWeekList)
{
found = false;
if (localTrainingWeekList != null)
{
foreach (var localTrainingWeek in localTrainingWeekList)
{
//Same trainingWeek
if (TrainingWeekKey.IsEqualByKey(onlineTrainingWeek, localTrainingWeek))
{
if (onlineTrainingWeek.ModificationDate.ToUniversalTime() != localTrainingWeek.ModificationDate.ToUniversalTime()) //ToUniversalTime for security...
{
synchronizeTrainingWeekList.Add(onlineTrainingWeek);
}
found = true;
break;
}
}
}
if (!found)
{
synchronizeTrainingWeekList.Add(onlineTrainingWeek);
}
}
}
//Synchronize all trainingWeek data
trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true,
TrainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
}
};
if (synchronizeTrainingWeekList.Count > 0)
{
criteriaList.Clear();
foreach (var trainingWeek in synchronizeTrainingWeekList)
{
criteria = new TrainingWeekCriteria();
criteria.UserId = new StringCriteria()
{
Equal = trainingWeek.UserId
};
criteria.Year = new IntegerCriteria()
{
Equal = trainingWeek.Year
};
criteria.WeekOfYear = new IntegerCriteria()
{
Equal = trainingWeek.WeekOfYear
};
criteriaList.Add(criteria);
}
onlineTrainingWeekList = await TrainingWeekWebService.FindTrainingWeeksAsync(criteriaList, trainingWeekScenario);
if (onlineTrainingWeekList != null && onlineTrainingWeekList.Count > 0)
{
trainingWeekService.UpdateTrainingWeekList(onlineTrainingWeekList, trainingWeekScenario);
}
}
result = true;
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to synchronize training weeks", except);
}
return(result);
}
private Calculator()
{
_repo = new CriteriaRepo();
_criterias = new CriteriaList(_repo.GetAll());
}
public List<TrainingWeek> FindTrainingWeek(CriteriaList<TrainingWeekCriteria> trainingWeekCriteriaList, TrainingWeekScenario trainingWeekScenario)
{
return GetTrainingWeekManager().FindTrainingWeek(trainingWeekCriteriaList, trainingWeekScenario);
}
public List <TrainingExerciseSet> FindTrainingExerciseSet(CriteriaList <TrainingExerciseSetCriteria> trainingExerciseSetCriteriaList)
{
return(_trainingExerciseSetModule.Find(trainingExerciseSetCriteriaList));
}
public List <TrainingExercise> FindTrainingExercise(CriteriaList <TrainingExerciseCriteria> trainingExerciseCriteriaList)
{
return(GetTrainingExerciseManager().FindTrainingExercise(trainingExerciseCriteriaList));
}
public static void CompleteQuery <TEntity, TCriteriaField>(ref IQueryable <TEntity> source, CriteriaList <TCriteriaField> criteriaFieldList) where TEntity : class
where TCriteriaField : CriteriaField
{
if (source == null || criteriaFieldList == null)
{
return;
}
Expression <Func <TEntity, bool> > globalQueryExpression = null, queryExpression;
foreach (var criteriaField in criteriaFieldList)
{
queryExpression = null;
CompleteQueryInternal(ref queryExpression, criteriaField);
if (queryExpression != null)
{
if (globalQueryExpression == null)
{
globalQueryExpression = queryExpression;
}
else
{
globalQueryExpression = globalQueryExpression.OrElse(queryExpression);
}
}
}
if (globalQueryExpression != null)
{
source = source.Where(globalQueryExpression);
}
foreach (var criteriaField in criteriaFieldList)
{
if (criteriaField != null && criteriaField.FieldSortList != null && criteriaField.FieldSortList.Count > 0)
{
ApplySort(ref source, criteriaField);
break;
}
}
}
public static void CompleteQuery <TEntity, T>(ref IQueryable <TEntity> source, CriteriaList <T> criteriaFieldList) where TEntity : class
where T : CriteriaField
{
if (criteriaFieldList == null)
{
return;
}
Expression <Func <TEntity, bool> > queryExpression, globalQueryExpression;
globalQueryExpression = null;
foreach (T criteriaField in criteriaFieldList)
{
if (criteriaField != null)
{
queryExpression = null;
CompleteQueryInternal(ref queryExpression, criteriaField);
if (queryExpression != null)
{
if (globalQueryExpression == null)
{
globalQueryExpression = queryExpression;
}
else
{
globalQueryExpression = globalQueryExpression.OrElse(queryExpression);
}
}
}
}
if (globalQueryExpression != null)
{
source = source.Where(globalQueryExpression);
}
}
/// <summary>
/// Gets a list of records based on criteriaList passed in, using HQL.
/// Supports OR searches as well.
/// </summary>
/// <typeparam name="T">Business entity object type</typeparam>
/// <typeparam name="criteriaList">list of TypeSafe Criteria objects</typeparam>
/// <returns>list of Business entity objects</returns>
private List <T> ExecuteHQLSearch <T>(CriteriaList criteriaList) where T : new()
{
List <T> businessEntitiesList;
T retObject = new T();
List <HQLParameterItem> masterHQLParameterItemList = new List <HQLParameterItem>();
Dictionary <string, object> paramDictionary = new Dictionary <string, object>();
int i = 0;
string whereClause = " WHERE ";
//used when building out where clause. Need to know index of all entities in the search
//since parameters are named param0, param1, etc. Parent entity is always first (index=0)
List <string> entityNameList = new List <string>();
//add parent entity type to entityNameList
entityNameList.Add(retObject.GetType().Name);
foreach (Criteria criteria in criteriaList)
{
criteriaType TargetOperationalOperator;
List <HQLParameterItem> HQLParameterItemList = new List <HQLParameterItem>();
string criteriaHQL = "";
//if this is not the first criteria in the criteria list, supply the () and correct operator
if (criteriaList.IndexOf(criteria) > 0)
{
criteriaHQL += " " + criteria.LogicalOperator.ToString() + " (";
}
foreach (Criterion criterion in criteria)
{
switch (criterion.RelationalOperator)
{
case RelationalOperatorType.EQUALS: TargetOperationalOperator = criteriaType.Equal;
break;
case RelationalOperatorType.STARTSWITH: TargetOperationalOperator = criteriaType.LikeStartsWith;
break;
case RelationalOperatorType.ENDSWITH: TargetOperationalOperator = criteriaType.LikeEndsWith;
break;
case RelationalOperatorType.CONTAINS: TargetOperationalOperator = criteriaType.Like;
break;
case RelationalOperatorType.IN: TargetOperationalOperator = criteriaType.In;
break;
case RelationalOperatorType.GREATERTHAN: TargetOperationalOperator = criteriaType.GreaterThan;
break;
case RelationalOperatorType.GREATERTHAN_EQUAL: TargetOperationalOperator = criteriaType.GreaterThanEqual;
break;
case RelationalOperatorType.LESSTHAN: TargetOperationalOperator = criteriaType.LessThan;
break;
case RelationalOperatorType.LESSTHAN_EQUAL: TargetOperationalOperator = criteriaType.LessThanEqual;
break;
default: throw new Exception(String.Format("% is not supported as relation operator", criterion.RelationalOperator));
}
if (criterion.SubObjectTypeField != null && entityNameList.Contains(criterion.SubObjectTypeField) == false)
{
entityNameList.Add(criterion.SubObjectTypeField);
}
HQLParameterItemList.Add(new HQLParameterItem(criterion.FieldName, criterion.FieldValue, TargetOperationalOperator, criterion.LogicalOperator.ToString(), criterion.SubObjectTypeField));
}
// build out where clause
foreach (HQLParameterItem hqlItem in HQLParameterItemList)
{
paramDictionary.Add("param" + i, hqlItem.FieldValue);
criteriaHQL = CreateHQLWhereClause(criteriaHQL, i, hqlItem, HQLParameterItemList, entityNameList);
i++;
}
//if this is not the first criteria in the criteria list, supply the ) to end grouping
if (criteriaList.IndexOf(criteria) > 0)
{
criteriaHQL += ")";
}
whereClause += criteriaHQL;
masterHQLParameterItemList.AddRange(HQLParameterItemList);
}
// HMF Beging Sort Criteria Support
List <string> sortCriterionSubObjectNameList = new List <String>();
if (criteriaList.SortCriteria != null && criteriaList.SortCriteria.Count > 0)
{
foreach (SortCriterion sortCriterion in criteriaList.SortCriteria)
{
if (sortCriterion.SubObjectTypeField != null && entityNameList.Contains(sortCriterion.SubObjectTypeField) == false)
{
entityNameList.Add(sortCriterion.SubObjectTypeField);
sortCriterionSubObjectNameList.Add(sortCriterion.SubObjectTypeField);
}
}
string orderByClause = " ORDER BY ";
int x = 0;
foreach (SortCriterion sortCriterion in criteriaList.SortCriteria)
{
//determine if sort goes with parent or sub-object
if (sortCriterion.SubObjectTypeField == null)
{
orderByClause += " parent.";
}
else
{
orderByClause += " sub" + entityNameList.IndexOf(sortCriterion.SubObjectTypeField) + ".";
}
if (x > 0)
{
orderByClause += ",";
}
if (sortCriterion.SortDirection == SortDirection.Ascending)
{
orderByClause += sortCriterion.FieldName + " ASC";
}
else
{
orderByClause += sortCriterion.FieldName + " DESC";
}
x++;
}
whereClause += orderByClause;
}
// HMF End Sort Criteria Support
if (criteriaList.MaxEntities > 0)
{
businessEntitiesList = GetSubObjectFilteredList <T>(masterHQLParameterItemList, paramDictionary, whereClause, criteriaList.MaxEntities, sortCriterionSubObjectNameList);
}
else
{
businessEntitiesList = GetSubObjectFilteredList <T>(masterHQLParameterItemList, paramDictionary, whereClause, -1, sortCriterionSubObjectNameList);
}
return(businessEntitiesList);
}
public List<TrainingWeek> FindTrainingWeek(CriteriaList<TrainingWeekCriteria> trainingWeekCriteriaList, TrainingWeekScenario trainingWeekScenario)
{
List<TrainingWeek> trainingWeeks = _trainingWeekModule.Find(trainingWeekCriteriaList);
if (trainingWeekScenario != null && trainingWeekScenario.ManageTrainingDay)
{
foreach (TrainingWeek trainingJournal in trainingWeeks)
{
CompleteTrainingWeekWithTrainingDay(trainingJournal, trainingWeekScenario.TrainingDayScenario);
}
}
return trainingWeeks;
}
public List <TrainingWeek> FindTrainingWeek(CriteriaList <TrainingWeekCriteria> trainingWeekCriteriaList, TrainingWeekScenario trainingWeekScenario)
{
return(GetTrainingWeekManager().FindTrainingWeek(trainingWeekCriteriaList, trainingWeekScenario));
}
