private static AnalyticRuleSettingsEntity Get(int ruleType, int engineFamilyType, int engineType)
{
using (VTSDatabase database = new VTSDatabase())
{
AnalyticRuleSettingsEntity exactMatch =
database.AnalyticRuleSettings.FirstOrDefault(
s => s.RuleType == ruleType &&
s.EngineFamilyType == engineFamilyType &&
s.EngineType == engineType);
if (exactMatch != null)
{
return(exactMatch);
}
AnalyticRuleSettingsEntity engineFamilyMatch =
database.AnalyticRuleSettings.FirstOrDefault(
s => s.RuleType == ruleType &&
s.EngineFamilyType == engineFamilyType &&
s.EngineType == null);
if (engineFamilyMatch != null)
{
return(engineFamilyMatch);
}
AnalyticRuleSettingsEntity typeFallbackMatch =
database.AnalyticRuleSettings.First(
s => s.RuleType == ruleType &&
s.EngineFamilyType == null &&
s.EngineType == null);
return(typeFallbackMatch);
}
}
private void PersistVehicleCharacteristics(VehicleCharacteristics chars)
{
VehicleCharacteristicsEntity entity =
VehicleCharacteristicsAssembler.FromDomainObjectToEntity(chars);
using (VTSDatabase database = new VTSDatabase())
{
database.VehicleCharacteristics.Add(entity);
try
{
database.SaveChanges();
}
catch (DbEntityValidationException e)
{
string result = String.Empty;
foreach (DbEntityValidationResult eve in e.EntityValidationErrors)
{
string entityTypename = eve.Entry.Entity.GetType().Name;
string errorString = String.Empty;
foreach (DbValidationError error in eve.ValidationErrors)
{
errorString = error.PropertyName + " : " + error.ErrorMessage;
}
result = String.Format("{0} | {1}", result, entityTypename + " -> " + errorString);
}
throw new Exception(result);
}
}
}
private static AnalyticRuleSettingsDto GetDefaultSettingsBySignature(
int ruleType, int engineFamilyType, int engineType)
{
using (VTSDatabase database = new VTSDatabase())
{
AnalyticRuleSettingsEntity exactMatch =
database.AnalyticRuleSettings.FirstOrDefault(
s => s.RuleType == ruleType &&
s.EngineFamilyType == engineFamilyType &&
s.EngineType == engineType);
if (exactMatch != null)
{
return(AnalyticRuleSettingsAssembler.
FromEntityToDto(exactMatch));
}
AnalyticRuleSettingsEntity engineFamilyMatch =
database.AnalyticRuleSettings.FirstOrDefault(
s => s.RuleType == ruleType &&
s.EngineFamilyType == engineFamilyType &&
s.EngineType == null);
if (engineFamilyMatch != null)
{
return(AnalyticRuleSettingsAssembler.
FromEntityToDto(engineFamilyMatch));
}
AnalyticRuleSettingsEntity typeFallbackMatch =
database.AnalyticRuleSettings.First(
s => s.RuleType == ruleType &&
s.EngineFamilyType == null &&
s.EngineType == null);
return(AnalyticRuleSettingsAssembler.
FromEntityToDto(typeFallbackMatch));
}
}
private static void Persist(List <PsaDataset> datasets)
{
foreach (PsaDataset psaDataset in datasets)
{
PsaDatasetDto dataset = PsaDatasetAssembler.FromDomainObjectToDto(psaDataset);
if (IsKnownDataset(dataset))
{
foreach (PsaTraceDto traceDto in dataset.Traces)
{
// skip known traces
if (!IsKnownTrace(traceDto))
{
// persist trace for existing dataset
using (VTSDatabase database = new VTSDatabase())
{
Guid guid = dataset.Guid;
long datasetId = database.PsaDataset.First(d => d.Guid == guid).Id;
traceDto.PsaDatasetId = datasetId;
VTSWebService.DataAccess.PsaTrace traceEntity = PsaTraceAssembler.FromDtoToEntity(traceDto);
database.PsaTrace.Add(traceEntity);
database.SaveChanges();
}
}
}
}
else
{
List <PsaTraceDto> bufferList = new List <PsaTraceDto>(dataset.Traces);
foreach (PsaTraceDto traceDto in bufferList) // to remove known traces
{
if (IsKnownTrace(traceDto))
{
DateTime date = traceDto.Date;
string vin = traceDto.Vin;
PsaTraceDto dtoToRemove = dataset.Traces.FirstOrDefault(t =>
t.Date == date && t.Vin == vin);
if (dtoToRemove == null)
{
throw new Exception("Trace not found here!");
}
dataset.Traces.Remove(dtoToRemove);
}
}
if (dataset.Traces.Count > 0) // if there are still some new
{
VTSWebService.DataAccess.PsaDataset datasetEntity =
PsaDatasetAssembler.FromDtoToEntity(dataset);
using (VTSDatabase database = new VTSDatabase())
{
string vin = dataset.Traces.First().Vin;
datasetEntity.VehicleEntityId =
database.Vehicle.First(v => v.Vin == vin).Id;
database.PsaDataset.Add(datasetEntity);
database.SaveChanges();
}
}
}
}
}
private static bool IsKnownDataset(PsaDatasetDto dataset)
{
using (VTSDatabase database = new VTSDatabase())
{
Guid guid = dataset.Guid;
return(database.PsaDataset.Any(pd => pd.Guid == guid));
}
}
private bool DoWeHaveAnythingForThisVin(string vin)
{
using (VTSDatabase database = new VTSDatabase())
{
return(database.VehicleCharacteristics.Any(
vc => vc.Vin == vin));
}
}
private static bool IsKnownTrace(PsaTraceDto dto)
{
using (VTSDatabase database = new VTSDatabase())
{
string vin = dto.Vin;
DateTime date = dto.Date;
return(database.PsaTrace.Any(t => t.Date == date && t.Vin == vin));
}
}
private bool AlreadyHaveItemWithSignature(AnalyticStatisticsItem item)
{
using (VTSDatabase database = new VTSDatabase())
{
return(database.AnalyticStatisticsItem.Any(
i => i.Type == (int)item.Type &&
i.TargetEngineFamilyType == (int)item.TargetEngineFamilyType &&
i.TargetEngineType == (int)item.TargetEngineType));
}
}
public void Aggregate()
{
using (VTSDatabase database = new VTSDatabase())
{
foreach (AnalyticStatisticsItemEntity item in database.AnalyticStatisticsItem)
{
AggregateAnalyticStatisticsItemEntity(item, database);
}
database.SaveChanges();
}
}
private void PersistNewAnalyticStatisticsItem(AnalyticStatisticsItem item)
{
AnalyticStatisticsItemEntity entity =
AnalyticStatisticsItemAssembler.FromDomainObjectToEntity(item);
using (VTSDatabase database = new VTSDatabase())
{
database.AnalyticStatisticsItem.Add(entity);
database.SaveChanges();
RememberUpdatedItem(entity);
}
}
private bool AlreadyHaveThisValueForThisItem(
AnalyticStatisticsItem item,
AnalyticStatisticsValue value)
{
using (VTSDatabase database = new VTSDatabase())
{
AnalyticStatisticsItemEntity ourItem = database.AnalyticStatisticsItem.First(
i => i.Type == (int)item.Type &&
i.TargetEngineFamilyType == (int)item.TargetEngineFamilyType &&
i.TargetEngineType == (int)item.TargetEngineType);
return(ourItem.AnalyticStatisticsValue.Any(v =>
v.SourcePsaParametersSetId == value.SourcePsaParametersSetId));
}
}
private void RememberUpdatedItem(AnalyticStatisticsItemEntity item)
{
using (VTSDatabase database = new VTSDatabase())
{
AnalyticStatisticsItemEntity itemEntity = database.
AnalyticStatisticsItem.FirstOrDefault(e =>
e.Type == item.Type &&
e.TargetEngineFamilyType == item.TargetEngineFamilyType &&
e.TargetEngineType == item.TargetEngineType);
if (itemEntity == null)
{
return;
}
affectedItemsIds.Add(itemEntity.Id);
}
}
private VehicleCharacteristics GetExactMatchFromDatabase(
string vin, string language)
{
using (VTSDatabase db = new VTSDatabase())
{
IList <VehicleCharacteristicsEntity> exactMatch =
db.VehicleCharacteristics.Where(vc =>
vc.Vin == vin && vc.Language == language).ToList();
if (exactMatch.Count == 0)
{
return(null);
}
return(VehicleCharacteristicsAssembler.
FromEntityToDomainObject(exactMatch.First()));
}
}
private void AddNewValueToExistingItem(AnalyticStatisticsItem item,
AnalyticStatisticsValue value)
{
AnalyticStatisticsValueEntity entityToAdd =
AnalyticStatisticsValueAssembler.FromDomainObjectToEntity(value);
using (VTSDatabase database = new VTSDatabase())
{
AnalyticStatisticsItemEntity existingItem = database.AnalyticStatisticsItem.First(
i => i.Type == (int)item.Type &&
i.TargetEngineFamilyType == (int)item.TargetEngineFamilyType &&
i.TargetEngineType == (int)item.TargetEngineType);
existingItem.AnalyticStatisticsValue.Add(entityToAdd);
database.SaveChanges();
RememberUpdatedItem(existingItem);
}
}
public void Aggregate(List <long> statisticsItemIds)
{
using (VTSDatabase database = new VTSDatabase())
{
List <AnalyticStatisticsItemEntity> items =
new List <AnalyticStatisticsItemEntity>();
foreach (long id in statisticsItemIds)
{
AnalyticStatisticsItemEntity entity = database.
AnalyticStatisticsItem.First(item => item.Id == id);
items.Add(entity);
}
foreach (AnalyticStatisticsItem item in items)
{
AggregateAnalyticStatisticsItemEntity(item, database);
}
database.SaveChanges();
}
}
private void UpdateValue(AnalyticStatisticsItem item,
AnalyticStatisticsValue value)
{
using (VTSDatabase database = new VTSDatabase())
{
AnalyticStatisticsItemEntity existingItem = database.AnalyticStatisticsItem.First(
i => i.Type == (int)item.Type &&
i.TargetEngineFamilyType == (int)item.TargetEngineFamilyType &&
i.TargetEngineType == (int)item.TargetEngineType);
AnalyticStatisticsValueEntity entityToUpdate = existingItem.AnalyticStatisticsValue.First(
v => v.SourcePsaParametersSetId == value.SourcePsaParametersSetId);
if (!entityToUpdate.Value.Equals(value.Value))
{
entityToUpdate.Value = value.Value;
database.SaveChanges();
RememberUpdatedItem(existingItem);
}
}
}
private void LogUnrecognizedVin(string vin)
{
if (vin.Length != 17)
{
return;
}
using (VTSDatabase database = new VTSDatabase())
{
if (!database.UnrecognizedVin.Any(
uv =>
uv.Vin.Equals(vin, StringComparison.OrdinalIgnoreCase)))
{
database.UnrecognizedVin.Add(
new UnrecognizedVin
{
Date = DateTime.Now,
Vin = vin
});
database.SaveChanges();
}
}
}
private List <SupportedLanguage> GetLangsWeDoNotHaveForVin(string vin)
{
using (VTSDatabase database = new VTSDatabase())
{
List <SupportedLanguage> result = new List <SupportedLanguage>();
foreach (SupportedLanguage value in
Enum.GetValues(typeof(SupportedLanguage)))
{
CharacteristicsLanguageMapper mapper =
new CharacteristicsLanguageMapper(VinChecker.GetManufacturer(vin));
string langValue = mapper.GetSpecificCode(value);
if (!database.VehicleCharacteristics.Any(vc =>
vc.Vin == vin && vc.Language == langValue))
{
if (!result.Contains(value))
{
result.Add(value);
}
}
}
return(result);
}
}
private VehicleCharacteristics GetBestMatchFromOurDatabase(
string vin, string preferredLang)
{
using (VTSDatabase database = new VTSDatabase())
{
VehicleCharacteristicsEntity perfectMatch =
database.VehicleCharacteristics.FirstOrDefault(
vc => vc.Vin == vin && vc.Language == preferredLang);
if (perfectMatch != null)
{
return(VehicleCharacteristicsAssembler.
FromEntityToDomainObject(perfectMatch));
}
VehicleCharacteristicsEntity anything =
database.VehicleCharacteristics.FirstOrDefault(
vc => vc.Vin == vin);
if (anything == null)
{
return(null);
}
return(VehicleCharacteristicsAssembler.
FromEntityToDomainObject(anything));
}
}
private void AggregateAnalyticStatisticsItemEntity(
AnalyticStatisticsItemEntity item,
VTSDatabase database)
{
VTS.Shared.DomainObjects.AnalyticStatisticsItem asi =
AnalyticStatisticsItemAssembler.FromEntityToDomainObject(item);
VTS.AnalysisCore.Common.AnalyticRuleSettings settings = AggregatorFactory.Create(asi).Aggregate();
AnalyticRuleSettingsEntity entityToUpdate = database.AnalyticRuleSettings.
FirstOrDefault(s => s.RuleType == (int)settings.RuleType && s.EngineType == (int)settings.EngineType);
if (entityToUpdate == null)
{
database.AnalyticRuleSettings.Add(
AnalyticRuleSettingsAssembler.FromDomainObjectToEntity(settings));
}
else
{
AnalyticRuleSettingsEntity sourceEntity =
AnalyticRuleSettingsAssembler.FromDomainObjectToEntity(settings);
UpdateAnalyticRuleStatisticalAtomEntity(sourceEntity, entityToUpdate);
ReliabilitySummarizer summarizer = new ReliabilitySummarizer();
summarizer.SummarizeFor(entityToUpdate);
}
}
/// <summary>
/// Persists dataset with all duplicate protections.
/// </summary>
/// <returns>Persisted dataset guid.</returns>
public Guid Persist(PsaDatasetDto dataset)
{
Guid updatedDatasetGuid = Guid.Empty;
if (IsKnownDataset(dataset))
{
foreach (PsaTraceDto traceDto in dataset.Traces)
{
// skip known traces, skip empty traces
if (!IsKnownTrace(traceDto) && traceDto.ParametersSets.Count > 0)
{
// persist trace for existing dataset
using (VTSDatabase database = new VTSDatabase())
{
Guid guid = dataset.Guid;
PsaDatasetEntity entity = database.PsaDataset.FirstOrDefault(d => d.Guid == guid);
if (entity != null)
{
traceDto.PsaDatasetId = entity.Id;
}
PsaTrace traceEntity = PsaTraceAssembler.FromDtoToEntity(traceDto);
database.PsaTrace.Add(traceEntity);
database.SaveChanges();
updatedDatasetGuid = dataset.Guid; // to update analytic data based on updated dataset
}
}
}
}
else
{
List <PsaTraceDto> bufferList = new List <PsaTraceDto>(dataset.Traces);
foreach (PsaTraceDto traceDto in bufferList) // to remove known traces
{
if (IsKnownTrace(traceDto) && traceDto.ParametersSets.Count > 0)
{
DateTime date = traceDto.Date;
string vin = traceDto.Vin;
PsaTraceDto dtoToRemove = dataset.Traces.FirstOrDefault(t =>
t.Date == date && t.Vin == vin);
if (dtoToRemove == null)
{
throw new Exception("Trace not found here!");
}
dataset.Traces.Remove(dtoToRemove);
}
}
if (dataset.Traces.Count > 0) // if there are still some new
{
string vin = dataset.Traces.First().Vin;
if (!VinChecker.IsValid(vin))
{
throw new FaultException <VtsWebServiceException>(
new VtsWebServiceException(String.Format("Cannot save data for invalid vin {0}", vin)));
}
PsaDatasetEntity datasetEntity = PsaDatasetAssembler.FromDtoToEntity(dataset);
using (VTSDatabase database = new VTSDatabase())
{
datasetEntity.VehicleEntityId =
database.Vehicle.First(v => v.Vin == vin).Id;
database.PsaDataset.Add(datasetEntity);
database.SaveChanges();
updatedDatasetGuid = dataset.Guid; // to update analytic data based on updated dataset
}
}
}
return(updatedDatasetGuid);
}
