public static async Task <bool> Exists(this ITextItemRepository repository, Guid identity)
{
var textItemIdentity = TextItemIdentity.From(identity);
var exists = await repository.Exists(textItemIdentity);
return(exists);
}
public static async Task Append(this ITextItemRepository repository, TextItemIdentity identity, string appendix, string separator = StringHelper.Empty)
{
var value = repository.GetValue(identity);
var newValue = $"{value}{separator}{appendix}";
await repository.SetValue(identity, newValue);
}
public async Task <string> GetValue(TextItemIdentity identity)
{
var value = await this.ExecuteInContextAsync(async dbContext =>
{
var output = await dbContext.TextItems.Where(x => x.GUID == identity.Value).Select(x => x.Value).SingleAsync();
return(output);
});
return(value);
}
public async Task Delete(TextItemIdentity identity)
{
await this.ExecuteInContextAsync(async dbContext =>
{
var entity = await dbContext.TextItems.Where(x => x.GUID == identity.Value).SingleAsync();
dbContext.Remove(entity);
await dbContext.SaveChangesAsync();
});
}
public async Task SetValue(TextItemIdentity identity, string value)
{
await this.ExecuteInContextAsync(async dbContext =>
{
var entity = await dbContext.TextItems.Where(x => x.GUID == identity.Value).SingleAsync();
entity.Value = value;
dbContext.SaveChanges();
});
}
public async Task <bool> Exists(TextItemIdentity identity)
{
var exists = await this.ExecuteInContextAsync(async dbContext =>
{
var entity = await dbContext.TextItems.Where(x => x.GUID == identity.Value).SingleOrDefaultAsync();
var output = entity is object;
return(output);
});
return(exists);
}
public async Task <TextItemTypeIdentity> GetItemType(TextItemIdentity identity)
{
var textItemTypeIdentity = await this.ExecuteInContextAsync(async dbContext =>
{
var textItemTypeGuid = await dbContext.TextItems.Where(x => x.GUID == identity.Value).Select(x => x.TextItemType.GUID).SingleAsync();
var output = TextItemTypeIdentity.From(textItemTypeGuid);
return(output);
});
return(textItemTypeIdentity);
}
public async Task SetItemType(TextItemIdentity identity, TextItemTypeIdentity typeIdentity)
{
await this.ExecuteInContextAsync(async dbContext =>
{
var entity = await dbContext.TextItems.Where(x => x.GUID == identity.Value).SingleAsync();
var textItemTypeEntityID = await dbContext.TextItemTypes.Where(x => x.GUID == typeIdentity.Value).Select(x => x.ID).SingleAsync();
entity.TextItemTypeID = textItemTypeEntityID;
await dbContext.SaveChangesAsync();
});
}
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 <TextItemIdentity> New()
{
var textItemIdentity = TextItemIdentity.New();
await this.ExecuteInContextAsync(async dbContext =>
{
var textItemEntity = new Entities.TextItem()
{
GUID = textItemIdentity.Value,
};
dbContext.Add(textItemEntity);
await dbContext.SaveChangesAsync();
});
return(textItemIdentity);
}
public async Task <TextItemIdentity> New(TextItemTypeIdentity typeIdentity, string value)
{
var textItemIdentity = TextItemIdentity.New();
await this.ExecuteInContextAsync(async dbContext =>
{
var textItemTypeID = await dbContext.TextItemTypes.Where(x => x.GUID == typeIdentity.Value).Select(x => x.ID).SingleAsync();
var entity = new Entities.TextItem()
{
GUID = textItemIdentity.Value,
TextItemTypeID = textItemTypeID,
Value = value,
};
return(entity);
});
return(textItemIdentity);
}
public async Task <TextItemIdentity> Add(TextItem textItem)
{
var textItemIdentity = TextItemIdentity.New();
await this.ExecuteInContextAsync(async dbContext =>
{
var textItemTypeID = await dbContext.TextItemTypes.Where(x => x.GUID == textItem.Type.Identity.Value).Select(x => x.ID).SingleAsync();
var entity = new Entities.TextItem()
{
GUID = textItemIdentity.Value,
TextItemTypeID = textItemTypeID,
Value = textItem.Value,
};
dbContext.TextItems.Add(entity);
await dbContext.SaveChangesAsync();
});
return(textItemIdentity);
}
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);
}
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();
});
}
