public override object Execute()
{
IEnumerable<TextContent> contents = new TextContent[0];
contents = TextContentQuery.Schema.GetContents();
if (TextContentQuery.Folder != null)
{
contents = contents.Where(it => it.FolderName.EqualsOrNullEmpty(TextContentQuery.Folder.FullName, StringComparison.CurrentCultureIgnoreCase));
}
QueryExpressionTranslator translator = new QueryExpressionTranslator();
var contentQueryable = translator.Translate(TextContentQuery.Expression, contents.AsQueryable());
foreach (var categoryQuery in translator.CategoryQueries)
{
var categories = (IEnumerable<TextContent>)ContentQueryExecutor.Execute(categoryQuery);
var categoryData = TextContentQuery.Repository.GetCategoryData()
.Where(it => categories.Any(c => it.CategoryUUID.EqualsOrNullEmpty(c.UUID, StringComparison.CurrentCultureIgnoreCase)));
contentQueryable = contentQueryable.Where(it => categoryData.Any(c => it.UUID.EqualsOrNullEmpty(c.ContentUUID, StringComparison.CurrentCultureIgnoreCase)));
}
return Execute(contentQueryable, translator.OrderExpressions, translator.CallType, translator.Skip, translator.Take);
}
public ContentVersionPath(TextContent content)
{
var contentPath = new TextContentPath(content);
var basePath = EngineContext.Current.Resolve<IBaseDir>();
var versionPath = Path.Combine(basePath.DataPhysicalPath, VersionPathName);
this.PhysicalPath = contentPath.PhysicalPath.Replace(basePath.DataPhysicalPath, versionPath);
}
private static void DeleteChildContents(TextContent textContent, TextFolder parentFolder, TextFolder childFolder)
{
var repository = textContent.GetRepository();
var childContents = childFolder.CreateQuery().WhereEquals("ParentFolder", parentFolder.FullName)
.WhereEquals("ParentUUID", textContent.UUID);
foreach (var content in childContents)
{
Services.ServiceFactory.TextContentManager.Delete(repository, childFolder, content.UUID);
}
}
public VersionInfo GetVersion(TextContent content, int version)
{
string versionFile = GetVersionFile(content, version);
if (File.Exists(versionFile))
{
var versionInfo = DataContractSerializationHelper.Deserialize<VersionInfo>(versionFile);
versionInfo.Version = version;
return versionInfo;
}
return null;
}
protected virtual SendingSetting AllowSending(TextContent content, Repository repository, ContentEventContext eventContext)
{
if (!repository.EnableBroadcasting)
{
return null;
}
var list = Providers.DefaultProviderFactory.GetProvider<ISendingSettingProvider>().All(repository).Select(o => Providers.DefaultProviderFactory.GetProvider<ISendingSettingProvider>().Get(o));
foreach (var item in list)
{
if (AllowSendingSetting(content, item, eventContext))
{
return item;
}
}
return null;
}
public IEnumerable<int> AllVersions(TextContent content)
{
ContentVersionPath versionPath = new ContentVersionPath(content);
if (Directory.Exists(versionPath.PhysicalPath))
{
foreach (var file in Directory.EnumerateFiles(versionPath.PhysicalPath))
{
string fileName = Path.GetFileNameWithoutExtension(file);
int version;
if (int.TryParse(fileName, out version))
{
yield return version;
}
}
}
}
public override object Execute()
{
var parent = (IEnumerable<TextContent>)ContentQueryExecutor.Execute(ChildrenQuery.ParentQuery);
IQueryable<TextContent> contents = new TextContent[0].AsQueryable();
if (parent.Count() > 0)
{
contents = ChildrenQuery.ChildSchema.GetContents().AsQueryable();
}
QueryExpressionTranslator translator = new QueryExpressionTranslator();
contents = translator.Translate(ChildrenQuery.Expression, contents);
contents = contents.Where(it => parent.Any(c => it.ParentUUID.EqualsOrNullEmpty(c.UUID, StringComparison.CurrentCultureIgnoreCase)));
return Execute(contents, translator.OrderExpressions, translator.CallType, translator.Skip, translator.Take);
}
public static TextContent ConvertToUTCTime(this TextContent textContent)
{
ITimeZoneHelper timeZoneHelper = Bsc.Dmtds.Core.Runtime.EngineContext.Current.Resolve<ITimeZoneHelper>();
TextContent newTextContent = new TextContent(textContent);
foreach (var key in newTextContent.Keys.ToArray())
{
if (newTextContent[key] is DateTime)
{
DateTime dt = (DateTime)newTextContent[key];
if (dt.Kind != DateTimeKind.Utc)
{
newTextContent[key] = timeZoneHelper.ConvertToUtcTime(dt);
}
}
}
return newTextContent;
}
public void LogVersion(TextContent content)
{
VersionInfo versionInfo = new VersionInfo()
{
CommitUser = content.UserId,
UtcCommitDate = content.LastModificationDate,
TextContent = new Dictionary<string, object>(content)
};
if (!string.IsNullOrEmpty(content.FolderName))
{
versionInfo.Categories = ServiceFactory.TextContentManager
.QueryCategories(content.GetRepository(), content.FolderName, content.UUID)
.Select(it => new Category()
{
FolderName = it.CategoryFolder.FullName,
Contents = it.Contents.Select(c => new CategoryContent() { UUID = c.UUID, DisplayName = c.GetSummary() }).ToArray()
})
.ToArray();
}
DataContractSerializationHelper.Serialize(versionInfo, GetNextVersionFile(content));
}
public override object Execute()
{
var contents = (IEnumerable<TextContent>)ContentQueryExecutor.Execute(CategoriesQuery.InnerQuery);
IQueryable<TextContent> categories = new TextContent[0].AsQueryable();
if (contents.Count() > 0)
{
categories = CategoriesQuery.CategoryFolder.GetSchema().GetContents().AsQueryable();
}
QueryExpressionTranslator translator = new QueryExpressionTranslator();
categories = translator.Translate(CategoriesQuery.Expression, categories);
var categoryData = CategoriesQuery.Repository.GetCategoryData()
.Where(it => it.CategoryFolder.EqualsOrNullEmpty(CategoriesQuery.CategoryFolder.FullName, StringComparison.CurrentCultureIgnoreCase))
.Where(it => contents.Any(c => it.ContentUUID.EqualsOrNullEmpty(c.UUID, StringComparison.CurrentCultureIgnoreCase)))
.ToArray();
categories = categories.Where(it => categoryData.Any(c => it.UUID.EqualsOrNullEmpty(c.CategoryUUID, StringComparison.CurrentCultureIgnoreCase)));
var result = Execute(categories, translator.OrderExpressions, translator.CallType, translator.Skip, translator.Take);
return result;
}
public virtual void RemoveCategories(Repository repository, TextContent textContent, params TextContent[] categories)
{
var relations = categories.Select(it => new Category()
{
ContentUUID = textContent.UUID,
CategoryFolder = it.FolderName,
CategoryUUID = it.UUID
});
TextContentProvider.DeleteCategories(textContent, relations.ToArray());
}
public virtual TextContent Copy(Schema schema, string uuid)
{
var repository = schema.Repository;
var content = schema.CreateQuery().WhereEquals("UUID", uuid).FirstOrDefault();
if (content != null)
{
var textContent = new TextContent(content);
textContent.Id = "";
textContent.UUID = "";
textContent.CreationDate = DateTime.Now;
textContent.LastModificationDate = DateTime.Now;
textContent.Published = null;
textContent.Sequence = 0;
textContent.UserKey = null;
var titleField = schema.AsActual().GetSummarizeColumn();
if (titleField != null)
{
textContent[titleField.Name] = (content[titleField.Name] ?? "") + " - Copy";
}
EventBus.Content.ContentEvent.Fire(ContentAction.PreAdd, textContent);
TextContentProvider.Add(textContent);
var categories = this.QueryCategories(repository, content.FolderName, uuid);
this.AddCategories(repository, textContent, categories.SelectMany(it => it.Contents).ToArray());
EventBus.Content.ContentEvent.Fire(ContentAction.Add, textContent);
return textContent;
}
return null;
}
public virtual ContentBase Copy(TextContent originalContent, TextFolder textFolder, bool keepStatus, bool keepUUID, NameValueCollection values)
{
textFolder = textFolder.AsActual();
var repository = textFolder.Repository;
var schema = new Schema(repository, textFolder.SchemaName);
var copyedContent = new TextContent(originalContent);
copyedContent.Id = "";
copyedContent.UUID = "";
if (keepUUID)
{
copyedContent.UUID = originalContent.UUID;
}
copyedContent.CreationDate = DateTime.UtcNow;
copyedContent.Repository = textFolder.Repository.Name;
copyedContent.FolderName = textFolder.FullName;
copyedContent.SchemaName = textFolder.SchemaName;
copyedContent.OriginalUUID = originalContent.UUID;
copyedContent.OriginalRepository = originalContent.Repository;
copyedContent.OriginalFolder = originalContent.FolderName;
copyedContent.IsLocalized = false;
copyedContent.Sequence = 0;
copyedContent.UserId = originalContent.UserId;
var versions = Versioning.VersionManager.AllVersionInfos(originalContent).ToArray();
if (versions.Any())
{
copyedContent.OriginalLastestVisitedVersionId = versions.Max(it => it.Version);
}
if (values != null)
{
originalContent = Binder.Bind(schema, copyedContent, values);
}
if (!keepStatus)
{
copyedContent.Published = false;
}
//如果没有Content event，那么在发送设置的“转发”功能就会失效。
EventBus.Content.ContentEvent.Fire(ContentAction.PreAdd, copyedContent);
TextContentProvider.Add(copyedContent);
if (textFolder.Categories != null && textFolder.Categories.Count > 0)
{
var originalRepository = originalContent.GetRepository();
var originalFolder = originalContent.GetFolder().AsActual();
var originalCategories = QueryCategories(originalRepository, originalFolder.FullName, originalContent.UUID);
List<TextContent> categories = new List<TextContent>();
foreach (var category in originalCategories)
{
foreach (var originalCategoryContent in category.Contents)
{
foreach (var categoryFolder in textFolder.Categories)
{
var categoryContent = (new TextFolder(textFolder.Repository, categoryFolder.FolderName)).CreateQuery()
.WhereEquals("UUID", originalCategoryContent.UUID).FirstOrDefault();
if (categoryContent != null)
{
categories.Add(categoryContent);
break;
}
}
}
}
AddCategories(repository, copyedContent, categories.ToArray());
}
EventBus.Content.ContentEvent.Fire(ContentAction.Add, copyedContent);
return copyedContent;
}
public virtual void ClearCategories(Repository repository, TextContent textContent)
{
TextContentProvider.ClearCategories(textContent);
}
public virtual TextContent Add(Repository repository, Schema schema, string parentUUID, NameValueCollection values, HttpFileCollectionBase files,
string userid = "")
{
var textContent = new TextContent(repository.Name, schema.Name, null);
textContent.ParentUUID = parentUUID;
textContent = Binder.Bind(schema, textContent, values);
textContent.LastModificationDate = textContent.CreationDate = DateTime.Now.ToUniversalTime();
textContent.UserId = userid;
if (files != null)
{
textContent.ContentFiles = GetPostFiles(files);
}
EventBus.Content.ContentEvent.Fire(ContentAction.PreAdd, textContent);
TextContentProvider.Add(textContent);
EventBus.Content.ContentEvent.Fire(ContentAction.Add, textContent);
return textContent;
}
public virtual ContentBase Add(Repository repository, TextFolder folder, string parentFolder, string parentUUID, NameValueCollection values
, HttpFileCollectionBase files, IEnumerable<TextContent> categories, string userid = "")
{
var textFolder = (TextFolder)folder.AsActual();
var schema = new Schema(repository, textFolder.SchemaName);
var textContent = new TextContent(repository.Name, schema.Name, textFolder.FullName);
textContent = Binder.Bind(schema, textContent, values);
if (!string.IsNullOrEmpty(values["UUID"]))
{
textContent.UUID = values["UUID"];
}
textContent.ParentFolder = parentFolder;
textContent.ParentUUID = parentUUID;
textContent.UserId = userid;
textContent.LastModificationDate = textContent.CreationDate = DateTime.Now;
textContent.ContentFiles = GetPostFiles(files);
EventBus.Content.ContentEvent.Fire(ContentAction.PreAdd, textContent);
TextContentProvider.Add(textContent);
if (categories != null)
{
AddCategories(repository, textContent, categories.ToArray());
}
EventBus.Content.ContentEvent.Fire(ContentAction.Add, textContent);
return textContent;
}
public static VersionInfo GetVersion(TextContent content, int version)
{
return VersionLogger.GetVersion(content, version);
}
public virtual TextContent Update(Repository repository, Schema schema, string uuid, NameValueCollection values,
HttpFileCollectionBase files, string userid = "")
{
var textContent = schema.CreateQuery().WhereEquals("UUID", uuid).First();
var old = new TextContent(textContent);
textContent = Binder.Update(schema, textContent, values);
textContent.LastModificationDate = DateTime.Now.ToUniversalTime();
textContent.UserId = userid;
if (files != null)
{
textContent.ContentFiles = GetPostFiles(files);
}
EventBus.Content.ContentEvent.Fire(ContentAction.PreUpdate, textContent);
TextContentProvider.Update(textContent, old);
EventBus.Content.ContentEvent.Fire(ContentAction.Update, textContent);
return textContent;
}
public virtual void RevertTo(Repository repository, string folder, string schemaName, string uuid, int version, string user)
{
var textContent = new TextFolder(repository, folder).CreateQuery().WhereEquals("UUID", uuid).FirstOrDefault();
if (textContent != null)
{
var versionInfo = Versioning.VersionManager.GetVersion(textContent, version);
var @new = new TextContent(versionInfo.TextContent);
@new.Repository = repository.Name;
@new.UserId = user;
@new.LastModificationDate = DateTime.Now;
TextContentProvider.Update(@new, textContent);
ClearCategories(repository, textContent);
if (versionInfo.Categories != null)
{
AddCategories(repository, textContent, versionInfo.Categories
.Where(it => it.Contents != null)
.SelectMany(it => it.Contents.Select(c => new TextContent(repository.Name, "", it.FolderName) { UUID = c.UUID }))
.ToArray());
}
if (string.IsNullOrEmpty(textContent.OriginalUUID))
EventBus.Content.ContentEvent.Fire(ContentAction.Update, @new);
}
}
private string GetVersionFile(TextContent content, int version)
{
ContentVersionPath versionPath = new ContentVersionPath(content);
return Path.Combine(versionPath.PhysicalPath, string.Format("{0}.xml", version));
}
private string GetNextVersionFile(TextContent content)
{
var versions = AllVersions(content);
var nextVersion = versions.Count() == 0 ? 1 : versions.Max() + 1;
return GetVersionFile(content, nextVersion);
}
public static void Fire(ContentAction contentAction, TextContent textContent)
{
EventBus.Send(new ContentEventContext(contentAction, textContent));
}
public static void LogVersion(TextContent content)
{
if (content.GetRepository().AsActual().EnableVersioning.Value == true)
{
VersionLogger.LogVersion(content);
}
}
public IEnumerable<VersionInfo> AllVersionInfos(TextContent content)
{
return AllVersions(content).Select(it => GetVersion(content, it)).OrderByDescending(it => it.Version);
}
public virtual ContentBase Update(Repository repository, TextFolder folder, string uuid, NameValueCollection values, HttpFileCollectionBase files,
DateTime modificationDate, IEnumerable<TextContent> addedCateogries, IEnumerable<TextContent> removedCategories, string userid = "", bool enableVersion = true)
{
var textFolder = (TextFolder)folder.AsActual();
var schema = new Schema(repository, textFolder.SchemaName);
var textContent = textFolder.CreateQuery().WhereEquals("UUID", uuid).First();
var old = new TextContent(textContent);
textContent = Binder.Update(schema, textContent, values);
textContent.Repository = repository.Name;
textContent.UserId = userid;
textContent.LastModificationDate = modificationDate;
var parentFolder = values["ParentFolder"];
if (!string.IsNullOrEmpty(parentFolder))
{
textContent.ParentFolder = parentFolder;
}
var parentUUID = values["ParentUUID"];
if (!string.IsNullOrEmpty(parentUUID))
{
textContent.ParentUUID = parentUUID;
}
if (files != null)
{
textContent.ContentFiles = GetPostFiles(files);
}
textContent.___EnableVersion___ = enableVersion;
//SaveFiles(textContent, schema, files);
EventBus.Content.ContentEvent.Fire(ContentAction.PreUpdate, textContent);
TextContentProvider.Update(textContent, old);
if (addedCateogries != null)
{
AddCategories(repository, textContent, addedCateogries.ToArray());
}
if (removedCategories != null)
{
RemoveCategories(repository, textContent, removedCategories.ToArray());
}
EventBus.Content.ContentEvent.Fire(ContentAction.Update, textContent);
return textContent;
}
protected virtual bool AllowSendingSetting(TextContent content, SendingSetting sendingSetting, ContentEventContext eventContext)
{
if (!string.IsNullOrEmpty(sendingSetting.FolderName) && !sendingSetting.FolderName.Equals(content.FolderName, StringComparison.CurrentCultureIgnoreCase))
{
return false;
}
if (!string.IsNullOrEmpty(content.OriginalUUID))
{
if (content.IsLocalized == null || content.IsLocalized.Value == false)
{
if ((sendingSetting.SendReceived == null || sendingSetting.SendReceived.Value == false))
{
return false;
}
}
}
return true;
}
public ContentEventContext(ContentAction contentAction, TextContent content)
{
this.ContentAction = contentAction;
this.Content = content;
}
public static IEnumerable<int> AllVersions(TextContent content)
{
return VersionLogger.AllVersions(content);
}
