/// <summary>
/// Updates the data row count for the log.
/// </summary>
/// <param name="uri">The URI.</param>
protected override void UpdateDataRowCount(EtpUri uri)
{
var current = GetEntity(uri);
var dataRowCount = ChannelDataChunkAdapter.GetDataRowCount(uri);
if (current.DataRowCount.Equals(dataRowCount))
{
return;
}
// Update the dataRowCount in the header
var updates = GetDataRowCountUpdate(null, current, dataRowCount);
var filter = MongoDbUtility.GetEntityFilter <Log>(uri);
var fields = MongoDbUtility.CreateUpdateFields <Log>();
Logger.Debug($"Updating dataRowCount for URI: {uri}");
updates = MongoDbUtility.BuildUpdate(updates, fields);
var mongoUpdate = new MongoDbUpdate <Log>(Container, GetCollection(), null, IdPropertyName);
mongoUpdate.UpdateFields(filter, updates);
// Join existing Transaction
var transaction = Transaction;
transaction.Attach(MongoDbAction.Update, DbCollectionName, IdPropertyName, current.ToBsonDocument(), uri);
transaction.Save();
}
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>());
}
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>());
}
/// <summary>
/// Updates the growing object's header and change history.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="updates">The header update definition.</param>
/// <param name="isAuditUpdate">if set to <c>true</c> audit the update.</param>
protected virtual void UpdateGrowingObject(EtpUri uri, UpdateDefinition <T> updates = null, bool isAuditUpdate = true)
{
var current = GetEntity(uri);
// Update the growing object's header
var filter = MongoDbUtility.GetEntityFilter <T>(uri);
var fields = MongoDbUtility.CreateUpdateFields <T>();
Logger.Debug($"Updating date time last change for URI: {uri}");
updates = MongoDbUtility.BuildUpdate(updates, fields);
var mongoUpdate = new MongoDbUpdate <T>(Container, GetCollection(), null, IdPropertyName);
mongoUpdate.UpdateFields(filter, updates);
// Join existing Transaction
var transaction = Transaction;
transaction.Attach(MongoDbAction.Update, DbCollectionName, IdPropertyName, current.ToBsonDocument(), uri);
transaction.Save();
if (!isAuditUpdate)
{
return;
}
var changeType = WitsmlOperationContext.Current.Request.Function == Functions.AddToStore
? Witsml141.ReferenceData.ChangeInfoType.add
: Witsml141.ReferenceData.ChangeInfoType.update;
// Audit entity
AuditEntity(uri, changeType);
}
public void DatabaseFromUrl()
{
var url = MongoDbUtility.GetMongoUrlFromConfig("MongoFrameworkTests");
var database = MongoDbUtility.GetDatabase(url);
Assert.IsNotNull(database);
}
/// <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);
}
/// <summary>
/// Updates the IsActive field of a wellbore.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="isActive">IsActive flag on wellbore is set to the value.</param>
public void UpdateIsActive(EtpUri uri, bool isActive)
{
var wellboreEntity = GetEntity(uri);
if (wellboreEntity == null)
{
Logger.DebugFormat("Wellbore not found with uri '{0}'", uri);
return;
}
if (wellboreEntity.IsActive.GetValueOrDefault() == isActive)
{
return;
}
Logger.DebugFormat("Updating wellbore isActive for uid '{0}' and name '{1}'.", wellboreEntity.Uuid, wellboreEntity.Citation.Title);
Transaction.Attach(MongoDbAction.Update, DbCollectionName, IdPropertyName, wellboreEntity.ToBsonDocument(), uri);
Transaction.Save();
var filter = MongoDbUtility.GetEntityFilter <Wellbore>(uri);
var wellboreUpdate = MongoDbUtility.BuildUpdate <Wellbore>(null, "IsActive", isActive);
var mongoUpdate = new MongoDbUpdate <Wellbore>(Container, GetCollection(), null);
mongoUpdate.UpdateFields(filter, wellboreUpdate);
}
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());
}
public void InvalidObjectId()
{
Assert.IsFalse(MongoDbUtility.IsValidObjectId(string.Empty));
Assert.IsFalse(MongoDbUtility.IsValidObjectId("0"));
Assert.IsFalse(MongoDbUtility.IsValidObjectId("a"));
Assert.IsFalse(MongoDbUtility.IsValidObjectId("0123456789ABCDEFGHIJKLMN"));
Assert.IsFalse(MongoDbUtility.IsValidObjectId(null));
}
/// <summary>
/// Gets the data row count update.
/// </summary>
/// <param name="logHeaderUpdate">The log header update.</param>
/// <param name="currentLog">The current log.</param>
/// <param name="dataRowCount">The data row count.</param>
/// <returns>
/// The current log header update.
/// </returns>
protected override UpdateDefinition <Log> GetDataRowCountUpdate(UpdateDefinition <Log> logHeaderUpdate, Log currentLog, int dataRowCount)
{
if (dataRowCount.Equals(currentLog.DataRowCount))
{
return(logHeaderUpdate);
}
logHeaderUpdate = MongoDbUtility.BuildUpdate(logHeaderUpdate, "DataRowCountSpecified", true);
return(MongoDbUtility.BuildUpdate(logHeaderUpdate, "DataRowCount", dataRowCount));
}
/// <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);
}
public void ValidObjectId()
{
var connection = TestConfiguration.GetConnection();
var context = new MongoDbContext(connection);
var entity = new MongoDbUtilityModel();
context.ChangeTracker.SetEntityState(entity, EntityEntryState.Added);
context.SaveChanges();
Assert.IsTrue(MongoDbUtility.IsValidObjectId(entity.Id));
}
/// <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);
}
public void ValidObjectId()
{
var database = TestConfiguration.GetDatabase();
var entityContainer = new DbEntityCollection <MongoDbUtilityModel>();
var writer = new DbEntityWriter <MongoDbUtilityModel>(database);
var entity = new MongoDbUtilityModel();
entityContainer.Update(entity, DbEntityEntryState.Added);
writer.Write(entityContainer);
Assert.IsTrue(MongoDbUtility.IsValidObjectId(entity.Id));
}
public void ValidObjectId()
{
var connection = TestConfiguration.GetConnection();
var writerPipeline = new EntityWriterPipeline <MongoDbUtilityModel>(connection);
var entityCollection = new EntityCollection <MongoDbUtilityModel>();
writerPipeline.AddCollection(entityCollection);
var entity = new MongoDbUtilityModel();
entityCollection.Update(entity, EntityEntryState.Added);
writerPipeline.Write();
Assert.IsTrue(MongoDbUtility.IsValidObjectId(entity.Id));
}
private void UpdateIndexInfo(EtpUri uri, IList <ChannelIndexInfo> indexInfos, TimeSpan?offset)
{
var entity = GetEntity(uri);
Logger.DebugFormat("Updating index info for uid '{0}' and name '{1}'.", entity.Uuid, entity.Citation.Title);
// Add ChannelIndex for each index
var headerUpdate = MongoDbUtility.BuildPushEach <ChannelSet, ChannelIndex>(null, "Index", indexInfos.Select(CreateChannelIndex));
// TODO: Update Citation
//headerUpdate = UpdateCommonData(headerUpdate, entity, offset);
var mongoUpdate = new MongoDbUpdate <ChannelSet>(Container, GetCollection(), null);
var filter = GetEntityFilter(uri);
mongoUpdate.UpdateFields(filter, headerUpdate);
}
private void UpdateChannels(EtpUri uri, ChannelDataReader reader, TimeSpan?offset)
{
var entity = GetEntity(uri);
Logger.DebugFormat("Updating channels for uid '{0}' and name '{1}'.", entity.Uuid, entity.Citation.Title);
var isTimeIndex = reader.Indices.Take(1).Select(x => x.IsTimeIndex).FirstOrDefault();
var channels = reader.Mnemonics
.Select((x, i) => new { Mnemonic = x, Index = i })
.Where(x => entity.Channel.GetByMnemonic(x.Mnemonic) == null)
.Select(x => CreateChannel(uri, x.Mnemonic, reader.Units[x.Index], reader.DataTypes[x.Index], isTimeIndex, entity.Index));
var mongoUpdate = new MongoDbUpdate <ChannelSet>(Container, GetCollection(), null);
var headerUpdate = MongoDbUtility.BuildPushEach <ChannelSet, Channel>(null, "Channel", channels);
var filter = GetEntityFilter(uri);
mongoUpdate.UpdateFields(filter, headerUpdate);
}
/// <summary>
/// Updates the common data.
/// </summary>
/// <param name="logHeaderUpdate">The log header update.</param>
/// <param name="entity">The entity.</param>
/// <param name="offset">The offset.</param>
/// <returns></returns>
protected override UpdateDefinition <Log> UpdateCommonData(UpdateDefinition <Log> logHeaderUpdate, Log entity, TimeSpan?offset)
{
if (entity?.CommonData == null)
{
return(logHeaderUpdate);
}
if (entity.CommonData.DateTimeCreation.HasValue)
{
var creationTime = entity.CommonData.DateTimeCreation.ToOffsetTime(offset);
logHeaderUpdate = MongoDbUtility.BuildUpdate(logHeaderUpdate, "CommonData.DateTimeCreation", creationTime?.ToString("o"));
Logger.DebugFormat("Updating Common Data create time to '{0}'", creationTime);
}
if (entity.CommonData.DateTimeLastChange.HasValue)
{
var updateTime = entity.CommonData.DateTimeLastChange.ToOffsetTime(offset);
logHeaderUpdate = MongoDbUtility.BuildUpdate(logHeaderUpdate, "CommonData.DateTimeLastChange", updateTime?.ToString("o"));
Logger.DebugFormat("Updating Common Data update time to '{0}'", updateTime);
}
return(logHeaderUpdate);
}
/// <summary>
/// Updates the growing status for the specified growing object. If isObjectGrowing has a value it will update
/// the objectGrowing flag for the entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="updates">The header update definition.</param>
/// <param name="isObjectGrowing">Is the object currently growing.</param>
protected virtual void UpdateGrowingObject(T entity, UpdateDefinition <T> updates, bool?isObjectGrowing = null)
{
var uri = GetUri(entity);
var isCurrentObjectGrowing = IsObjectGrowing(entity);
var isAuditUpdate = !isObjectGrowing.GetValueOrDefault();
// Set change history object growing flag
var changeHistory = AuditHistoryAdapter.GetCurrentChangeHistory();
changeHistory.ObjectGrowingState = isCurrentObjectGrowing;
// Check to see if the object growing flag needs to be toggled
if (isObjectGrowing.HasValue && isCurrentObjectGrowing != isObjectGrowing)
{
// Only allow DbGrowingObjectDataAdapter to set flag to false
Logger.Debug($"Updating object growing flag for URI: {uri}; Value: {isObjectGrowing.Value}");
var flag = MongoDbUtility.CreateObjectGrowingFields <T>(isObjectGrowing.Value);
updates = MongoDbUtility.BuildUpdate(updates, flag);
// Only audit an append of data when first toggling object growing flag
changeHistory.ObjectGrowingState = isObjectGrowing;
isAuditUpdate = true;
}
UpdateGrowingObject(uri, updates, isAuditUpdate);
// If the object is not currently growing do not update wellbore isActive
if (!isObjectGrowing.GetValueOrDefault())
{
return;
}
// Update dbGrowingObject timestamp
DbGrowingObjectAdapter.UpdateLastAppendDateTime(uri, GetWellboreUri(uri));
// Update Wellbore isActive
UpdateWellboreIsActive(uri, true);
}
/// <summary>
/// Updates the IsActive field of a wellbore.
/// </summary>
/// <param name="uri">The URI.</param>
/// <param name="isActive">IsActive flag on wellbore is set to the value.</param>
public void UpdateIsActive(EtpUri uri, bool isActive)
{
var wellboreEntity = GetEntity(uri);
if (wellboreEntity == null)
{
Logger.DebugFormat("Wellbore not found with uri '{0}'", uri);
return;
}
if (wellboreEntity.IsActive.GetValueOrDefault() == isActive)
{
return;
}
Logger.DebugFormat("Updating wellbore isActive for uid '{0}' and name '{1}'.", wellboreEntity.Uuid, wellboreEntity.Citation.Title);
var filter = MongoDbUtility.GetEntityFilter <Wellbore>(uri);
var fields = MongoDbUtility.CreateUpdateFields <Wellbore>();
var wellboreUpdate = MongoDbUtility.BuildUpdate <Wellbore>(null, "IsActive", isActive);
wellboreUpdate = MongoDbUtility.BuildUpdate(wellboreUpdate, fields);
var mongoUpdate = new MongoDbUpdate <Wellbore>(Container, GetCollection(), null);
mongoUpdate.UpdateFields(filter, wellboreUpdate);
// Join existing Transaction
var transaction = Transaction;
transaction.Attach(MongoDbAction.Update, DbCollectionName, IdPropertyName, wellboreEntity.ToBsonDocument(), uri);
transaction.Save();
// Audit entity
AuditEntity(uri, Energistics.DataAccess.WITSML141.ReferenceData.ChangeInfoType.update);
}
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 UrlFromConfigFound()
{
var url = MongoDbUtility.GetMongoUrlFromConfig("MongoFrameworkTests");
Assert.IsNotNull(url);
}
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);
}
public void DatabaseFromNullUrl()
{
MongoDbUtility.GetDatabase((MongoDB.Driver.MongoUrl)null);
}
public void DatabaseFromNullOptions()
{
MongoDbUtility.GetDatabase((IMongoDbContextOptions)null);
}
private long GetActiveWellboreCount(string wellboreUri)
{
var filter = MongoDbUtility.BuildFilter <DbGrowingObject>("WellboreUri", wellboreUri);
return(GetCollection().CountDocuments(filter));
}
private FilterDefinition <BsonDocument> GetDocumentFilter(EtpUri uri, string idPropertyName)
{
return(MongoDbUtility.GetEntityFilter <BsonDocument>(uri, idPropertyName));
}
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);
}
}
}
public void UrlFromConfigMissing()
{
var url = MongoDbUtility.GetMongoUrlFromConfig("ThisConnectionStringDoesntExist");
Assert.IsNull(url);
}
/// <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()));
}
