public static async Task <bool> Exists(this ITextItemRepository repository, Guid identity)
        {
            var textItemIdentity = TextItemIdentity.From(identity);

            var exists = await repository.Exists(textItemIdentity);

            return(exists);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #4
0
        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);
        }