private List <Channel> GetChannelsByUris(params EtpUri[] uris)
{
if (uris.Any(u => u.IsBaseUri))
{
return(GetAll(null));
}
var channelUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Channel);
var wellboreUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Wellbore);
var wellUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Well);
if (wellUris.Any())
{
var wellboreFilters = wellUris.Select(wellUri => MongoDbUtility.BuildFilter <Wellbore>("Well.Uuid", wellUri.ObjectId)).ToList();
var wellbores = GetCollection <Wellbore>(ObjectNames.Wellbore200)
.Find(Builders <Wellbore> .Filter.Or(wellboreFilters)).ToList();
wellboreUris.AddRange(wellbores.Select(w => w.GetUri()).Where(u => !wellboreUris.Contains(u)));
}
var channelFilters = wellboreUris.Select(wellboreUri => MongoDbUtility.BuildFilter <Channel>("Wellbore.Uuid", wellboreUri.ObjectId)).ToList();
channelFilters.AddRange(channelUris.Select(u => MongoDbUtility.GetEntityFilter <Channel>(u, IdPropertyName)));
return(channelFilters.Any() ? GetCollection().Find(Builders <Channel> .Filter.Or(channelFilters)).ToList() : new List <Channel>());
}
private List <Log> GetLogsByUris(List <EtpUri> uris)
{
if (uris.Any(u => u.IsBaseUri))
{
return(GetAll(null));
}
var logUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Log);
var wellboreUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Wellbore);
var wellUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Well);
if (wellUris.Any())
{
var wellboreFilters = wellUris.Select(wellUri => MongoDbUtility.BuildFilter <Wellbore>("Well.Uuid", wellUri.ObjectId)).ToList();
var wellbores = GetCollection <Wellbore>(ObjectNames.Wellbore200)
.Find(Builders <Wellbore> .Filter.Or(wellboreFilters)).ToList();
wellboreUris.AddRange(wellbores.Select(w => w.GetUri()).Where(u => !wellboreUris.Contains(u)));
}
var logFilters = wellboreUris.Select(wellboreUri => MongoDbUtility.BuildFilter <Log>("Wellbore.Uuid", wellboreUri.ObjectId)).ToList();
logFilters.AddRange(logUris.Select(logUri => MongoDbUtility.GetEntityFilter <Log>(logUri, IdPropertyName)));
return(logFilters.Any() ? GetCollection().Find(Builders <Log> .Filter.Or(logFilters)).ToList() : new List <Log>());
}
/// <summary>
/// Deletes the transactions.
/// </summary>
/// <param name="transactionId">The tid.</param>
public void DeleteTransactions(string transactionId)
{
var collection = GetCollection();
var filter = MongoDbUtility.BuildFilter <MongoDbTransaction>(TransactionIdField, transactionId);
collection.DeleteMany(filter);
}
private List <ChannelDataChunk> GetDataChunks(EtpUri uri)
{
var filter = MongoDbUtility.BuildFilter <ChannelDataChunk>("Uri", uri.ToString());
var database = _provider.GetDatabase();
var collection = database.GetCollection <ChannelDataChunk>("channelDataChunk");
return(collection.Find(filter).ToList());
}
/// <summary>
/// Updates the entities.
/// </summary>
/// <param name="transactionId">The transaction identifier.</param>
/// <param name="newTransactionId">The new transaction identifier.</param>
public void UpdateEntities(string transactionId, string newTransactionId)
{
Logger.Debug($"Transferring transactions from Transaction ID: {transactionId} to {newTransactionId}");
var filter = MongoDbUtility.BuildFilter <DbTransaction>(TransactionIdField, transactionId);
var update = MongoDbUtility.BuildUpdate <DbTransaction>(null, TransactionIdField, newTransactionId);
var collection = GetCollection();
collection.UpdateMany(filter, update);
}
/// <summary>
/// Deletes the transactions.
/// </summary>
/// <param name="transactionId">The tid.</param>
public void DeleteTransactions(string transactionId)
{
Logger.Debug($"Deleting transactions for Transaction ID: {transactionId}");
// Delete the binary files
DeleteTransactionMongoFiles(transactionId);
// Delete the document
var collection = GetCollection();
var filter = MongoDbUtility.BuildFilter <DbTransaction>(TransactionIdField, transactionId);
collection.DeleteMany(filter);
}
private List <ChannelSet> GetChannelSetByUris(List <EtpUri> uris)
{
if (uris.Any(u => u.IsBaseUri))
{
return(GetAll(null));
}
_wellboreUris = new List <EtpUri>();
_channelSetUris = new List <EtpUri>();
var channelSetUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.ChannelSet);
var wellboreUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Wellbore);
var wellUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Well);
if (wellUris.Any())
{
var wellboreFilters = wellUris.Select(wellUri => MongoDbUtility.BuildFilter <Wellbore>("Well.Uuid", wellUri.ObjectId)).ToList();
var wellbores = GetCollection <Wellbore>(ObjectNames.Wellbore200)
.Find(Builders <Wellbore> .Filter.Or(wellboreFilters)).ToList();
wellboreUris.AddRange(wellbores.Select(w => w.GetUri()).Where(u => !wellboreUris.Contains(u)));
}
_wellboreUris.AddRange(wellboreUris);
var channelSetFilters = wellboreUris.Select(wellboreUri => MongoDbUtility.BuildFilter <ChannelSet>("Wellbore.Uuid", wellboreUri.ObjectId)).ToList();
_channelSetUris.AddRange(channelSetUris);
channelSetFilters.AddRange(channelSetUris.Select(GetEntityFilter));
var channelUris = MongoDbUtility.GetObjectUris(uris, ObjectTypes.Channel).Where(u => u.Parent.ObjectType == ObjectTypes.ChannelSet);
foreach (var channelUri in channelUris)
{
channelSetFilters.Add(MongoDbUtility.BuildFilter <ChannelSet>(IdPropertyName, channelUri.Parent.ObjectId));
}
return(channelSetFilters.Any() ? GetCollection().Find(Builders <ChannelSet> .Filter.Or(channelSetFilters)).ToList() : new List <ChannelSet>());
}
public void Log141Adapter_AddToStore_Can_Add_Data_Chunk_Exceeds_MongoDb_Document_Size()
{
var response = _devKit.Add <WellList, Well>(_well);
// Adjust Points and Nodes for large file
WitsmlSettings.LogMaxDataPointsAdd = 5000000;
WitsmlSettings.LogMaxDataNodesAdd = 15000;
WitsmlSettings.LogMaxDataPointsGet = 5000000;
WitsmlSettings.LogMaxDataNodesGet = 15000;
_wellbore.UidWell = response.SuppMsgOut;
response = _devKit.Add <WellboreList, Wellbore>(_wellbore);
var xmlfile = Path.Combine(_testDataDir, string.Format(_exceedFileFormat, "log"));
var xmlin = File.ReadAllText(xmlfile);
var logList = EnergisticsConverter.XmlToObject <LogList>(xmlin);
Assert.IsNotNull(logList);
var log = logList.Log.FirstOrDefault();
Assert.IsNotNull(log);
log.Uid = null;
log.UidWell = _wellbore.UidWell;
log.UidWellbore = response.SuppMsgOut;
log.NameWell = _well.Name;
log.NameWellbore = _wellbore.Name;
var logDataAdded = log.LogData.FirstOrDefault();
Assert.IsNotNull(logDataAdded);
response = _devKit.Add <LogList, Log>(log);
Assert.AreEqual((short)ErrorCodes.Success, response.Result);
var uidLog = response.SuppMsgOut;
log.Uid = uidLog;
var uri = log.GetUri();
// Query Channel Data Chunk
var filter = MongoDbUtility.BuildFilter <ChannelDataChunk>("Uri", uri.ToString());
var database = _provider.GetDatabase();
var collection = database.GetCollection <ChannelDataChunk>("channelDataChunk");
var chunks = collection.Find(filter).ToList();
Assert.IsTrue(chunks.Count > 0);
// Query Mongo File
var fileChunks = chunks.Where(c => string.IsNullOrEmpty(c.Data)).ToList();
Assert.IsTrue(fileChunks.Count > 0);
var bucket = new GridFSBucket(database, new GridFSBucketOptions
{
BucketName = ChannelDataChunkAdapter.BucketName,
ChunkSizeBytes = WitsmlSettings.ChunkSizeBytes
});
foreach (var fc in fileChunks)
{
Assert.IsNull(fc.Data);
var mongoFileFilter = Builders <GridFSFileInfo> .Filter.Eq(fi => fi.Metadata[ChannelDataChunkAdapter.FileName], fc.Uid);
var mongoFile = bucket.Find(mongoFileFilter).FirstOrDefault();
Assert.IsNotNull(mongoFile);
}
// Query Log
var query = new Log
{
Uid = uidLog,
UidWell = log.UidWell,
UidWellbore = log.UidWellbore
};
var results = _devKit.Query <LogList, Log>(query, optionsIn: OptionsIn.ReturnElements.All);
Assert.AreEqual(1, results.Count);
var result = results.First();
Assert.IsNotNull(result);
var logDataReturned = result.LogData.FirstOrDefault();
Assert.IsNotNull(logDataReturned);
Assert.AreEqual(logDataAdded.Data.Count, logDataReturned.Data.Count);
}
private long GetActiveWellboreCount(string wellboreUri)
{
var filter = MongoDbUtility.BuildFilter <DbGrowingObject>("WellboreUri", wellboreUri);
return(GetCollection().CountDocuments(filter));
}
/// <summary>
/// Gets the entity filter for the specified URI.
/// </summary>
/// <typeparam name="TObject">The type of the object.</typeparam>
/// <param name="uri">The URI.</param>
/// <param name="idPropertyName">Name of the identifier property.</param>
/// <returns>The entity filter.</returns>
protected override FilterDefinition <TObject> GetEntityFilter <TObject>(EtpUri uri, string idPropertyName)
{
return(MongoDbUtility.BuildFilter <TObject>(idPropertyName, uri.ToString()));
}
private void UpdateIndexRange(EtpUri uri, ChannelSet entity, Dictionary <string, Range <double?> > ranges, IEnumerable <string> mnemonics)
{
var mongoUpdate = new MongoDbUpdate <ChannelSet>(Container, GetCollection(), null);
var channelIndexUpdate = default(UpdateDefinition <ChannelSet>);
var filter = GetEntityFilter(uri);
if (entity.Citation != null)
{
if (entity.Citation.Creation.HasValue)
{
var creationTime = entity.Citation.Creation;
channelIndexUpdate = MongoDbUtility.BuildUpdate(channelIndexUpdate, "Citation.Creation", creationTime.Value.ToUniversalTime().ToString(_utcFormat));
}
if (entity.Citation.LastUpdate.HasValue)
{
var updateTime = entity.Citation.LastUpdate;
channelIndexUpdate = MongoDbUtility.BuildUpdate(channelIndexUpdate, "Citation.LastUpdate", updateTime.Value.ToUniversalTime().ToString(_utcFormat));
}
}
var indexChannel = entity.Index.FirstOrDefault();
var indexType = indexChannel.IndexType;
var indexMnemonic = indexChannel.Mnemonic;
var range = ranges[indexMnemonic];
if (range.Start.HasValue)
{
var start = UpdateIndexValue(indexType, entity.StartIndex, range.Start.Value);
channelIndexUpdate = MongoDbUtility.BuildUpdate(channelIndexUpdate, "StartIndex", start);
}
if (range.End.HasValue)
{
var end = UpdateIndexValue(indexType, entity.EndIndex, range.End.Value);
channelIndexUpdate = MongoDbUtility.BuildUpdate(channelIndexUpdate, "EndIndex", end);
}
if (channelIndexUpdate != null)
{
mongoUpdate.UpdateFields(filter, channelIndexUpdate);
}
var idField = MongoDbUtility.LookUpIdField(typeof(Channel), "Uuid");
foreach (var mnemonic in mnemonics)
{
var channel = entity.Channel.FirstOrDefault(c => c.Mnemonic.EqualsIgnoreCase(mnemonic));
if (channel == null)
{
continue;
}
var channelFilter = Builders <ChannelSet> .Filter.And(filter,
MongoDbUtility.BuildFilter <ChannelSet>("Channel." + idField, channel.Uuid));
UpdateDefinition <ChannelSet> updates = null;
range = ranges[mnemonic];
if (range.Start.HasValue)
{
var start = UpdateIndexValue(indexType, channel.StartIndex, range.Start.Value);
updates = MongoDbUtility.BuildUpdate(updates, "Channel.$.StartIndex", start);
}
if (range.End.HasValue)
{
var end = UpdateIndexValue(indexType, channel.EndIndex, range.End.Value);
updates = MongoDbUtility.BuildUpdate(updates, "Channel.$.EndIndex", end);
}
if (updates != null)
{
mongoUpdate.UpdateFields(channelFilter, updates);
}
}
}