public async Task Should_enrich_with_old_data_if_updated()
{
var ctx = Context();
var @event = new ContentUpdated {
AppId = ctx.AppId, ContentId = DomainId.NewGuid(), SchemaId = schemaMatch
};
var envelope = Envelope.Create <AppEvent>(@event).SetEventStreamNumber(12);
var dataNow = new ContentData();
var dataOld = new ContentData();
A.CallTo(() => contentLoader.GetAsync(ctx.AppId.Id, @event.ContentId, 12))
.Returns(new ContentEntity {
AppId = ctx.AppId, SchemaId = schemaMatch, Version = 12, Data = dataNow, Id = @event.ContentId
});
A.CallTo(() => contentLoader.GetAsync(ctx.AppId.Id, @event.ContentId, 11))
.Returns(new ContentEntity {
AppId = ctx.AppId, SchemaId = schemaMatch, Version = 11, Data = dataOld
});
var result = await sut.CreateEnrichedEventsAsync(envelope, ctx, default).ToListAsync();
var enrichedEvent = result.Single() as EnrichedContentEvent;
Assert.Same(dataNow, enrichedEvent !.Data);
Assert.Same(dataOld, enrichedEvent !.DataOld);
}
public async Task Should_enrich_with_old_data_when_updated()
{
var @event = new ContentUpdated();
var envelope = Envelope.Create <AppEvent>(@event).SetEventStreamNumber(12);
var dataNow = new NamedContentData();
var dataOld = new NamedContentData();
A.CallTo(() => contentLoader.GetAsync(@event.ContentId, 12))
.Returns(new ContentEntity {
SchemaId = SchemaMatch, Version = 12, Data = dataNow
});
A.CallTo(() => contentLoader.GetAsync(@event.ContentId, 11))
.Returns(new ContentEntity {
SchemaId = SchemaMatch, Version = 11, Data = dataOld
});
var result = await sut.CreateEnrichedEventsAsync(envelope);
var enrichedEvent = result.Single() as EnrichedContentEvent;
Assert.Same(dataNow, enrichedEvent !.Data);
Assert.Same(dataOld, enrichedEvent !.DataOld);
}
public void Should_calculate_name_for_updated()
{
var @event = new ContentUpdated {
SchemaId = schemaMatch
};
Assert.Equal("MySchema1Updated", sut.GetName(@event));
}
protected void On(ContentUpdated @event)
{
DataDraft = @event.Data;
if (Data != null)
{
Data = @event.Data;
}
}
protected Task On(ContentUpdated @event, EnvelopeHeaders headers)
{
return(ForSchemaAsync(@event.SchemaId.Id, (collection, schemaEntity) =>
{
return collection.UpdateAsync(@event, headers, x =>
{
x.SetData(schemaEntity.Schema, @event.Data);
});
}));
}
public void Should_return_plain_value_when_found_from_update_event()
{
var @event = new ContentUpdated
{
Data =
new NamedContentData()
.AddField("city",
new ContentFieldData()
.AddValue("iv", "Berlin"))
};
var result = sut.FormatString("$CONTENT_DATA.city.iv", AsEnvelope(@event));
Assert.Equal("Berlin", result);
}
private async Task UpdateAsync(ContentUpdated @event)
{
var state = await textIndexerState.GetAsync(@event.ContentId);
if (state != null)
{
if (state.DocIdNew != null)
{
await IndexAsync(@event,
new UpsertIndexEntry
{
ContentId = @event.ContentId,
DocId = state.DocIdNew,
ServeAll = true,
ServePublished = false,
Texts = @event.Data.ToTexts()
},
new UpdateIndexEntry
{
DocId = state.DocIdCurrent,
ServeAll = false,
ServePublished = true
});
state.DocIdForPublished = state.DocIdCurrent;
}
else
{
var isPublished = state.DocIdCurrent == state.DocIdForPublished;
await IndexAsync(@event,
new UpsertIndexEntry
{
ContentId = @event.ContentId,
DocId = state.DocIdCurrent,
ServeAll = true,
ServePublished = isPublished,
Texts = @event.Data.ToTexts()
});
state.DocIdForPublished = state.DocIdNew;
}
await textIndexerState.SetAsync(state);
}
}
protected Task On(ContentUpdated @event, EnvelopeHeaders headers)
{
return(ForSchemaAsync(@event.AppId, @event.SchemaId.Id, (collection, schema) =>
{
var idData = @event.Data?.ToIdModel(schema.SchemaDef, true);
return collection.UpdateOneAsync(
Filter.Eq(x => x.Id, @event.ContentId),
Update
.Set(x => x.DataText, idData.ToFullText())
.Set(x => x.IdData, idData)
.Set(x => x.ReferencedIds, idData.ToReferencedIds(schema.SchemaDef))
.Set(x => x.LastModified, headers.Timestamp())
.Set(x => x.LastModifiedBy, @event.Actor)
.Set(x => x.Version, headers.EventStreamNumber()));
}));
}
public override void Execute()
{
if (ContentUpdated.EndsWith(BibaContentConstants.ACHIEVEMENT_SETTINGS_FILE))
{
AchievementService.ReloadContent();
}
if (ContentUpdated.EndsWith(BibaContentConstants.LOCALIZATION_SETTINGS_FILE))
{
LocalizationService.ReloadContent();
}
if (ContentUpdated.EndsWith(BibaContentConstants.SPECIAL_SCENE_SETTINGS_FILE))
{
SpecialSceneService.ReloadContent();
}
}
public async Task Should_load_content_from_correct_version()
{
var eventData1 = new EventData();
var eventData2 = new EventData();
var eventData3 = new EventData();
var event1 = new ContentCreated {
Data = new NamedContentData(), AppId = new NamedId <Guid>(appId, "my-app")
};
var event2 = new ContentUpdated {
Data = new NamedContentData()
};
var event3 = new ContentUpdated {
Data = new NamedContentData()
};
var events = new List <StoredEvent>
{
new StoredEvent("0", 0, eventData1),
new StoredEvent("1", 1, eventData2),
new StoredEvent("2", 2, eventData3)
};
A.CallTo(() => eventStore.GetEventsAsync(streamName))
.Returns(events);
A.CallTo(() => formatter.Parse(eventData1, true))
.Returns(new Envelope <IEvent>(event1));
A.CallTo(() => formatter.Parse(eventData2, true))
.Returns(new Envelope <IEvent>(event2));
A.CallTo(() => formatter.Parse(eventData3, true))
.Returns(new Envelope <IEvent>(event3));
var data = await sut.LoadAsync(appId, id, 1);
Assert.Equal(event2.Data, data);
}
void OnContentUpdated(string location, bool removed)
{
ContentUpdated?.Invoke(this, new ContentUpdatedEventArgs(location, removed));
}
protected void NotifyContentUpdated()
{
ContentUpdated?.Invoke(this, EventArgs.Empty);
}
void UpdateControls(Size screenSize)
{
ContentUpdated?.Invoke(GetViewportBoundaries(screenSize));
}
private void SyncDatabaseToImageRecList(IEnumerable <ImageRec> filesOnDisk, Theme theme, Database db, CancellationToken cancel)
{
var table = db.SelectDataTable("select rowid, * from img where location_id = @id", "@id", _rowid);
// Find files in the database that don't exist on disk
var filesToRemove = new List <long>();
foreach (DataRow row in table.Rows)
{
if (cancel.IsCancellationRequested)
{
return;
}
var path = (string)row["path"];
var found = false;
foreach (var file in filesOnDisk)
{
if (string.Equals(file.Location, path, StringComparison.OrdinalIgnoreCase))
{
found = true;
break;
}
}
if (!found)
{
filesToRemove.Add((long)row["rowid"]);
}
}
var changesMade = false;
using (var tran = db.BeginTransaction())
{
if (filesToRemove.Count > 0)
{
using (var cmd = db.CreateCommand("delete from img where rowid = @rowid"))
{
foreach (var rowid in filesToRemove)
{
if (cancel.IsCancellationRequested)
{
return;
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@rowid", rowid);
cmd.ExecuteNonQuery();
changesMade = true;
}
}
}
// Find files on disk that don't exist in the database
var filesToAdd = new List <ImageRec>();
foreach (var file in filesOnDisk)
{
if (cancel.IsCancellationRequested)
{
return;
}
DataRow foundRow = null;
foreach (DataRow row in table.Rows)
{
if (cancel.IsCancellationRequested)
{
return;
}
if (string.Equals(file.Location, (string)row["path"], StringComparison.OrdinalIgnoreCase))
{
foundRow = row;
break;
}
}
if (foundRow == null)
{
filesToAdd.Add(file);
}
else
{
// Check if new cache path needs to be updated in the img table
if (file.Type == ImageLocationType.Url && string.IsNullOrEmpty(file.LocationOnDisk))
{
string cachePathName;
if (ImageCache.TryGetCachedImage(db, file.Location, out cachePathName))
{
db.ExecuteNonQuery("update img set cache_path = @cache_path where path = @path",
"@cache_path", cachePathName,
"@path", file.Location);
db.ExecuteNonQuery("update history set cache_path = @cache_path where path = @path",
"@cache_path", cachePathName,
"@path", file.Location);
changesMade = true;
}
}
// Check if the size needs updating
if (foundRow.GetLong("size", -1) == -1 && !string.IsNullOrEmpty(file.LocationOnDisk))
{
file.RefreshFileSize();
var size = file.Size;
if (size.HasValue)
{
db.ExecuteNonQuery("update img set size = @size where path = @path",
"@size", size.Value,
"@path", file.Location);
// No need to update history since it doesn't care about the size.
changesMade = true;
}
}
}
}
if (filesToAdd.Count > 0)
{
using (var cmd = db.CreateCommand("insert into img (theme_id, location_id, type, path, pub_date, rating, thumb, size)"
+ " values (@theme_id, @location_id, @type, @path, @pub_date, @rating, @thumb, @size)"))
{
foreach (var img in filesToAdd)
{
if (cancel.IsCancellationRequested)
{
return;
}
#if DEBUG
Log.Debug("Inserting: {0}", img.Location);
#endif
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@theme_id", theme.RowId);
cmd.Parameters.AddWithValue("@location_id", _rowid);
cmd.Parameters.AddWithValue("@type", img.Type.ToString());
cmd.Parameters.AddWithValue("@path", img.Location);
cmd.Parameters.AddWithValue("@pub_date", img.PubDate.HasValue ? (object)img.PubDate.Value : null);
cmd.Parameters.AddWithValue("@rating", img.Rating);
cmd.Parameters.AddWithValue("@thumb", img.Thumbnail?.Data);
if (img.Size.HasValue)
{
cmd.Parameters.AddWithValue("@size", img.Size.Value);
}
else
{
cmd.Parameters.AddWithValue("@size", null);
}
cmd.ExecuteNonQuery();
changesMade = true;
}
}
}
tran.Commit();
}
if (changesMade)
{
ContentUpdated?.Invoke(this, EventArgs.Empty);
}
}
public void OnContentUpdated()
{
ContentUpdated?.Invoke(this, new EventArgs());
}
protected void On(ContentUpdated @event)
{
UpdateData(@event.Data, @event.Data, false);
}
protected void On(ContentUpdated @event)
{
data = @event.Data;
}
/// <summary> /// Signals an update by firing the <see cref="ContentUpdated"/> event. /// Call this whenever status changes to trigger a soft render. /// </summary> protected void SignalUpdate() => ContentUpdated?.Invoke(this, new EventArgs());
