public async Task <ImageFileIdentity> AddImage(Stream imageFileStream, FileName imageFileName, FileFormat fileFormat) { var imageFileIdentity = ImageFileIdentity.New(); // Get unique file-name from image file identity. var uniqueImageFileName = imageFileIdentity.GetUniqueFileName(); // Get the storage file path of the image file, using a single directory path and a globally-unique file name. var uniqueImageFilePath = this.GetUniqueImageFilePath(uniqueImageFileName); // Write the image file from its input stream to its unique local file path. using (var file = File.Open(uniqueImageFilePath.Value, FileMode.CreateNew)) // Throw an exception if the file already exists by using create-new. { await imageFileStream.CopyToAsync(file); } // Add the file info to the repository. var fileIdentity = imageFileIdentity.GetFileIdentity(); var fileInfo = new FileInfoAppType() { FileIdentity = fileIdentity, FilePath = uniqueImageFilePath, FileFormat = fileFormat, }; await this.LocalFileInfoRepository.Add(fileInfo); // Now add the unique file-name to original file-name mapping. await this.OriginalFileNameMappingRepository.Add(uniqueImageFileName, imageFileName); // Return the image file identity. return(imageFileIdentity); }
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; })); }
private FilePath GetUniqueImageFilePath(ImageFileIdentity imageFileIdentity) { var uniqueImageFileName = imageFileIdentity.GetUniqueFileName(); var uniqueImageFilePath = this.GetUniqueImageFilePath(uniqueImageFileName); return(uniqueImageFilePath); }
public async Task <FileFormat> GetImageFileFormat(ImageFileIdentity imageFileIdentity) { var fileIdentity = imageFileIdentity.GetFileIdentity(); var fileFormat = await this.LocalFileInfoRepository.GetFileFormat(fileIdentity); return(fileFormat); }
public static FileName GetUniqueFileName(this ImageFileIdentity imageFileIdentity) { var uniqueFileNameValue = imageFileIdentity.GetUniqueFileNameValue(); var uniqueFileName = FileName.New(uniqueFileNameValue); return(uniqueFileName); }
public async Task <bool> Exists(ImageFileIdentity imageFileIdentity) { var fileIdentity = imageFileIdentity.GetFileIdentity(); var exists = await this.LocalFileInfoRepository.Exists(fileIdentity); return(exists); }
/// <summary> /// This, in context, means the original image file name. /// </summary> public async Task <FileName> GetImageFileName(ImageFileIdentity imageFileIdentity) { // Can get the unique image file-name directly from the image file identity. var uniqueImageFileName = imageFileIdentity.GetUniqueFileName(); var originalImageFileName = await this.OriginalFileNameMappingRepository.GetOriginalImageFileName(uniqueImageFileName); return(originalImageFileName); }
public async Task SetImageData(ImageFileIdentity imageFileIdentity, Stream imageFileStream) { var uniqueImageFilePath = this.GetUniqueImageFilePath(imageFileIdentity); // Overwrite. using (var file = File.OpenWrite(uniqueImageFilePath.Value)) { await imageFileStream.CopyToAsync(file); } }
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 Task <Stream> GetImageFileStream(ImageFileIdentity imageFileIdentity) { var uniqueImageFilePath = this.GetUniqueImageFilePath(imageFileIdentity); // For times when the file doesn't exist (particularly common in dev, but happens in prod too) // return a null stream. And hope for the best from there. if (!File.Exists(uniqueImageFilePath.Value)) { return(Task.FromResult <Stream>(Stream.Null)); } var imageFileStream = File.OpenRead(uniqueImageFilePath.Value); return(Task.FromResult <Stream>(imageFileStream)); }
public async Task <ImageFileReadInfo> GetReadInfo(ImageFileIdentity imageFileIdentity) { var getImageFileStream = this.GetImageFileStream(imageFileIdentity); var getImageFileName = this.GetImageFileName(imageFileIdentity); var getImageFileFormat = this.GetImageFileFormat(imageFileIdentity); var imageFileStream = await getImageFileStream; var originalImageFileName = await getImageFileName; var imageFileFormat = await getImageFileFormat; var readInfo = new ImageFileReadInfo() { Identity = imageFileIdentity, Stream = imageFileStream, FileName = originalImageFileName, FileFormat = imageFileFormat, }; return(readInfo); }
public async Task Delete(ImageFileIdentity imageFileIdentity) { var uniqueImageFileName = imageFileIdentity.GetUniqueFileName(); var uniqueImageFilePath = this.GetUniqueImageFilePath(uniqueImageFileName); // The multiple tasks are sequentially awaited to allow failures to preserve the sequence of events in case of failure. // (The alternative would have been to Task.WhenAll() the various tasks, which would be simultaneous, but would lead to situations where things might get out of whack in case of failure.) // Delete the image file. await FileHelper.DeleteAsync(uniqueImageFilePath.Value); // Remove the local file info. var fileIdentity = imageFileIdentity.GetFileIdentity(); await this.LocalFileInfoRepository.Delete(fileIdentity); // Delete the original image name mapping. await this.OriginalFileNameMappingRepository.Delete(uniqueImageFileName); }
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); }
public static string GetUniqueFileNameValue(this ImageFileIdentity imageFileIdentity) { var uniqueFileNameValue = imageFileIdentity.Value.ToStringStandard(); return(uniqueFileNameValue); }
public static FileIdentity GetFileIdentity(this ImageFileIdentity imageFileIdentity) { var fileIdentity = FileIdentity.New(imageFileIdentity.Value); return(fileIdentity); }
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); }