public bool UpdateContent(ContentEntity content)
{
AmazonDynamoDBConfig clientConfig = new AmazonDynamoDBConfig();
clientConfig.RegionEndpoint = RegionEndpoint.USEast1;
AmazonDynamoDBClient client = new AmazonDynamoDBClient(clientConfig);
Dictionary <string, AttributeValue> item = new Dictionary <string, AttributeValue>();
item["ContentKey"] = new AttributeValue()
{
S = content.ContentKey
};
item["Content"] = new AttributeValue()
{
S = "<p>" + content.ContentHtml + "</p>"
};
PutItemRequest request = new PutItemRequest()
{
TableName = TABLE_NAME,
Item = item
};
try
{
var response = client.PutItemAsync(request);
return(response.Result.HttpStatusCode == HttpStatusCode.OK);
}
catch (Exception ex)
{
return(false);
}
}
//äæ®ę¹å„½ ęŖęµčÆ
/// <summary>
/// ę„čÆ¢tbå
容čæåéå
/// </summary>
/// <param name="rows"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public List <ContentEntity> SelectLocalContentList(string rows = "50", string startIndex = "0")
{
List <ContentEntity> listContentEntity = new List <ContentEntity>();
//ISQLConnection iSQLConnection = new SQLiteConn();
//string sql = @"SELECT id,title,url,uname,uid,replies,createcode,createtime,updatetime FROM tbtitlelist ORDER BY id AND visiable=1 LIMIT " + rows + " OFFSET " + startIndex + "";
string sql = @"SELECT id,content,titlecreatetime,replytime,floor,replynum,pagenum,createcode,createtime,updatetime FROM tbcontext WHERE visiable=1 LIMIT" + rows + " OFFSET " + startIndex + "";
var conn = SQLiteConn.GetSQLiteConn();//iSQLConnection.GetSQLiteConn();
SQLiteCommand cmd = new SQLiteCommand(sql, conn);
conn.Open();
Monitor.Enter(obj);
SQLiteDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
ContentEntity contentEntity = new ContentEntity();
contentEntity.Id = (int)dataReader["id"];
contentEntity.Content = dataReader["content"].ToString();
contentEntity.TitleCreateTime = dataReader["titlecreatetime"].ToString();
contentEntity.ReplyTime = dataReader["replytime"].ToString();
contentEntity.Floor = dataReader["floor"].ToString();
contentEntity.ReplyNum = dataReader["replynum"].ToString();
contentEntity.PageNum = dataReader["pagenum"].ToString();
contentEntity.CreateCode = (int)dataReader["createcode"];
contentEntity.CreateTime = dataReader["createtime"].ToString();
contentEntity.UpdateTime = dataReader["updatetime"].ToString();
listContentEntity.Add(contentEntity);
}
Monitor.Exit(obj);
dataReader.Close();
conn.Close();
conn.Dispose();
return(listContentEntity);
}
/// <summary>
/// Creates or updates a publish content entity.
/// </summary>
/// <param name="content">The publish content entity to save.</param>
/// <param name="message">The commit message.</param>
/// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
/// <returns>The change method.</returns>
public Task <ChangeMethods> SaveAsync(ContentEntity content, string message, CancellationToken cancellationToken = default)
{
var rev = content?.CreateRevision(message);
_ = SaveAsync(contentRevisions, rev, cancellationToken);
return(SaveAsync(contents, content, cancellationToken));
}
public int DownVoteContent(ContentEntity content, UserEntity user)
{
var temp = contentRepository.DownVote(content.ToDalContent(), user.ToDalUser());
uow.Commit();
return(temp);
}
private async Task Execute <T>(Func <Task <T> > build, string contentType) where T : IEquatable <T>
{
_ContentDb ??= _ContentDbProvider();
await using var tx = _ContentDb.BeginTransaction();
var candidate = await build();
if (await ShouldLeaveCurrentManifestAsync(candidate, contentType))
{
_Logger.WriteUpdateNotRequired();
return;
}
_Logger.WriteStart();
var snapshot = _DateTimeProvider.Snapshot;
var contentEntity = new ContentEntity
{
Created = snapshot,
Release = snapshot,
Type = contentType
};
await _Formatter().FillAsync(contentEntity, candidate);
_ContentDb.Add(contentEntity);
_ContentDb.SaveAndCommit();
_Logger.WriteFinished();
}
/// <summary>
/// Read one content entity
/// </summary>
/// <returns></returns>
public List <ContentEntity> ReadAllContentEntity()
{
List <ContentEntity> listContentEntity = new List <ContentEntity>();
string strSql = "SELECT * FROM tb_ListContent ORDER BY fld_CreateDate";
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = GetConnectString();
conn.Open();
try
{
SqlCommand cmd = new SqlCommand(strSql);
cmd.Connection = conn;
SqlDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
ContentEntity entity = new ContentEntity();
entity.fld_ID = dr["fld_ID"].ToString();
entity.fld_Content = dr["fld_Content"].ToString();
entity.fld_status = bool.Parse(dr["fld_status"].ToString());
entity.fld_CreateDate = DateTime.Parse(dr["fld_CreateDate"].ToString());
listContentEntity.Add(entity);
}
}
catch (Exception e)
{
throw e;
}
}
return(listContentEntity);
}
private ContentEntity ConvertDocumentToContentEntity(Document doc)
{
ContentEntity content = new ContentEntity();
foreach (var attribute in doc.GetAttributeNames())
{
switch (attribute)
{
case "ContentKey":
content.ContentKey = doc[attribute].AsString();
break;
case "Content":
content.ContentHtml = doc[attribute].AsString();
break;
case "Filename":
content.Filename = doc[attribute].AsString();
break;
default:
break;
}
}
return(content);
}
public ContentEntity GetByID(int _contentEntityId)
{
ContentEntityDAC _contentEntityComponent = new ContentEntityDAC();
IDataReader reader = _contentEntityComponent.GetByIDContentEntity(_contentEntityId);
ContentEntity _contentEntity = null;
while (reader.Read())
{
_contentEntity = new ContentEntity();
if (reader["ContentEntityId"] != DBNull.Value)
{
_contentEntity.ContentEntityId = Convert.ToInt32(reader["ContentEntityId"]);
}
if (reader["ContentEntityType"] != DBNull.Value)
{
_contentEntity.ContentEntityType = Convert.ToString(reader["ContentEntityType"]);
}
if (reader["RowGuid"] != DBNull.Value)
{
_contentEntity.RowGuid = new Guid(reader["RowGuid"].ToString());
}
if (reader["ModifiedDate"] != DBNull.Value)
{
_contentEntity.ModifiedDate = Convert.ToDateTime(reader["ModifiedDate"]);
}
_contentEntity.NewRecord = false;
}
reader.Close();
return(_contentEntity);
}
public async Task Should_call_script_engine_with_data()
{
var ctx = new Context(Mocks.ApiUser(), Mocks.App(appId));
var oldData = new NamedContentData();
var content = new ContentEntity {
SchemaId = schemaWithScriptId, Data = oldData
};
A.CallTo(() => scriptEngine.TransformAsync(A <ScriptVars> ._, "my-query"))
.Returns(new NamedContentData());
await sut.EnrichAsync(ctx, new[] { content }, schemaProvider);
Assert.NotSame(oldData, content.Data);
A.CallTo(() => scriptEngine.TransformAsync(
A <ScriptVars> .That.Matches(x =>
ReferenceEquals(x.User, ctx.User) &&
ReferenceEquals(x.Data, oldData) &&
x.ContentId == content.Id),
"my-query"))
.MustHaveHappened();
}
public async Task Should_call_script_engine_with_data()
{
var ctx = new Context(Mocks.ApiUser(), Mocks.App(appId));
var oldData = new ContentData();
var(provider, schemaId) = CreateSchema(
query: "my-query");
var content = new ContentEntity {
Data = oldData, SchemaId = schemaId
};
A.CallTo(() => scriptEngine.TransformAsync(A <ScriptVars> ._, "my-query", ScriptOptions(), A <CancellationToken> ._))
.Returns(new ContentData());
await sut.EnrichAsync(ctx, new[] { content }, provider, default);
Assert.NotSame(oldData, content.Data);
A.CallTo(() => scriptEngine.TransformAsync(
A <ScriptVars> .That.Matches(x =>
Equals(x["user"], ctx.User) &&
Equals(x["data"], oldData) &&
Equals(x["contentId"], content.Id)),
"my-query",
ScriptOptions(), A <CancellationToken> ._))
.MustHaveHappened();
}
public async Task Should_make_test_with_pre_query_script()
{
var ctx = new Context(Mocks.ApiUser(), Mocks.App(appId));
var(provider, id) = CreateSchema(
query: @"
ctx.data.test = { iv: ctx.custom };
replace()",
queryPre: "ctx.custom = 123;");
var content = new ContentEntity {
Data = new ContentData(), SchemaId = id
};
var realScriptEngine =
new JintScriptEngine(new MemoryCache(Options.Create(new MemoryCacheOptions())),
Options.Create(new JintScriptOptions
{
TimeoutScript = TimeSpan.FromSeconds(20),
TimeoutExecution = TimeSpan.FromSeconds(100)
}));
var sut2 = new ScriptContent(realScriptEngine);
await sut2.EnrichAsync(ctx, new[] { content }, provider, default);
Assert.Equal(JsonValue.Create(123), content.Data["test"] !["iv"]);
public async Task Execute()
{
if (_ContentDb != null)
{
throw new InvalidOperationException("Command already used.");
}
_ContentDb = _ContentDbProvider();
await using var tx = _ContentDb.BeginTransaction();
var candidate = await _Builder.Execute();
if (!await WriteCandidate(candidate))
{
_Logger.LogInformation("Manifest does NOT require updating.");
return;
}
_Logger.LogInformation("Manifest updating.");
var snapshot = _DateTimeProvider.Snapshot;
var e = new ContentEntity
{
Created = snapshot,
Release = snapshot,
Type = ContentTypes.Manifest
};
await _Formatter.Fill(e, candidate);
_Result.Updated = true;
_ContentDb.Add(e);
_ContentDb.SaveAndCommit();
_Logger.LogInformation("Manifest updated.");
}
private void BatchInsertContent(Guid accountId, Guid contentId, string newFullData, TableBatchOperation batch)
{
var standaloneContent = new ContentEntity(accountId.ToString(), contentId.ToString());
standaloneContent.Data = newFullData;
batch.InsertOrReplace(standaloneContent);
}
public async Task Should_enrich_multiple_contents_and_cache_color()
{
var source1 = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
var source2 = new ContentEntity {
Status = Status.Published, SchemaId = schemaId
};
var source = new IContentEntity[]
{
source1,
source2
};
A.CallTo(() => contentWorkflow.GetInfoAsync(source1))
.Returns(new StatusInfo(Status.Published, StatusColors.Published));
var result = await sut.EnrichAsync(source, requestContext);
Assert.Equal(StatusColors.Published, result[0].StatusColor);
Assert.Equal(StatusColors.Published, result[1].StatusColor);
A.CallTo(() => contentWorkflow.GetInfoAsync(A <IContentEntity> .Ignored))
.MustHaveHappenedOnceExactly();
}
public void ResignManifest()
{
var lf = new LoggerFactory();
var resignerLogger = new ResignerLoggingExtensions(lf.CreateLogger <ResignerLoggingExtensions>());
var d = DateTime.Now;
using var testContentStream = ResourcesHook.GetManifestResourceStream("Resources.ResignTestManifest.zip");
using var m = new MemoryStream();
testContentStream.CopyTo(m);
var zipContent = m.ToArray();
var m1 = new ContentEntity {
Content = zipContent, PublishingId = "1", ContentTypeName = "Meh", Type = ContentTypes.Manifest, Created = d, Release = d
};
var dbc = _contentDbProvider.CreateNew();
dbc.Content.AddRange(new[] {
m1,
new ContentEntity {
Content = new byte[0], PublishingId = "2", ContentTypeName = "Meh", Type = ContentTypes.AppConfig, Created = d, Release = d
},
new ContentEntity {
Content = new byte[0], PublishingId = "3", ContentTypeName = "Meh", Type = ContentTypes.AppConfigV2, Created = d, Release = d
},
new ContentEntity {
Content = new byte[0], PublishingId = "4", ContentTypeName = "Meh", Type = ContentTypes.ExposureKeySet, Created = d, Release = d
},
new ContentEntity {
Content = new byte[0], PublishingId = "5", ContentTypeName = "Meh", Type = ContentTypes.ExposureKeySetV2, Created = d, Release = d
},
});
dbc.SaveChanges();
var resigner = new NlContentResignCommand(_contentDbProvider.CreateNew, TestSignerHelpers.CreateCmsSignerEnhanced(lf), resignerLogger);
resigner.ExecuteAsync(ContentTypes.Manifest, ContentTypes.ManifestV2, ZippedContentEntryNames.Content).GetAwaiter().GetResult();
//check the numbers
Assert.Equal(6, dbc.Content.Count());
var m2 = dbc.Content.Single(x => x.PublishingId == "1" && x.Type == ContentTypes.ManifestV2);
Assert.Equal(m1.Created, m2.Created);
Assert.Equal(m1.Release, m2.Release);
var ms1 = new MemoryStream(zipContent);
using var zip1 = new ZipArchive(ms1);
var ms2 = new MemoryStream(m2.Content);
using var zip2 = new ZipArchive(ms2);
Assert.True(Enumerable.SequenceEqual(zip1.ReadEntry(ZippedContentEntryNames.Content), zip2.ReadEntry(ZippedContentEntryNames.Content)));
Assert.NotEqual(zip1.GetEntry(ZippedContentEntryNames.NlSignature), zip2.GetEntry(ZippedContentEntryNames.NlSignature));
}
public ContentEntity GetContentByReq(RequestModel requestModel)
{
ContentEntity contentEntity = service.IQueryable(m => m.WebSiteId == requestModel.webSite.Id &&
(m.UrlAddress == requestModel.UrlRaw || m.UrlAddress == requestModel.UrlRaw.Replace(@"/", @"\"))).FirstOrDefault();
return(contentEntity);
}
protected static IEnrichedContentEntity CreateRefContent(NamedId <Guid> schemaId, Guid id, string field, string value)
{
var now = SystemClock.Instance.GetCurrentInstant();
var data =
new NamedContentData()
.AddField(field,
new ContentFieldData()
.AddValue("iv", value));
var content = new ContentEntity
{
Id = id,
Version = 1,
Created = now,
CreatedBy = new RefToken(RefTokenType.Subject, "user1"),
LastModified = now,
LastModifiedBy = new RefToken(RefTokenType.Subject, "user2"),
Data = data,
SchemaId = schemaId,
Status = Status.Draft,
StatusColor = "red"
};
return(content);
}
static string ReplaceEmbeddedImages(string htmlBody, AttachmentCollection attachments)
{
var srcPattern =
"(?<=<img.+?src=[\"'])" +
"(.+?)" +
"(?=[\"'].*?>)";
// Iterate through "src" attributes from HTML images in reverse order.
foreach (var match in Regex.Matches(htmlBody, srcPattern, RegexOptions.IgnoreCase).Cast <Match>().Reverse())
{
var imageId = match.Value.Replace("cid:", "");
Attachment attachment = attachments.FirstOrDefault(a => a.ContentId == imageId);
if (attachment != null)
{
// Create inlined image data. E.g. "data:image/png;base64,AABBCC..."
ContentEntity entity = attachment.MimeEntity;
var embeddedImage = entity.Charset.GetString(entity.Content);
var embeddedSrc = $"data:{entity.ContentType};{entity.TransferEncoding},{embeddedImage}";
// Replace "src" attribute with inlined image.
htmlBody = $"{htmlBody.Substring(0, match.Index)}{embeddedSrc}{htmlBody.Substring(match.Index + match.Length)}";
}
}
return(htmlBody);
}
protected static IContentEntity CreateContent(Guid id, Guid refId, Guid assetId, NamedContentData data = null, NamedContentData dataDraft = null)
{
var now = SystemClock.Instance.GetCurrentInstant();
data = data ??
new NamedContentData()
.AddField("my-string",
new ContentFieldData()
.AddValue("de", "value"))
.AddField("my-assets",
new ContentFieldData()
.AddValue("iv", JsonValue.Array(assetId.ToString())))
.AddField("my-number",
new ContentFieldData()
.AddValue("iv", 1.0))
.AddField("my-boolean",
new ContentFieldData()
.AddValue("iv", true))
.AddField("my-datetime",
new ContentFieldData()
.AddValue("iv", now))
.AddField("my-tags",
new ContentFieldData()
.AddValue("iv", JsonValue.Array("tag1", "tag2")))
.AddField("my-references",
new ContentFieldData()
.AddValue("iv", JsonValue.Array(refId.ToString())))
.AddField("my-geolocation",
new ContentFieldData()
.AddValue("iv", JsonValue.Object().Add("latitude", 10).Add("longitude", 20)))
.AddField("my-json",
new ContentFieldData()
.AddValue("iv", JsonValue.Object().Add("value", 1)))
.AddField("my-localized",
new ContentFieldData()
.AddValue("de-DE", "de-DE"))
.AddField("my-array",
new ContentFieldData()
.AddValue("iv", JsonValue.Array(
JsonValue.Object()
.Add("nested-boolean", true)
.Add("nested-number", 1),
JsonValue.Object()
.Add("nested-boolean", false)
.Add("nested-number", 2))));
var content = new ContentEntity
{
Id = id,
Version = 1,
Created = now,
CreatedBy = new RefToken(RefTokenType.Subject, "user1"),
LastModified = now,
LastModifiedBy = new RefToken(RefTokenType.Subject, "user2"),
Data = data,
DataDraft = dataDraft
};
return(content);
}
/// <summary>
/// Read one content entity
/// </summary>
/// <param name="fld_ID"></param>
/// <returns></returns>
public ContentEntity ReadEntity(string fld_ID)
{
ContentEntity entity = null;
string strSql = "SELECT Top 1 * FROM tb_ListContent WHERE fld_ID=@fld_ID ";
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = GetConnectString();
conn.Open();
try
{
SqlCommand cmd = new SqlCommand(strSql);
SqlParameter parameter = new SqlParameter();
cmd.Connection = conn;
cmd.Parameters.Add(new SqlParameter("@fld_ID", Convert.ToInt32(fld_ID)));
SqlDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
entity = new ContentEntity();
entity.fld_ID = dr["fld_ID"].ToString();
entity.fld_Content = dr["fld_Content"].ToString();
entity.fld_CreateDate = DateTime.Parse(dr["fld_CreateDate"].ToString());
entity.fld_status = bool.Parse(dr["fld_status"].ToString());
}
}
catch (Exception e)
{
throw e;
}
}
return(entity);
}
public List <ContentEntity> GetAll()
{
ContentEntityDAC _contentEntityComponent = new ContentEntityDAC();
IDataReader reader = _contentEntityComponent.GetAllContentEntity().CreateDataReader();
List <ContentEntity> _contentEntityList = new List <ContentEntity>();
while (reader.Read())
{
if (_contentEntityList == null)
{
_contentEntityList = new List <ContentEntity>();
}
ContentEntity _contentEntity = new ContentEntity();
if (reader["ContentEntityId"] != DBNull.Value)
{
_contentEntity.ContentEntityId = Convert.ToInt32(reader["ContentEntityId"]);
}
if (reader["ContentEntityType"] != DBNull.Value)
{
_contentEntity.ContentEntityType = Convert.ToString(reader["ContentEntityType"]);
}
if (reader["RowGuid"] != DBNull.Value)
{
_contentEntity.RowGuid = new Guid(reader["RowGuid"].ToString());
}
if (reader["ModifiedDate"] != DBNull.Value)
{
_contentEntity.ModifiedDate = Convert.ToDateTime(reader["ModifiedDate"]);
}
_contentEntity.NewRecord = false;
_contentEntityList.Add(_contentEntity);
}
reader.Close();
return(_contentEntityList);
}
public bool Post(ContentModel model)
{
var entity = new ContentEntity
{
Content = model.Content,
Title = model.Title,
Adduser = model.Adduser,
Addtime = model.Addtime,
Upduser = model.Upduser,
Updtime = model.Updtime,
Status = model.Status,
Praise = model.Praise,
Unpraise = model.Unpraise,
Viewcount = model.Viewcount,
// Tags = model.Tags,
// Channels = model.Channels,
};
if (_ContentService.Create(entity).Id > 0)
{
return(true);
}
return(false);
}
public static IEnrichedContentEntity CreateRef(NamedId <DomainId> schemaId, DomainId id, string field, string value)
{
var now = SystemClock.Instance.GetCurrentInstant();
var data =
new ContentData()
.AddField(field,
new ContentFieldData()
.AddInvariant(value));
var content = new ContentEntity
{
Id = id,
Version = 1,
Created = now,
CreatedBy = RefToken.User("user1"),
LastModified = now,
LastModifiedBy = RefToken.User("user2"),
Data = data,
SchemaId = schemaId,
Status = Status.Draft,
StatusColor = "red"
};
return(content);
}
//[ValidateAntiForgeryToken]
public ActionResult SubmitForm(ContentEntity moduleEntity, string keyValue)
{
try
{
List <UpFileDTO> upFileentitys = new List <UpFileDTO>();
List <string> lstRemoveImgIds = new List <string>();
if (HttpContext.Request["upFileentitys"] != null)
{
string strupFiles = HttpContext.Request["upFileentitys"].ToString();
upFileentitys = JsonConvert.DeserializeObject <List <UpFileDTO> >(strupFiles);
}
if (HttpContext.Request["removeImageIds"] != null && !string.IsNullOrEmpty(keyValue))
{
string strRemoveImageIds = HttpContext.Request["removeImageIds"].ToString();
lstRemoveImgIds = JsonConvert.DeserializeObject <List <string> >(strRemoveImageIds);
}
moduleEntity.WebSiteId = Base_WebSiteId;
c_contentApp.SubmitForm(moduleEntity, keyValue, upFileentitys, lstRemoveImgIds);
return(Success("ęä½ęåć"));
}
catch (Exception ex)
{
return(Error("ęä½å¤±č“„ć" + ex.Message));
}
}
private async Task ExecuteForVxxx <T>(Func <Task <T> > build, string type) where T : IEquatable <T>
{
_ContentDb ??= _ContentDbProvider();
await using var tx = _ContentDb.BeginTransaction();
var candidate = await build();
if (!await ShouldWriteCandidateAsync(candidate, type))
{
_Logger.WriteUpdateNotRequired();
return;
}
_Logger.WriteStart();
var snapshot = _DateTimeProvider.Snapshot;
var e = new ContentEntity
{
Created = snapshot,
Release = snapshot,
Type = type
};
await _FormatterForV3().FillAsync(e, candidate);
_Result.Updated = true;
_ContentDb.Add(e);
_ContentDb.SaveAndCommit();
_Logger.WriteFinished();
}
protected static IContentEntity CreateContent(Guid id, Guid refId, Guid assetId, NamedContentData data = null)
{
var now = DateTime.UtcNow.ToInstant();
data = data ??
new NamedContentData()
.AddField("my-string",
new ContentFieldData()
.AddValue("de", "value"))
.AddField("my-assets",
new ContentFieldData()
.AddValue("iv", JToken.FromObject(new[] { assetId })))
.AddField("my-number",
new ContentFieldData()
.AddValue("iv", 1))
.AddField("my-boolean",
new ContentFieldData()
.AddValue("iv", true))
.AddField("my-datetime",
new ContentFieldData()
.AddValue("iv", now.ToDateTimeUtc()))
.AddField("my-tags",
new ContentFieldData()
.AddValue("iv", JToken.FromObject(new[] { "tag1", "tag2" })))
.AddField("my-references",
new ContentFieldData()
.AddValue("iv", JToken.FromObject(new[] { refId })))
.AddField("my-geolocation",
new ContentFieldData()
.AddValue("iv", JToken.FromObject(new { latitude = 10, longitude = 20 })))
.AddField("my-json",
new ContentFieldData()
.AddValue("iv", JToken.FromObject(new { value = 1 })))
.AddField("my-localized",
new ContentFieldData()
.AddValue("de-DE", "de-DE"))
.AddField("my-array",
new ContentFieldData()
.AddValue("iv", new JArray(
new JObject(
new JProperty("nested-boolean", true),
new JProperty("nested-number", 1)),
new JObject(
new JProperty("nested-boolean", false),
new JProperty("nested-number", 2)))));
var content = new ContentEntity
{
Id = id,
Version = 1,
Created = now,
CreatedBy = new RefToken(RefTokenType.Subject, "user1"),
LastModified = now,
LastModifiedBy = new RefToken(RefTokenType.Subject, "user2"),
Data = data
};
return(content);
}
public async Task <IActionResult> SubmitForm(ContentEntity model)
{
var userClaim = await workContext.GetCurrentUserClaim();
Messages messages = contentService.Save(model, userClaim);
return(Json(messages));
}
private bool UserVoted(UserEntity user, ContentEntity content)
{
if (user.VotedPublicationsId == null || !user.VotedPublicationsId.Any())
{
return(false);
}
return(user.VotedPublicationsId.Contains(content.Id));
}
public ContentAggregate()
{
_ContentEntityLIst = new List <ContentEntity>();
_ContentEntity = new ContentEntity();
_GenreEntity = new List <GenreEntity>();
_PersonEntity = new List <PersonEntity>();
_WatchList = new List <ContentEntity>();
}
public static ContentEntity CreateContentEntity() {
ContentEntity entity = new ContentEntity();
entity.Initialize(new ContentEntitySerializationFormat() {
Data = new List<ContentEntity.DataInstance>(),
PrettyName = "",
UniqueId = _idGenerator.Next()
});
return entity;
}
public GameSnapshot() {
EntityIdGenerator = new UniqueIntGenerator();
GlobalEntity = new ContentEntity(EntityIdGenerator.Next(), "Global Entity");
ActiveEntities = new List<IEntity>();
AddedEntities = new List<IEntity>();
RemovedEntities = new List<IEntity>();
_systems = new SystemSerializationContainer();
}
public void CreateText()
{
SetupTutorial();
SetupSteps();
var modelMiddleware = TutorialManagerModelMiddleware.GetInstance();
string expectedStep1TextId = ConstructID(t1Step1LookupID, ContentType.text.ToString());
string expectedStep2TextId = ConstructID(t1Step2LookupID, ContentType.text.ToString());
var t1s1 = modelMiddleware.TMData.stepTable[t1Step1LookupID];
var t1s2 = modelMiddleware.TMData.stepTable[t1Step2LookupID];
// Add content to s1
string contentId = modelMiddleware.CreateContentEntity(t1Step1LookupID, ContentType.text, t1step1Text);
Assert.That(expectedStep1TextId, Is.EqualTo(contentId), string.Format("text content 1 should have id {0}", expectedStep1TextId));
Assert.AreEqual(1, t1s1.messaging.content.Count, "step 1 should have one content item");
Assert.IsEmpty(t1s2.messaging.content, "step 2 should still have no steps");
Assert.AreEqual(1, modelMiddleware.TMData.contentTable.Count, "model should have 1 content item");
ContentEntity t1S1textFromList = modelMiddleware.TMData.content[0];
ContentEntity t1S1textFromTable = modelMiddleware.TMData.contentTable[contentId];
Assert.IsNotNull(t1S1textFromList, "new content item should be in list");
Assert.IsNotNull(t1S1textFromTable, "new content item should be in table");
Assert.AreSame(t1S1textFromList, t1S1textFromTable, "the two entities should represent the same content item");
// Check the content of the object
Assert.That("text", Is.EqualTo(t1S1textFromTable.type), "text content type should be 'text'");
Assert.That(t1step1Text, Is.EqualTo(t1S1textFromTable.text), string.Format("text content value should be {0}", t1step1Text));
Assert.That(expectedStep1TextId, Is.EqualTo(t1S1textFromTable.id), string.Format("text id should be {0}", expectedStep1TextId));
Assert.That(contentId, Is.EqualTo(t1S1textFromTable.id), string.Format("content id should be {0}", contentId));
Assert.That(contentId, Is.EqualTo(t1s1.messaging.content[0]), string.Format("content id in step 1 should be {0}", contentId));
// Add content to s2
string contentId2 = modelMiddleware.CreateContentEntity(t1Step2LookupID, ContentType.text, t1step2Text);
Assert.That(expectedStep2TextId, Is.EqualTo(contentId2), string.Format("text content 2 should have id {0}", expectedStep1TextId));
Assert.AreEqual(1, t1s2.messaging.content.Count, "step 2 should have one content item");
Assert.AreEqual(1, t1s1.messaging.content.Count, "step 1 should still have 1 step");
Assert.AreEqual(2, modelMiddleware.TMData.contentTable.Count, "model should have 2 content items");
ContentEntity t1S2textFromList = modelMiddleware.TMData.content[1];
ContentEntity t1S2textFromTable = modelMiddleware.TMData.contentTable[contentId2];
Assert.IsNotNull(t1S2textFromList, "new content item should be in list");
Assert.IsNotNull(t1S2textFromTable, "new content item should be in table");
Assert.AreSame(t1S2textFromList, t1S2textFromTable, "the two entities should represent the same content item");
Assert.That(contentId2, Is.EqualTo(t1S2textFromTable.id), string.Format("content id should be {0}", contentId2));
Assert.That(contentId2, Is.EqualTo(t1s2.messaging.content[0]), string.Format("content id in step 2 should be {0}", contentId2));
EnsureUnaffectedSteps();
PostTestCleanup();
}
public ContentEntity Create(ContentEntity content)
{
if (content.UrlToContent.Contains("youtube.com"))
{
content.UrlToContent = GetYouTubeID(content.UrlToContent);
}
var temp = contentRepository.Create(content.ToDalContent());
uow.Commit();
Lucene.LuceneSearch.AddUpdateLuceneIndex(content);
return temp.ToBllContent();
}
/// <summary>
/// Returns an entity instance for the given entity UniqueId. If an instance for the given
/// id already exists, then it is returned. Otherwise, either a RuntimeEntity or
/// ContentEntity is created.
/// </summary>
/// <param name="entityId">The id of the entity to get an instance for.</param>
/// <param name="context">The GameEngineContext, used to determine if we should create a
/// ContentTemplate or RuntimeTemplate instance.</param>
public IEntity GetEntityInstance(int entityId, GameEngineContext context) {
if (CreatedEntities.ContainsKey(entityId)) {
return CreatedEntities[entityId];
}
IEntity entity;
if (context.GameEngine.IsEmpty) {
entity = new ContentEntity();
}
else {
entity = new RuntimeEntity();
}
CreatedEntities[entityId] = entity;
return entity;
}
private static void _addToLuceneIndex(ContentEntity content, IndexWriter writer)
{
// remove older index entry
var searchQuery = new TermQuery(new Term("Id", content.Id.ToString()));
writer.DeleteDocuments(searchQuery);
// add new index entry
var doc = new Document();
bool commentsAreEmpty = content.Comments == null || !content.Comments.Any();
// add lucene fields mapped to db fields
doc.Add(new Field("Id", content.Id.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("Name", content.Name, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field("Description", content.Description, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field("Text", commentsAreEmpty ? string.Empty : content.Comments.Select(x => x.Text).Aggregate((x, y) => (x + y)), Field.Store.YES, Field.Index.ANALYZED));
// add entry to index
writer.AddDocument(doc);
}
public void Update(ContentEntity content)
{
contentRepository.Update(content.ToDalContent());
uow.Commit();
Lucene.LuceneSearch.AddUpdateLuceneIndex(content);
}
public IEntity CreateEntity(string prettyName = "") {
ContentEntity added = new ContentEntity(EntityIdGenerator.Next(), prettyName);
AddedEntities.Add(added);
return added;
}
/// <summary>
/// Helper for tests to create snapshots with entities within more collections than just
/// AddedEntities.
/// </summary>
internal IEntity CreateEntity(EntityAddTarget target, string prettyName = "") {
ContentEntity added = new ContentEntity(EntityIdGenerator.Next(), prettyName);
if (target == EntityAddTarget.Added) {
AddedEntities.Add(added);
}
else if (target == EntityAddTarget.Active) {
ActiveEntities.Add(added);
}
else {
RemovedEntities.Add(added);
}
return added;
}
public static void AddUpdateLuceneIndex(ContentEntity content)
{
AddUpdateLuceneIndex(new List<ContentEntity> { content });
}
public void Delete(ContentEntity content)
{
contentRepository.Delete(content.ToDalContent());
uow.Commit();
Lucene.LuceneSearch.ClearLuceneIndexRecord(content.Id);
}
public bool UserVoted(string username, ContentEntity content)
{
var user = userRepository.GetByName(username).ToBllUser();
return UserVoted(user, content);
}
public int DownVoteContent(ContentEntity content, UserEntity user)
{
var temp = contentRepository.DownVote(content.ToDalContent(), user.ToDalUser());
uow.Commit();
return temp;
}
private bool UserVoted(UserEntity user, ContentEntity content)
{
if (user.VotedPublicationsId == null || !user.VotedPublicationsId.Any())
return false;
return user.VotedPublicationsId.Contains(content.Id);
}
