public async Task SetTextItem(AnomalyIdentity anomalyIdentity, TextItemTypeIdentity textItemTypeIdentity, TextItemIdentity textItemIdentity) { await this.ExecuteInContextAsync(async dbContext => { var anomalyID = await dbContext.GetAnomaly(anomalyIdentity).Select(x => x.ID).SingleAsync(); var count = await dbContext.AnomalyToTextItemMappings.Where(x => x.Anomaly.GUID == anomalyIdentity.Value && x.TextItemTypeGUID == textItemTypeIdentity.Value).CountAsync(); var alreadyExists = count > 0; if (alreadyExists) { var mappingEntity = await dbContext.AnomalyToTextItemMappings.Where(x => x.Anomaly.GUID == anomalyIdentity.Value && x.TextItemTypeGUID == textItemTypeIdentity.Value).SingleAsync(); mappingEntity.TextItemGUID = textItemIdentity.Value; } else { var mappingEntity = new Entities.AnomalyToTextItemMapping() { AnomalyID = anomalyID, TextItemTypeGUID = textItemTypeIdentity.Value, TextItemGUID = textItemIdentity.Value, }; dbContext.AnomalyToTextItemMappings.Add(mappingEntity); } await dbContext.SaveChangesAsync(); }); }
public async Task AddImageFile(AnomalyIdentity anomalyIdentity, ImageFileIdentity imageFileIdentity) { await this.ExecuteInContextAsync(async dbContext => { var anomalyID = await dbContext.GetAnomaly(anomalyIdentity).Select(x => x.ID).SingleAsync(); // Acquire the AnomalyToImageFileMapping (since there currently can only be one image per anomaly). var anomalyToImageFileMappingEntity = await dbContext.AnomalyToImageFileMappings.Where(x => x.AnomalyID == anomalyID).SingleOrDefaultAsync(); var existsAlready = anomalyToImageFileMappingEntity is object; if (existsAlready) { anomalyToImageFileMappingEntity.ImageFileGUID = imageFileIdentity.Value; } else { anomalyToImageFileMappingEntity = new Entities.AnomalyToImageFileMapping() { AnomalyID = anomalyID, ImageFileGUID = imageFileIdentity.Value, }; dbContext.AnomalyToImageFileMappings.Add(anomalyToImageFileMappingEntity); } await dbContext.SaveChangesAsync(); }); }
public Task <Dictionary <AnomalyIdentity, List <ImageFileIdentity> > > GetImageFilesForAnomalies(IEnumerable <AnomalyIdentity> anomalyIdentities) { return(this.ExecuteInContext(async dbContext => { var anomalyGuids = anomalyIdentities.Select(x => x.Value).ToList(); var query = from anomaly in dbContext.Anomalies where anomalyGuids.Contains(anomaly.GUID) join anomalyImage in dbContext.AnomalyToImageFileMappings on anomaly.ID equals anomalyImage.AnomalyID into imageGroup from i in imageGroup.DefaultIfEmpty() select new { anomaly.GUID, ImageIdentity = i == default ? Guid.Empty : i.ImageFileGUID, }; var result = await query.ToListAsync(); // Group it by anomaly (since we need an AnomalyInfo per AnomalyIdentity passed in) var grouped = result.GroupBy( x => AnomalyIdentity.From(x.GUID), x => ImageFileIdentity.From(x.ImageIdentity)); var output = grouped.ToDictionary( grouping => grouping.Key, grouping => grouping .Where(x => !x.IsEmpty()) .ToList()); return output; })); }
/// <summary> /// Creates a new anomaly identity. /// Uses the static <see cref="AnomalyIdentity.New()"/> functionality. /// </summary> public static async Task <AnomalyIdentity> New(this IAnomalyRepository anomalyRepository, DateTime reportedUTC) { var anomalyIdentity = AnomalyIdentity.New(); await anomalyRepository.Add(anomalyIdentity, reportedUTC); return(anomalyIdentity); }
public async Task IncrementUpvotesCount(AnomalyIdentity anomalyIdentity) { await this.ExecuteInContext(async dbContext => { var anomalyEntity = await dbContext.GetAnomaly(anomalyIdentity).SingleAsync(); anomalyEntity.UpvotesCount += 1; await dbContext.SaveChangesAsync(); }); }
public async Task SetReportedUTC(AnomalyIdentity anomalyIdentity, DateTime dateTime) { await this.ExecuteInContextAsync(async dbContext => { var entity = await dbContext.GetAnomaly(anomalyIdentity).SingleAsync(); entity.ReportedUTC = dateTime; await dbContext.SaveChangesAsync(); }); }
public async Task SetReportedLocation(AnomalyIdentity anomalyIdentity, LocationIdentity reportedLocation) { await this.ExecuteInContextAsync(async dbContext => { var entity = await dbContext.GetAnomaly(anomalyIdentity).SingleAsync(); entity.ReportedLocationGUID = reportedLocation.Value; await dbContext.SaveChangesAsync(); }); }
public async Task <bool> Exists(AnomalyIdentity anomalyIdentity) { var exists = await this.ExecuteInContextAsync(async dbContext => { var anomalyEntity = await dbContext.Anomalies.Where(x => x.GUID == anomalyIdentity.Value).SingleOrDefaultAsync(); var anomalyExists = !(anomalyEntity == default); return(anomalyExists); }); return(exists); }
public async Task <bool> ExistsTextItem(AnomalyIdentity anomalyIdentity, TextItemTypeIdentity textItemTypeIdentity) { var exists = await this.ExecuteInContextAsync(async dbContext => { var count = await dbContext.AnomalyToTextItemMappings.Where(x => x.Anomaly.GUID == anomalyIdentity.Value && x.TextItemTypeGUID == textItemTypeIdentity.Value).CountAsync(); var output = count > 0; return(output); }); return(exists); }
public async Task <List <AnomalyIdentity> > GetAllAnomaliesInCatchment(CatchmentIdentity catchmentIdentity) { var anomalies = await this.ExecuteInContextAsync(async dbContext => { var anomalyIdentityValues = await dbContext.AnomalyToCatchmentMappings.Where(x => x.CatchmentIdentity == catchmentIdentity.Value).Select(x => x.Anomaly.GUID).ToListAsync(); var output = anomalyIdentityValues.Select(x => AnomalyIdentity.From(x)).ToList(); return(output); }); return(anomalies); }
public async Task <List <ImageFileIdentity> > GetImageFiles(AnomalyIdentity anomalyIdentity) { var imageFileIdentities = await this.ExecuteInContextAsync(async dbContext => { var imageFileGuids = dbContext.AnomalyToImageFileMappings.Where(x => x.Anomaly.GUID == anomalyIdentity.Value).Select(x => x.ImageFileGUID); var output = await imageFileGuids.Select(x => ImageFileIdentity.From(x)).ToListAsync(); // Execute now. return(output); }); return(imageFileIdentities); }
public async Task <int> GetUpvotesCount(AnomalyIdentity anomalyIdentity) { var upvotesCount = await this.ExecuteInContext(async dbContext => { var output = await dbContext.GetAnomaly(anomalyIdentity) .Select(x => x.UpvotesCount) .SingleOrDefaultAsync(); return(output); }); return(upvotesCount); }
public async Task <LocationIdentity> GetReportedLocation(AnomalyIdentity anomalyIdentity) { var locationIdentity = await this.ExecuteInContext(async dbContext => { var locationIdentityValue = await dbContext.GetAnomaly(anomalyIdentity).Select(x => x.ReportedLocationGUID).SingleOrDefaultAsync(); var output = locationIdentityValue == null ? null : LocationIdentity.From(locationIdentityValue.Value); return(output); }); return(locationIdentity); }
public async Task <DateTime> GetReportedUTC(AnomalyIdentity anomalyIdentity) { var reportedUtc = await this.ExecuteInContext(async dbContext => { var reportedUtcValue = await dbContext.GetAnomaly(anomalyIdentity) .Select(x => x.ReportedUTC) .SingleOrDefaultAsync(); return(reportedUtcValue); }); return(reportedUtc); }
public static async Task <WasFound <ImageFileIdentity> > GetSingleImageForAnomaly( this IAnomalyRepository anomalyRepository, AnomalyIdentity anomalyIdentity) { var anomalyIdentities = EnumerableHelper.From(anomalyIdentity); var singleImageForAnomalies = await anomalyRepository.GetSingleImageForAnomalies(anomalyIdentities); var singleImageForAnomaly = singleImageForAnomalies.First(); var output = singleImageForAnomaly.ImageFileIdentityWasFound; return(output); }
public async Task <TextItemIdentity> GetTextItem(AnomalyIdentity anomalyIdentity, TextItemTypeIdentity textItemTypeIdentity) { var textItemIdentity = await this.ExecuteInContextAsync(async dbContext => { var output = await dbContext.AnomalyToTextItemMappings .Where(x => x.Anomaly.GUID == anomalyIdentity.Value && x.TextItemTypeGUID == textItemTypeIdentity.Value) .Select(x => TextItemIdentity.From(x.TextItemGUID)) .SingleAsync(); return(output); }); return(textItemIdentity); }
public async Task Add(AnomalyIdentity anomalyIdentity, DateTime reportedUTC) { await this.ExecuteInContextAsync(async dbContext => { var anomalyEntity = new Entities.Anomaly() { GUID = anomalyIdentity.Value, ReportedUTC = reportedUTC, }; dbContext.Anomalies.Add(anomalyEntity); await dbContext.SaveChangesAsync(); }); }
public async Task <List <CatchmentIdentity> > GetCatchments(AnomalyIdentity anomalyIdentity) { var catchmentIdentities = await this.ExecuteInContext(async dbContext => { var output = await dbContext.AnomalyToCatchmentMappings .Where(x => x.Anomaly.GUID == anomalyIdentity.Value) .Select(x => x.CatchmentIdentity) .Select(x => CatchmentIdentity.From(x)) .ToListAsync(); return(output); }); return(catchmentIdentities); }
public async Task <bool> AddCatchment(AnomalyIdentity anomalyIdentity, CatchmentIdentity catchmentIdentity) { return(await this.ExecuteInContext(async dbContext => { // Old version involved this // var mappingEntity = await dbContext.AnomalyToCatchmentMappings.Acquire(dbContext.Anomalies, anomalyIdentity.Value); // mappingEntity.CatchmentIdentity = catchmentIdentity.Value; // Get the anomaly ID from its GUID var anomalyID = await dbContext.GetAnomaly(anomalyIdentity.Value) .Select(x => x.ID) .SingleAsync(); // If the anomaly and catchment are already associated, do nothing. var exists = await dbContext.AnomalyToCatchmentMappings .Where(x => x.AnomalyID == anomalyID) .Where(x => x.CatchmentIdentity == catchmentIdentity.Value) .AnyAsync(); var actuallyAdded = false; if (!exists) { // Create new entity var newEntity = new Entities.AnomalyToCatchmentMapping { AnomalyID = anomalyID, CatchmentIdentity = catchmentIdentity.Value }; // Add it to the database and save dbContext.Add(newEntity); await dbContext.SaveChangesAsync(); actuallyAdded = true; } return actuallyAdded; })); }
public static IQueryable <AnomalyEntity> GetAnomaly(this IAnomalyDbContext dbContext, AnomalyIdentity anomalyIdentity) { var anomalyEntityQueryable = dbContext.GetAnomaly(anomalyIdentity.Value); return(anomalyEntityQueryable); }
public Task <LocationIdentity> GetReporterLocation(AnomalyIdentity anomalyIdentity) { throw new NotImplementedException(); }
public Task <List <Tuple <TextItemTypeIdentity, TextItemIdentity> > > GetTextItems(AnomalyIdentity anomalyIdentity) { throw new NotImplementedException(); }
public Task <(bool HasReporterLocation, LocationIdentity LocationIdentity)> HasReporterLocation(AnomalyIdentity anomalyIdentity) { throw new NotImplementedException(); }
public Task SetReporterLocation(AnomalyIdentity anomalyIdentity, LocationIdentity reporterLocation) { throw new NotImplementedException(); }
/// <summary> /// Returns the single catchment identity that the anomaly is currently mapped to. /// </summary> /// <param name="anomalyIdentity"></param> /// <returns></returns> public async Task <(bool HasCatchment, CatchmentIdentity CatchmentIdentity)> HasCatchment(AnomalyIdentity anomalyIdentity) { var hasOutput = await this.ExecuteInContext(async dbContext => { var output = await dbContext.AnomalyToCatchmentMappings.HasSingleAsync(x => x.Anomaly.GUID == anomalyIdentity.Value); //var output = await dbContext.AnomalyToCatchmentMappings.Include(x => x.Anomaly).HasSingleAsync(x => x.Anomaly.GUID.Value == anomalyIdentity.Value); //var output = dbContext.AnomalyToCatchmentMappings.Where(x => x.Anomaly.GUID.Value == anomalyIdentity.Value). return(output); }); var catchmentIdentity = hasOutput.Exists ? CatchmentIdentity.From(hasOutput.Result.CatchmentIdentity) : null; return(hasOutput.Exists, catchmentIdentity); }
public static async Task AddOnlyIfNotExistsAsync(this IAnomalyRepository anomalyRepository, AnomalyIdentity anomalyIdentity, DateTime reportedUTC) { var exists = await anomalyRepository.Exists(anomalyIdentity); if (!exists) { await anomalyRepository.Add(anomalyIdentity, reportedUTC); } }
public async Task <List <AnomalyInfo> > GetAnomalyInfos(List <AnomalyIdentity> anomalyIdentities) { var anomalyGuids = anomalyIdentities.Select(x => x.Value).ToList(); var output = await this.ExecuteInContextAsync(async dbContext => { // Get all the info, in rows. var query = from anomaly in dbContext.Anomalies where anomaly.GUID != null where anomalyGuids.Contains(anomaly.GUID) join anomalyCatchment in dbContext.AnomalyToCatchmentMappings on anomaly.ID equals anomalyCatchment.AnomalyID into catchmentGroup from c in catchmentGroup.DefaultIfEmpty() join anomalyText in dbContext.AnomalyToTextItemMappings on anomaly.ID equals anomalyText.AnomalyID into textGroup from t in textGroup.DefaultIfEmpty() join anomalyImage in dbContext.AnomalyToImageFileMappings on anomaly.ID equals anomalyImage.AnomalyID into imageGroup from i in imageGroup.DefaultIfEmpty() select new { anomaly.ID, anomaly.GUID, anomaly.ReportedUTC, anomaly.ReportedLocationGUID, anomaly.ReporterLocationGUID, CatchmentIdentity = c == default ? Guid.Empty : c.CatchmentIdentity, TextItemIdentity = t == default ? Guid.Empty : t.TextItemGUID, ImageIdentity = i == default ? Guid.Empty : i.ImageFileGUID, }; // Group it by anomaly (since we need an AnomalyInfo per AnomalyIdentity passed in) var result = await query.ToListAsync(); var grouped = result.GroupBy(group => new { group.ID, group.GUID, group.ReportedUTC, group.ReportedLocationGUID, group.ReporterLocationGUID }, group => group); // Use the grouping to put together anomaly infos. var anomalyInfos = new List <AnomalyInfo>(); foreach (var entry in grouped) { // Console.WriteLine(entry.Key); var images = new HashSet <Guid>(); var catchments = new HashSet <Guid>(); var textItemSet = new HashSet <Guid>(); foreach (var thing in entry) { images.Add(thing.ImageIdentity); catchments.Add(thing.CatchmentIdentity); textItemSet.Add(thing.TextItemIdentity); } var imagesList = images.ToList(); var catchmentsList = catchments.ToList(); var textItemsList = textItemSet.ToList(); // Console.WriteLine($" Images ({images.Count}): {string.Join(',',images.ToList())}"); // Console.WriteLine($" Catchments ({catchments.Count}): {string.Join(',', catchments.ToList())}"); // Console.WriteLine($" Text items ({textItemSet.Count}): {string.Join(',', textItemSet.ToList())}"); if (entry.Key.GUID == default) { // Unfortunately this also catches anomalies added with an all-zeros guid... // and we have at least one of those (ID 228 as of 2020-07-17) // throw new Exception("Got an anomaly without a GUID"); } var anomalyIdentity = new AnomalyIdentity(entry.Key.GUID); var reportedUTC = entry.Key.ReportedUTC; var reportedLocation = entry.Key.ReportedLocationGUID.HasValue ? LocationIdentity.From(entry.Key.ReportedLocationGUID.Value) : null; var reporterLocation = entry.Key.ReporterLocationGUID.HasValue ? LocationIdentity.From(entry.Key.ReporterLocationGUID.Value) : null; var catchmentIdentities = catchmentsList.Select(x => CatchmentIdentity.From(x)).ToList(); var imageFileIdentities = imagesList .Where(x => x != Guid.Empty) .Select(x => ImageFileIdentity.From(x)) .ToList(); var textItems = textItemsList.Select(x => TextItemIdentity.From(x)).ToList(); var info = new AnomalyInfo { AnomalyIdentity = anomalyIdentity, ReportedUTC = reportedUTC, ReportedLocationIdentity = reportedLocation, ReporterLocationIdentity = reporterLocation, CatchmentIdentities = catchmentIdentities, ImageFileIdentities = imageFileIdentities, TextItemsIdentities = textItems }; anomalyInfos.Add(info); } return(anomalyInfos); }); return(output); }
public async Task <AnomalyInfo> GetAnomalyInfo(AnomalyIdentity anomalyIdentity) { var anomalyInfo = await this.ExecuteInContextAsync(async dbContext => { var gettingAnomalyDetails = dbContext.GetAnomaly(anomalyIdentity) .Select(x => new { x.ReportedUTC, x.ReportedLocationGUID, x.ReporterLocationGUID, x.UpvotesCount, }) .SingleAsync(); var gettingImageFileIdentityValues = dbContext.GetAnomaly(anomalyIdentity) .Join(dbContext.AnomalyToImageFileMappings, anomaly => anomaly.ID, mapping => mapping.AnomalyID, (_, mapping) => mapping.ImageFileGUID) .ToListAsync(); var gettingTextItemIdentityValues = dbContext.GetAnomaly(anomalyIdentity) .Join(dbContext.AnomalyToTextItemMappings, anomaly => anomaly.ID, mapping => mapping.AnomalyID, (_, mapping) => mapping.TextItemGUID) .ToListAsync(); var gettingCatchmentMapping = dbContext.GetAnomaly(anomalyIdentity) .Join(dbContext.AnomalyToCatchmentMappings, anomaly => anomaly.ID, mapping => mapping.AnomalyID, (_, mapping) => mapping) .ToListAsync(); var anomalyDetails = await gettingAnomalyDetails; var imageFileIdentityValues = await gettingImageFileIdentityValues; var textItemIdentityValues = await gettingTextItemIdentityValues; var catchmentMapping = await gettingCatchmentMapping; var catchmentIdentities = catchmentMapping.Select(x => CatchmentIdentity.From(x.CatchmentIdentity)).ToList(); var imageFileIdentities = imageFileIdentityValues.Select(x => ImageFileIdentity.From(x)).ToList(); var reportedLocation = anomalyDetails.ReportedLocationGUID.HasValue ? LocationIdentity.From(anomalyDetails.ReportedLocationGUID.Value) : null; var reporterLocation = anomalyDetails.ReporterLocationGUID.HasValue ? LocationIdentity.From(anomalyDetails.ReporterLocationGUID.Value) : null; var reportedUTC = anomalyDetails.ReportedUTC; var textItems = textItemIdentityValues.Select(x => TextItemIdentity.From(x)).ToList(); var upvotesCount = anomalyDetails.UpvotesCount; var output = new AnomalyInfo() { AnomalyIdentity = anomalyIdentity, CatchmentIdentities = catchmentIdentities, ImageFileIdentities = imageFileIdentities, ReportedLocationIdentity = reportedLocation, ReporterLocationIdentity = reporterLocation, ReportedUTC = reportedUTC, TextItemsIdentities = textItems, UpvotesCount = upvotesCount, }; return(output); }); return(anomalyInfo); }