public IHttpActionResult PutModels([FromBody] MappableDTO[] data, [FromUri] string requestType, [FromUri] string leagueName)
{
try
{
logger.Info($"Put Models request || type: {requestType} - league: {leagueName} - data: {string.Join("/", (object[])data)}");
CheckLeagueRole(User, leagueName);
if (leagueName == null)
{
return(BadRequest("Parameter leagueName can not be null"));
}
if (data == null)
{
return(Ok(data));
}
//return Ok();
if (data.Count() == 0)
{
return(Ok(new MappableDTO[0]));
}
Type requestTypeType;
if (requestType == null)
{
requestTypeType = data.GetType();
}
else
{
requestTypeType = GetRequestType(requestType);
}
if (requestTypeType == null)
{
return(BadRequest("Could not identify request type"));
}
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext, User.Identity.Name, User.Identity.GetUserId()))
{
data = modelDataProvider.PutArray(requestTypeType, data);
if (dbContext.DbChanged)
{
UpdateLeague(leagueName, User);
}
}
//GC.Collect();
logger.Info($"Put Models request || send data: {string.Join("/", (object[])data)}");
return(Ok(data));
}
catch (Exception e)
{
logger.Error("Error in PutModels", e);
throw;
}
}
public IHttpActionResult DeleteModels([FromUri] string[] requestIds, string requestType, string leagueName)
{
try
{
logger.Info($"Delete Models request || type: {requestType} - league: {leagueName} - ids: {string.Join("/", requestIds.Select(x => $"[{x}]"))}");
CheckLeagueRole(User, leagueName);
if (requestIds == null || requestType == null || leagueName == null)
{
return(BadRequest("Parameters can not be null!"));
}
if (requestIds.Count() == 0)
{
return(BadRequest("Request ids can not be empty"));
}
long[][] requestIdValues;
if (requestIds != null && requestIds.Count() > 0)
{
requestIdValues = requestIds.Select(x => GetIdFromString(x)).ToArray();
}
else
{
requestIdValues = null;
}
Type requestTypeType = GetRequestType(requestType);
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
bool data;
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext))
{
data = modelDataProvider.DeleteArray(requestTypeType, requestIdValues);
if (dbContext.DbChanged)
{
UpdateLeague(leagueName, User);
}
}
//GC.Collect();
logger.Info($"Delete Models request || send answer: {data}");
return(Ok(data));
}
catch (Exception e)
{
logger.Error("Error in PostModels", e);
throw;
}
}
public IHttpActionResult GetModel(string requestId, string requestType, string leagueName, string fields, bool excludeFields = false)
{
try
{
logger.Info($"Get Model Fields request || type: {requestType} - league: {leagueName} - id: [{requestId}] - fields: {fields}");
CheckLeagueRole(User, leagueName);
if (requestId == null || requestType == null || leagueName == null)
{
return(BadRequest("Parameter requestType or leagueName can not be null!"));
}
string[] fieldValues = new string[0];
try
{
fieldValues = fields?.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) ?? fieldValues;
}
catch (Exception e)
{
throw new ArgumentException("Invalid field names", e);
}
long[] requestIdValue = GetIdFromString(requestId);
Type requestTypeType = GetRequestType(requestType);
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
MappableDTO data;
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext))
{
data = modelDataProvider.Get(requestTypeType, requestIdValue);
}
//GC.Collect();
data.SetSerializableProperties(fieldValues, excludeFields);
var response = SelectFieldsHelper.GetSelectedFieldObject(data);
logger.Info($"Get Model Fields request || send data: {data} - fields: {string.Join(",", fieldValues)}");
return(Json(response));
}
catch (Exception e)
{
logger.Error("Error in GetModel Fields", e);
throw;
}
}
public IHttpActionResult GetModels([FromUri] string[] requestIds, string requestType, string leagueName)
{
try
{
logger.Info($"Get Models request || type: {requestType} - league: {leagueName} - ids: {string.Join("/", requestIds.Select(x => $"[{string.Join(",", x)}]"))}");
CheckLeagueRole(User, leagueName);
if (requestType == null || leagueName == null)
{
return(BadRequest("Parameter requestType or leagueName can not be null!"));
}
long[][] requestIdValues;
if (requestIds != null && requestIds.Count() > 0)
{
requestIdValues = requestIds.Select(x => GetIdFromString(x)).ToArray();
}
else
{
requestIdValues = null;
}
Type requestTypeType = GetRequestType(requestType);
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
MappableDTO[] data;
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext))
{
data = modelDataProvider.GetArray(requestTypeType, requestIdValues);
}
//GC.Collect();
logger.Info($"Get Models request || send data: {string.Join("/", (object[])data)}");
return(Ok(data));
}
catch (Exception e)
{
logger.Error("Error in GetModels", e);
throw;
}
}
public IHttpActionResult GetModel(string requestId, string requestType, string leagueName)
{
try
{
logger.Info($"Get Model request || type: {requestType} - league: {leagueName} - id: [{requestId}]");
CheckLeagueRole(User, leagueName);
if (requestId == null || requestType == null || leagueName == null)
{
return(BadRequest("Parameter requestType or leagueName can not be null!"));
}
long[] requestIdValue = GetIdFromString(requestId);
Type requestTypeType = GetRequestType(requestType);
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
MappableDTO data;
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext))
{
data = modelDataProvider.Get(requestTypeType, requestIdValue);
}
//GC.Collect();
logger.Info($"Get Model request || send data: {data?.ToString()}");
return(Ok(data));
}
catch (Exception e)
{
logger.Error("Error in GetModel", e);
throw;
}
}
public async Task<IEnumerable<T>> GetModelsAsync<T>(IEnumerable<long[]> modelIds = null, bool update = false, bool reload = false) where T : MappableModel
{
object[] data = null;
List<T> modelList = new List<T>();
List<T> updateList = new List<T>();
List<long[]> getModelIds = new List<long[]>();
if (modelIds != null)
{
foreach (var modelId in modelIds)
{
var loadedModel = ModelCache.GetModel<T>(modelId.Cast<object>().ToArray());
if (loadedModel != null)
{
modelList.Add(loadedModel);
if (reload || loadedModel.IsExpired)
{
getModelIds.Add(modelId);
loadedModel.InitReset();
}
else
updateList.Add(loadedModel);
}
else
getModelIds.Add(modelId);
}
}
else
{
getModelIds = null;
}
if (update)
{
_ = GetModelsAsync<T>(updateList.Where(x => x.ContainsChanges == false).Select(x => x.ModelId).ToArray(), update: false, reload: true);
_ = UpdateModelsAsync(updateList.ToArray());
}
if (getModelIds == null || getModelIds.Count > 0)
{
if (typeof(T).Equals(typeof(SeasonModel)))
{
data = await ModelDataProvider.GetAsync<SeasonDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(LeagueMember)))
{
data = await ModelDataProvider.GetAsync<LeagueMemberDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScheduleModel)))
{
data = await ModelDataProvider.GetAsync<ScheduleDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(SessionModel)))
{
data = await ModelDataProvider.GetAsync<SessionDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(RaceSessionModel)))
{
data = await ModelDataProvider.GetAsync<RaceSessionDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(IncidentReviewModel)))
{
data = await ModelDataProvider.GetAsync<IncidentReviewDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(CommentModel)))
{
data = await ModelDataProvider.GetAsync<CommentDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ReviewCommentModel)))
{
data = await ModelDataProvider.GetAsync<ReviewCommentDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ResultModel)))
{
data = await ModelDataProvider.GetAsync<ResultDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(LeagueMember)))
{
data = await ModelDataProvider.GetAsync<LeagueMemberDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScoringModel)))
{
data = await ModelDataProvider.GetAsync<ScoringDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScoredResultModel)))
{
data = await ModelDataProvider.GetAsync<ScoredResultDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScoredResultRowModel)))
{
data = await ModelDataProvider.GetAsync<ScoredResultRowDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ResultRowModel)))
{
data = await ModelDataProvider.GetAsync<ResultRowDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(StandingsModel)))
{
data = await ModelDataProvider.GetAsync<StandingsDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(AddPenaltyModel)))
{
data = await ModelDataProvider.GetAsync<AddPenaltyDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScoringTableModel)))
{
data = await ModelDataProvider.GetAsync<ScoringTableDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(TeamModel)))
{
data = await ModelDataProvider.GetAsync<TeamDataDTO>(getModelIds?.Select(x => x.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(VoteCategoryModel)))
{
data = await ModelDataProvider.GetAsync<VoteCategoryDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(CustomIncidentModel)))
{
data = await ModelDataProvider.GetAsync<CustomIncidentDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(ResultsFilterOptionModel)))
{
data = await ModelDataProvider.GetAsync<ResultsFilterOptionDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(SeasonStatisticSetModel)))
{
data = await ModelDataProvider.GetAsync<SeasonStatisticSetDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(LeagueStatisticSetModel)))
{
data = await ModelDataProvider.GetAsync<LeagueStatisticSetDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(ImportedStatisticSetModel)))
{
data = await ModelDataProvider.GetAsync<ImportedStatisticSetDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(StatisticSetModel)))
{
data = await ModelDataProvider.GetAsync<StatisticSetDTO>(getModelIds?.ToArray());
}
else if (typeof(T).Equals(typeof(DriverStatisticModel)))
{
data = await ModelDataProvider.GetAsync<DriverStatisticDTO>(getModelIds?.ToArray());
}
else
{
throw new UnknownModelTypeException("Could not load Model of type " + typeof(T).ToString() + ". Model type not known.");
}
//data = await DbContext.GetAsync(getModelIds?.Select(x => x.ToArray()).ToArray(), typeof(T));
if (data == null)
{
if (getModelIds == null)
return null;
foreach (var modelId in getModelIds)
{
var add = await GetModelAsync<T>(modelId.ToArray());
if (add == null)
return new T[0];
if (modelList.Any(x => x != null && x.ModelId.SequenceEqual(add.ModelId)))
add.CopyTo(modelList.SingleOrDefault(x => x.ModelId.SequenceEqual(add.ModelId)));
else
modelList.Add(add);
}
}
else
{
var mapper = MapperConfiguration.CreateMapper();
var addList = new List<T>();
var validData = data.Where(x => x != null);
//mapper.Map(validData, addList);
foreach(var dto in validData)
{
var add = mapper.Map<T>(dto);
addList.Add(add);
}
//modelList.AddRange(addList);
//foreach (var add in addList)
//{
// if (modelList.Any(x => x != null && x.ModelId.SequenceEqual(add.ModelId)))
// add.CopyTo(modelList.SingleOrDefault(x => x.ModelId.SequenceEqual(add.ModelId)));
// else
// modelList.Add(add);
//}
modelList = addList;
}
}
foreach (var model in modelList)
{
if (model != null)
{
model.ResetChangedState();
model.InitializeModel();
}
}
if (modelIds == null)
return modelList;
else
{
return modelIds.Select(x => modelList.SingleOrDefault(y => y != null && y.ModelId.SequenceEqual(x)));
}
}
public async Task<IEnumerable<T>> AddModelsAsync<T>(params T[] models) where T : MappableModel
{
List<T> modelList = models.ToList();
var mapper = MapperConfiguration.CreateMapper();
object[] data = null;
if (typeof(T).Equals(typeof(SeasonModel)))
{
data = mapper.Map<IEnumerable<SeasonDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<SeasonDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(SessionModel)))
{
data = mapper.Map<IEnumerable<SessionDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<SessionDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(RaceSessionModel)))
{
data = mapper.Map<IEnumerable<RaceSessionDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<RaceSessionDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScheduleModel)))
{
data = mapper.Map<IEnumerable<ScheduleDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ScheduleDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(IncidentReviewModel)))
{
data = mapper.Map<IEnumerable<IncidentReviewDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<IncidentReviewDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(CommentModel)))
{
data = mapper.Map<IEnumerable<CommentDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<CommentDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ReviewCommentModel)))
{
data = mapper.Map<IEnumerable<ReviewCommentDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ReviewCommentDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultModel)))
{
data = mapper.Map<IEnumerable<ResultDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ResultDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(LeagueMember)))
{
data = mapper.Map<IEnumerable<LeagueMemberDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<LeagueMemberDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoringModel)))
{
data = mapper.Map<IEnumerable<ScoringDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ScoringDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultRowModel)))
{
data = mapper.Map<IEnumerable<ResultRowDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ResultRowDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(AddPenaltyModel)))
{
data = mapper.Map<IEnumerable<AddPenaltyDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<AddPenaltyDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoringTableModel)))
{
data = mapper.Map<IEnumerable<ScoringTableDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ScoringTableDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(TeamModel)))
{
data = mapper.Map<IEnumerable<TeamDataDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<TeamDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(VoteCategoryModel)))
{
data = mapper.Map<IEnumerable<VoteCategoryDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<VoteCategoryDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(CustomIncidentModel)))
{
data = mapper.Map<IEnumerable<CustomIncidentDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<CustomIncidentDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultsFilterOptionModel)))
{
data = mapper.Map<IEnumerable<ResultsFilterOptionDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ResultsFilterOptionDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(SeasonStatisticSetModel)))
{
data = mapper.Map<IEnumerable<SeasonStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<SeasonStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(LeagueStatisticSetModel)))
{
data = mapper.Map<IEnumerable<LeagueStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<LeagueStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ImportedStatisticSetModel)))
{
data = mapper.Map<IEnumerable<ImportedStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<ImportedStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(StatisticSetModel)))
{
data = mapper.Map<IEnumerable<StatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<StatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(DriverStatisticModel)))
{
data = mapper.Map<IEnumerable<DriverStatisticDTO>>(models).ToArray();
data = await ModelDataProvider.PostAsync(data.Cast<DriverStatisticDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoringRuleBase)))
{
throw new NotImplementedException("Loading of model from type " + typeof(T).ToString() + " not yet supported.");
}
else
{
throw new UnknownModelTypeException("Could not load Model of type " + typeof(T).ToString() + ". Model type not known.");
}
for (int i = 0; i < data.Count(); i++)
{
if (data[i] != null)
{
modelList[i] = mapper.Map<T>(data[i]);
modelList[i].ResetChangedState();
modelList[i].InitializeModel();
}
else
{
modelList[i] = null;
}
}
return modelList;
}
public async Task<bool> DeleteModelsAsync<T>(long[][] modelIds) where T : MappableModel
{
if (modelIds != null)
{
foreach (var modelId in modelIds)
{
ModelCache.RemoveReference<T>(modelId.Cast<object>().ToArray());
}
}
if (typeof(T).Equals(typeof(SeasonModel)))
{
return await ModelDataProvider.DelAsync<SeasonDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(SessionModel)))
{
return await ModelDataProvider.DelAsync<SessionDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(RaceSessionModel)))
{
return await ModelDataProvider.DelAsync<RaceSessionDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScheduleModel)))
{
return await ModelDataProvider.DelAsync<ScheduleDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(IncidentReviewModel)))
{
return await ModelDataProvider.DelAsync<IncidentReviewDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(CommentModel)))
{
return await ModelDataProvider.DelAsync<CommentDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ReviewCommentModel)))
{
return await ModelDataProvider.DelAsync<ReviewCommentDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ResultModel)))
{
return await ModelDataProvider.DelAsync<ResultDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(LeagueMember)))
{
return await ModelDataProvider.DelAsync<LeagueMemberDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScoringModel)))
{
return await ModelDataProvider.DelAsync<ScoringDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ResultRowModel)))
{
return await ModelDataProvider.DelAsync<ResultRowDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(AddPenaltyModel)))
{
return await ModelDataProvider.DelAsync<AddPenaltyDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScoredResultModel)))
{
return await ModelDataProvider.DelAsync<ScoredResultDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScoredResultRowModel)))
{
return await ModelDataProvider.DelAsync<ScoredResultRowDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScoringTableModel)))
{
return await ModelDataProvider.DelAsync<ScoringTableDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(TeamModel)))
{
return await ModelDataProvider.DelAsync<TeamDataDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(VoteCategoryModel)))
{
return await ModelDataProvider.DelAsync<VoteCategoryDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(CustomIncidentModel)))
{
return await ModelDataProvider.DelAsync<CustomIncidentDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ResultsFilterOptionModel)))
{
return await ModelDataProvider.DelAsync<ResultsFilterOptionDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(SeasonStatisticSetModel)))
{
return await ModelDataProvider.DelAsync<SeasonStatisticSetDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(LeagueStatisticSetModel)))
{
return await ModelDataProvider.DelAsync<LeagueStatisticSetDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ImportedStatisticSetModel)))
{
return await ModelDataProvider.DelAsync<ImportedStatisticSetDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(StatisticSetModel)))
{
return await ModelDataProvider.DelAsync<StatisticSetDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(DriverStatisticModel)))
{
return await ModelDataProvider.DelAsync<DriverStatisticDTO>(modelIds);
}
else if (typeof(T).Equals(typeof(ScoringRuleBase)))
{
throw new NotImplementedException("Loading of model from type " + typeof(T).ToString() + " not yet supported.");
}
else
{
throw new UnknownModelTypeException("Could not load Model of type " + typeof(T).ToString() + ". Model type not known.");
}
}
public async Task<IEnumerable<T>> UpdateModelsAsync<T>(IEnumerable<T> models) where T : MappableModel
{
List<T> modelList = models.ToList();
var mapper = MapperConfiguration.CreateMapper();
object[] data = new object[0];
if (models == null)
return null;
if (models.Count() == 0)
return modelList;
foreach (var model in models)
{
model.InitReset();
}
if (typeof(T).Equals(typeof(SeasonModel)))
{
data = mapper.Map<IEnumerable<SeasonDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<SeasonDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(SessionModel)))
{
data = mapper.Map<IEnumerable<SessionDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<SessionDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(RaceSessionModel)))
{
data = mapper.Map<IEnumerable<RaceSessionDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<RaceSessionDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScheduleModel)))
{
data = mapper.Map<IEnumerable<ScheduleDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ScheduleDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(IncidentReviewModel)))
{
data = mapper.Map<IEnumerable<IncidentReviewDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<IncidentReviewDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(CommentModel)))
{
data = mapper.Map<IEnumerable<CommentDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<CommentDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ReviewCommentModel)))
{
data = mapper.Map<IEnumerable<ReviewCommentDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ReviewCommentDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultModel)))
{
data = mapper.Map<IEnumerable<ResultDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ResultDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(LeagueMember)))
{
data = mapper.Map<IEnumerable<LeagueMemberDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<LeagueMemberDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoringModel)))
{
data = mapper.Map<IEnumerable<ScoringDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ScoringDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultRowModel)))
{
data = mapper.Map<IEnumerable<ResultRowDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ResultRowDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoredResultModel)))
{
data = await ModelDataProvider.GetAsync<ScoredResultDataDTO>(models.Select(x => x.ModelId.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(StandingsModel)))
{
data = await ModelDataProvider.GetAsync<StandingsDataDTO>(models.Select(x => x.ModelId.ToArray()).ToArray());
}
else if (typeof(T).Equals(typeof(ScoringModel)))
{
data = mapper.Map<IEnumerable<ScoringDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ScoringDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(AddPenaltyModel)))
{
data = mapper.Map<IEnumerable<AddPenaltyDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<AddPenaltyDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ScoringTableModel)))
{
data = mapper.Map<IEnumerable<ScoringTableDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ScoringTableDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(TeamModel)))
{
data = mapper.Map<IEnumerable<TeamDataDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<TeamDataDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(VoteCategoryModel)))
{
data = mapper.Map<IEnumerable<VoteCategoryDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<VoteCategoryDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(CustomIncidentModel)))
{
data = mapper.Map<IEnumerable<CustomIncidentDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<CustomIncidentDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ResultsFilterOptionModel)))
{
data = mapper.Map <IEnumerable<ResultsFilterOptionDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ResultsFilterOptionDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(SeasonStatisticSetModel)))
{
data = mapper.Map <IEnumerable<SeasonStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<SeasonStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(LeagueStatisticSetModel)))
{
data = mapper.Map<IEnumerable<LeagueStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<LeagueStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(ImportedStatisticSetModel)))
{
data = mapper.Map<IEnumerable<ImportedStatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<ImportedStatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(StatisticSetModel)))
{
data = mapper.Map<IEnumerable<StatisticSetDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<StatisticSetDTO>().ToArray());
}
else if (typeof(T).Equals(typeof(DriverStatisticModel)))
{
data = mapper.Map<IEnumerable<DriverStatisticDTO>>(models).ToArray();
data = await ModelDataProvider.PutAsync(data.Cast<DriverStatisticDTO>().ToArray());
}
else
{
throw new UnknownModelTypeException("Could not put Model of type " + typeof(T).ToString() + ". Model type not known.");
}
if (data == null)
return null;
for (int i = 0; i < modelList.Count; i++)
{
if (data[i] != null)
{
modelList[i] = mapper.Map<T>(data[i]);
modelList[i].ResetChangedState();
modelList[i].InitializeModel();
}
else
{
modelList[i] = null;
}
}
return modelList;
}
public IHttpActionResult GetModelsSelectFields([FromUri] string[] requestIds, string requestType, string leagueName, string fields, bool excludeFields = false)
{
try
{
logger.Info($"Get Models Fields request || type: {requestType} - league: {leagueName} - ids: {string.Join("/", requestIds.Select(x => $"[{string.Join(",", x)}]"))} - fields: {fields}");
CheckLeagueRole(User, leagueName);
if (requestType == null || leagueName == null)
{
//return BadRequest("Parameter requestType or leagueName can not be null!");
}
string[] fieldValues = new string[0];
try
{
fieldValues = fields?.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries) ?? fieldValues;
}
catch (Exception e)
{
throw new ArgumentException("Invalid field names", e);
}
long[][] requestIdValues;
if (requestIds != null && requestIds.Count() > 0)
{
requestIdValues = requestIds.Select(x => GetIdFromString(x)).ToArray();
}
else
{
requestIdValues = null;
}
Type requestTypeType = GetRequestType(requestType);
if (requestTypeType == null)
{
throw new InvalidOperationException($"Requested type {requestType} not found");
}
var databaseName = GetDatabaseNameFromLeagueName(leagueName);
MappableDTO[] data;
using (var dbContext = new LeagueDbContext(databaseName))
using (IModelDataProvider modelDataProvider = new ModelDataProvider(dbContext))
{
data = modelDataProvider.GetArray(requestTypeType, requestIdValues);
}
//GC.Collect();
data.ForEach(x => x.SetSerializableProperties(fieldValues, excludeFields));
var response = data.Select(x => SelectFieldsHelper.GetSelectedFieldObject(x));
logger.Info($"Get Models Fields request || send data: {string.Join("/", (object[])data)} - fields: {string.Join(",", fieldValues)}");
return(Json(response));
}
catch (Exception e)
{
logger.Error("Error in GetModels Fields", e);
throw;
}
}
public ModelDataProviderTests()
{
_connectionFactory = A.Fake <IConnectionFactory>();
_modelDataProvider = new ModelDataProvider <TestDataModel>(_connectionFactory);
}
public FrequentlyBoughtTogetherController()
{
modelProvider = new ModelDataProvider();
}
