public object Execute(IContentQuery<MediaContent> query)
{
var mediaQuery = (MediaContentQuery)query;
var blobClient = CloudStorageAccountHelper.GetStorageAccount().CreateCloudBlobClient();
QueryExpressionTranslator translator = new QueryExpressionTranslator();
var blobs = translator.Translate(query.Expression, blobClient, mediaQuery.MediaFolder)
.Where(it => it != null)
.Select(it => it.BlobToMediaContent(new MediaContent(mediaQuery.Repository.Name, mediaQuery.MediaFolder.FullName)));
//translator.Visite(query.Expression);
switch (translator.CallType)
{
case CallType.Count:
return blobs.Count();
case CallType.First:
return blobs.First();
case CallType.Last:
return blobs.Last();
case CallType.LastOrDefault:
return blobs.LastOrDefault();
case CallType.FirstOrDefault:
return blobs.FirstOrDefault();
case CallType.Unspecified:
default:
return blobs;
}
}
public object Execute(IContentQuery<MediaContent> query)
{
var mediaQuery = (MediaContentQuery)query;
QueryExpressionTranslator translator = new QueryExpressionTranslator();
translator.Translate(query.Expression);
//translator.Visite(query.Expression);
IEnumerable<MediaContent> contents;
switch (translator.CallType)
{
case CallType.Count:
return RemoteServiceFactory.CreateService<IMediaContentService>().Count(mediaQuery.MediaFolder.Repository.Name,
mediaQuery.MediaFolder.FullName, translator.Prefix);
case CallType.First:
contents = Execute(mediaQuery.MediaFolder, translator);
return contents.First();
case CallType.Last:
contents = Execute(mediaQuery.MediaFolder, translator);
return contents.Last();
case CallType.LastOrDefault:
contents = Execute(mediaQuery.MediaFolder, translator);
return contents.LastOrDefault();
case CallType.FirstOrDefault:
contents = Execute(mediaQuery.MediaFolder, translator);
return contents.FirstOrDefault();
case CallType.Unspecified:
default:
contents = Execute(mediaQuery.MediaFolder, translator);
return contents;
}
}
public QueryExpressionTranslator()
{
LinqExpression = it => true;
CategoryQueries = new IContentQuery<TextContent>[0];
OrderExpressions = new List<OrderExpression>();
}
public IContentQuery<ContentItem> FilterCulture(IContentQuery<ContentItem> query, string cultureName) {
var culture = _cultureManager.GetCultureByName(cultureName);
if (culture != null) {
return query.Where<LocalizationPartRecord>(x => x.CultureId == culture.Id);
}
return query;
}
public object Execute(IContentQuery<MediaContent> query)
{
var mediaQuery = (MediaContentQuery)query;
var blobClient = CloudStorageAccountHelper.GetStorageAccount().CreateCloudBlobClient();
QueryExpressionTranslator translator = new QueryExpressionTranslator();
var blobs = translator.Translate(query.Expression, blobClient, mediaQuery.MediaFolder)
.Where(it => it != null)
.Select(it => it.BlobToMediaContent(new MediaContent(mediaQuery.Repository.Name, mediaQuery.MediaFolder.FullName)));
foreach (var item in translator.OrderFields)
{
if (item.Descending)
{
blobs = blobs.OrderByDescending(it => it.GetType().GetProperty(item.FieldName).GetValue(it,null));
}
else
{
blobs = blobs.OrderBy(it => it.GetType().GetProperty(item.FieldName).GetValue(it,null));
}
}
//translator.Visite(query.Expression);
switch (translator.CallType)
{
case CallType.Count:
return blobs.Count();
case CallType.First:
return blobs.First();
case CallType.Last:
return blobs.Last();
case CallType.LastOrDefault:
return blobs.LastOrDefault();
case CallType.FirstOrDefault:
return blobs.FirstOrDefault();
case CallType.Unspecified:
default:
return blobs;
}
}
public MongoDBQuery Translate(IContentQuery<TextContent> contentQuery)
{
if (contentQuery is CategoriesQuery)
{
return new MongoDBCategoriesQuery(contentQuery);
}
else if (contentQuery is ChildrenQuery)
{
return new MongoDBChildrenQuery(contentQuery);
}
else if (contentQuery is ParentQuery)
{
return new MongoDBParentQuery(contentQuery);
}
else if (contentQuery is TextContentQuery)
{
return new MongoDBTextContentQuery(contentQuery);
}
return null;
}
public CouchbaseQuery Translate(IContentQuery<TextContent> contentQuery)
{
if (contentQuery is CategoriesQuery)
{
return new CouchbaseCategoryQuery((CategoriesQuery)contentQuery);
}
else if (contentQuery is ChildrenQuery)
{
return new CouchbaseChildrenQuery((ChildrenQuery)contentQuery);
}
else if (contentQuery is ParentQuery)
{
return new CouchbaseParentQuery((ParentQuery)contentQuery);
}
else if (contentQuery is TextContentQuery)
{
return new CouchbaseTextContentQuery((TextContentQuery)contentQuery);
}
return null;
}
public static object Execute(IContentQuery<TextContent> contentQuery)
{
QueryExecutorBase queryExecutor = null;
if (contentQuery is CategoriesQuery)
{
queryExecutor = new CategoriesQueryExecutor((CategoriesQuery)contentQuery);
}
else if (contentQuery is ParentQuery)
{
queryExecutor = new ParentQueryExecutor((ParentQuery)contentQuery);
}
else if (contentQuery is ChildrenQuery)
{
queryExecutor = new ChildrenQueryExecutor((ChildrenQuery)contentQuery);
}
else if (contentQuery is TextContentQuery)
{
queryExecutor = new TextContentQueryExecutor((TextContentQuery)contentQuery);
}
return queryExecutor.Execute();
}
public object Execute(IContentQuery <Models.TextContent> query)
{
Query.MongoDBQueryTranslator translator = new Query.MongoDBQueryTranslator();
return(translator.Translate(query).Execute());
}
protected abstract IContentQueryExtensionDuck <T> CreateDuck(IContentQuery <T> contentQuery);
public virtual ActionResult Index(string folderName, string parentUUID, string parentFolder, string search
, IEnumerable <WhereClause> whereClause, int?page, int?pageSize, string sortField = null, string sortDir = null)
{
//compatible with the Folder parameter changed to FolderName.
folderName = folderName ?? this.ControllerContext.RequestContext.GetRequestValue("Folder");
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
SchemaPath schemaPath = new SchemaPath(schema);
ViewData["Folder"] = textFolder;
ViewData["Schema"] = schema;
ViewData["Menu"] = textFolder.GetFormTemplate(FormType.Grid_Menu);
ViewData["Template"] = textFolder.GetFormTemplate(FormType.Grid);
ViewData["WhereClause"] = whereClause;
SetPermissionData(textFolder);
IEnumerable <TextFolder> childFolders = new TextFolder[0];
//Skip the child folders on the embedded folder grid.
if (string.IsNullOrEmpty(parentFolder))
{
if (!page.HasValue || page.Value <= 1)
{
childFolders = TextFolderManager.ChildFolders(textFolder, search).Select(it => it.AsActual());
}
}
IContentQuery <TextContent> query = textFolder.CreateQuery();
query = SortByField(sortField, sortDir, query);
bool showTreeStyle = schema.IsTreeStyle;
//如果有带搜索条件，则不输出树形结构
if (!string.IsNullOrEmpty(search))
{
IWhereExpression exp = new FalseExpression();
foreach (var item in schema.Columns.Where(it => it.ShowInGrid))
{
exp = new OrElseExpression(exp, (new WhereContainsExpression(null, item.Name, search)));
}
if (exp != null)
{
query = query.Where(exp);
}
showTreeStyle = false;
}
if (whereClause != null && whereClause.Count() > 0)
{
var expression = WhereClauseToContentQueryHelper.Parse(whereClause, schema, new MVCValueProviderWrapper(ValueProvider));
query = query.Where(expression);
showTreeStyle = false;
}
if (!string.IsNullOrWhiteSpace(parentUUID))
{
query = query.WhereEquals("ParentUUID", parentUUID);
}
else
{
//有两种情况需要考虑要不要查询所有的数据（ParentUUID=null)
//1.树形结构数据，第一次查询需要过滤ParentUUID==null
//2.自嵌套的目前结构，也需要过滤ParentUUID==null
var selfEmbedded = textFolder.EmbeddedFolders != null && textFolder.EmbeddedFolders.Contains(textFolder.FullName, StringComparer.OrdinalIgnoreCase);
if (showTreeStyle || selfEmbedded)
{
query = query.Where(new OrElseExpression(new WhereEqualsExpression(null, "ParentUUID", null), new WhereEqualsExpression(null, "ParentUUID", "")));
}
}
if (childFolders != null)
{
childFolders = childFolders
.Select(it => it.AsActual())
.Where(it => it.Visible)
.Where(it => Kooboo.CMS.Content.Services.ServiceFactory.WorkflowManager.AvailableViewContent(it, User.Identity.Name));
}
page = page ?? 1;
pageSize = pageSize ?? textFolder.PageSize;
//var pagedList = query.ToPageList(page.Value, pageSize.Value);
//IEnumerable<TextContent> contents = pagedList.ToArray();
//if (Repository.EnableWorkflow == true)
//{
// contents =WorkflowManager.GetPendWorkflowItemForContents(Repository, contents.ToArray(), User.Identity.Name);
//}
//var workflowContentPagedList = new PagedList<TextContent>(contents, page.Value, pageSize.Value, pagedList.TotalItemCount);
//ViewData["ContentPagedList"] = workflowContentPagedList;
return(View(new TextContentGrid()
{
ChildFolders = childFolders.OrderBy(it => it.FriendlyText).ToArray(),
ContentQuery = query,
PageIndex = page.Value,
PageSize = pageSize.Value,
ShowTreeStyle = showTreeStyle
}));
}
public CalendarController(IContentManager contentManager, IContentQuery contentQuery)
{
_contentManager = contentManager;
_contentQuery = contentQuery;
}
public IContentQuery<ContentItem> FilterCulture(IContentQuery<ContentItem> query, string cultureName) {
return query;
}
private static object GetData(DataRuleSetting dataRuleSetting, IContentQuery<TextContent> contentQuery)
{
if (dataRuleSetting.CachingDuration > 0)
{
var policy = new CacheItemPolicy() { SlidingExpiration = TimeSpan.FromSeconds(dataRuleSetting.CachingDuration) };
switch (dataRuleSetting.TakeOperation)
{
case TakeOperation.First:
var lazyFirst = contentQuery.LazyFirstOrDefault();
return GetCacheData(dataRuleSetting.TakeOperation, contentQuery, policy, () => lazyFirst.Value);
case TakeOperation.Count:
var lazyCount = contentQuery.LazyCount();
return GetCacheData(dataRuleSetting.TakeOperation, contentQuery, policy, () => lazyCount.Value);
case TakeOperation.List:
default:
return GetCacheData(dataRuleSetting.TakeOperation, contentQuery, policy, () => contentQuery.ToArray());
}
}
else
{
switch (dataRuleSetting.TakeOperation)
{
case TakeOperation.First:
return contentQuery.FirstOrDefault();
case TakeOperation.Count:
return contentQuery.Count();
case TakeOperation.List:
default:
return contentQuery.ToArray();
}
}
}
private IContentQuery <ConnectorPart, ConnectorPartRecord> ApplyConnectorCriteria(IContent left, ConnectorCriteria criteria, IContentQuery <ConnectorPart, ConnectorPartRecord> query)
{
if (criteria == ConnectorCriteria.Auto)
{
criteria = (!left.IsPublished() && left.ContentItem.VersionRecord != null && left.ContentItem.VersionRecord.Latest) ? ConnectorCriteria.Drafts : ConnectorCriteria.Published;
}
switch (criteria)
{
case ConnectorCriteria.Published:
// Always show published
query = query.ForVersion(VersionOptions.Published);
break;
case ConnectorCriteria.Drafts:
// Drafted item, get Latest (but exclude deleted)
query = query.ForVersion(VersionOptions.Latest).Where(c => !c.DeleteWhenLeftPublished);
break;
case ConnectorCriteria.DraftsAndDeleted:
// Drafted item, get Latest (but exclude deleted)
query = query.ForVersion(VersionOptions.Latest);
break;
}
return(query);
}
public CouchbaseQuery(IContentQuery <TextContent> contentQuery)
{
this.ContentQuery = contentQuery;
}
private IContentQuery<ConnectorPart, ConnectorPartRecord> ApplyConnectorCriteria(IContent left, ConnectorCriteria criteria, IContentQuery<ConnectorPart, ConnectorPartRecord> query) {
if (criteria == ConnectorCriteria.Auto)
criteria = (!left.IsPublished() && left.ContentItem.VersionRecord != null && left.ContentItem.VersionRecord.Latest) ? ConnectorCriteria.Drafts : ConnectorCriteria.Published;
switch (criteria) {
case ConnectorCriteria.Published:
// Always show published
query = query.ForVersion(VersionOptions.Published);
break;
case ConnectorCriteria.Drafts:
// Drafted item, get Latest (but exclude deleted)
query = query.ForVersion(VersionOptions.Latest).Where(c => !c.DeleteWhenLeftPublished);
break;
case ConnectorCriteria.DraftsAndDeleted:
// Drafted item, get Latest (but exclude deleted)
query = query.ForVersion(VersionOptions.Latest);
break;
}
return query;
}
public MongoDBQuery(IContentQuery <TextContent> contentQuery)
{
this.ContentQuery = contentQuery;
}
public override NCMIS.ObjectModel.PathedCmisObjectList GetChildren(string repositoryId, string folderId, int?maxItems, int skipCount, string orderBy, string filter, IncludeRelationships includeRelationships, string renditionFilter, bool includeAllowableActions, bool includePathSegment)
{
Kooboo.CMS.Content.Models.Repository repository = new Models.Repository(repositoryId);
IObjectService folderService = ObjectService.GetService(typeof(Folder));
string objectId = folderId;
folderService.TryPraseObjectId(objectId, out folderId);
FolderType folderType = CmisFolderHelper.IdentifyFolderType(repository, folderId);
PathedCmisObjectList pathedList = new PathedCmisObjectList();
IEnumerable <PathedCmisObject> children = folderService.GetChildren(repositoryId, objectId, filter, includeRelationships)
.Select(it => new PathedCmisObject()
{
Object = it
});
var count = children.Count();
pathedList.NumItems = count.ToString();
pathedList.HasMoreItems = false;
//IEnumerable<ContentBase> contents = new ContentBase[0];
if (folderType == FolderType.Content_Folder || folderType == FolderType.Media_Folder)
{
var folder = CmisFolderHelper.Parse(repository, folderId).AsActual();
IContentQuery <ContentBase> contentQuery = null;
if (folder is TextFolder)
{
var textFolder = (TextFolder)folder;
var schema = new Schema(repository, textFolder.SchemaName).AsActual();
contentQuery = textFolder.CreateQuery();
if (!string.IsNullOrEmpty(filter))
{
foreach (var item in schema.Columns)
{
contentQuery = contentQuery.Or(new WhereContainsExpression(null, item.Name, filter));
}
}
}
else
{
var mediaFolder = (TextFolder)folder;
contentQuery = mediaFolder.CreateQuery();
if (!string.IsNullOrEmpty(filter))
{
contentQuery = contentQuery.WhereContains("FileName", filter);
}
}
if (!string.IsNullOrEmpty(orderBy))
{
contentQuery = contentQuery.OrderBy(orderBy);
}
count = contentQuery.Count();
var take = maxItems.HasValue ? maxItems.Value : count;
pathedList.NumItems = count.ToString();
pathedList.HasMoreItems = count > count + take;
children = children.Concat(contentQuery.Select(it => new PathedCmisObject()
{
Object = ObjectConvertor.ToCmis((TextContent)(it), includeRelationships != IncludeRelationships.None)
}).Take(take));
}
pathedList.Objects = children.ToArray();
return(pathedList);
}
public QueryBuiltContext(IGraphDescriptor graphDescriptor, IContentQuery<ContentItem> query)
{
GraphDescriptor = graphDescriptor;
Query = query;
}
private object TranslateExpression(IContentQuery<ContentItem> contentQuery, Expression expression)
{
var translator = new OrchardQueryTranslator(_type,_dataSource);
return translator.Translate(contentQuery, expression);
}
public QueryExpressionTranslator()
{
LinqExpression = it => true;
CategoryQueries = new IContentQuery<TextContent>[0];
}
public CouchbaseQuery(IContentQuery<TextContent> contentQuery)
{
this.ContentQuery = contentQuery;
}
public static IContentQuery <T> ForContentItems <T>(this IContentQuery <T> query, params int[] ids) where T : IContent
{
return(query.ForContentItems(ids));
}
public MongoDBQuery(IContentQuery<TextContent> contentQuery)
{
this.ContentQuery = contentQuery;
}
public static IEnumerable <T> List <T>(this IContentQuery query) where T : IContent
{
return(query.ForPart <T>().List());
}
private IContentQuery <ContentItem> OrderByPosition(IContentQuery <ContentItem> query)
{
return(query.Join <ContainablePartRecord>().OrderByDescending(x => x.Position));
}
public static IEnumerable <T> Slice <T>(this IContentQuery <T> query, int count) where T : IContent
{
return(query.Slice(0, count));
}
public MongoDBVisitor()
{
CategoryQueries = new IContentQuery<TextContent>[0];
}
protected override DriverResult Display(RelatedContentWidgetPart part, string displayType, dynamic shapeHelper)
{
List <string> tags = part.TagList
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(s => s.Trim())
.Where(s => !String.IsNullOrEmpty(s))
.Distinct()
.ToList();
// If we have no tags.....
if (tags.Count < 1)
{
return(ContentShape("Parts_RelatedContentWidget",
() => shapeHelper.Parts_RelatedContentWidget(
ContentItems: shapeHelper.List()
)));
}
// See if we can find the current page/content id to filter it out
// from the related content if necessary.
int currentItemId = -1;
if (part.ExcludeCurrentItemIfMatching)
{
currentItemId = TryGetCurrentContentId(-1);
}
// Setup a query on the tags part
IContentQuery <TagsPart, TagsPartRecord> query = _cms.Query <TagsPart, TagsPartRecord>();
if (part.MustHaveAllTags)
{
// Add where conditions for every tag specified
foreach (string tag in tags)
{
string tag1 = tag; // Prevent access to modified closure
query.Where(tpr => tpr.Tags.Any(t => t.TagRecord.TagName == tag1));
}
}
else
{
// Add where condition for any tag specified
query.Where(tpr => tpr.Tags.Any(t => tags.Contains(t.TagRecord.TagName)));
}
// Finish the query (exclude current, do ordering and slice max items) and execute
IEnumerable <TagsPart> parts =
query.Join <CommonPartRecord>()
.Where(cpr => cpr.Id != currentItemId)
.OrderByDescending(cpr => cpr.PublishedUtc)
.Slice(part.MaxItems);
// Create a list and push our display content items in
var list = shapeHelper.List();
list.AddRange(parts.Select(p => _cms.BuildDisplay(p, "Summary")));
return(ContentShape("Parts_RelatedContentWidget",
() => shapeHelper.Parts_RelatedContentWidget(
ShowListOnly: part.ShowListOnly,
ContentItems: list
)));
}
public virtual ActionResult SelectCategories(string folderName, string selected, int?page, int?pageSize, string search, IEnumerable <WhereClause> whereClause
, string sortField = null, string sortDir = null)
{
var textFolder = (TextFolder)(FolderHelper.Parse <TextFolder>(Repository, folderName).AsActual());
var singleChoice = string.Equals("True", Request.RequestContext.GetRequestValue("SingleChoice"), StringComparison.OrdinalIgnoreCase);
Schema schema = new Schema(Repository, textFolder.SchemaName).AsActual();
SchemaPath schemaPath = new SchemaPath(schema);
ViewData["Folder"] = textFolder;
ViewData["Schema"] = schema;
ViewData["Template"] = textFolder.GetFormTemplate(FormType.Selectable);
ViewData["WhereClause"] = whereClause;
IEnumerable <TextFolder> childFolders = new TextFolder[0];
//Skip the child folders on the embedded folder grid.
if (!page.HasValue || page.Value <= 1)
{
childFolders = ServiceFactory.TextFolderManager.ChildFoldersWithSameSchema(textFolder).Select(it => it.AsActual());
}
var query = textFolder.CreateQuery();
query = SortByField(sortField, sortDir, query);
bool showTreeStyle = schema.IsTreeStyle;
if (showTreeStyle)
{
query = query.Where(new OrElseExpression(new WhereEqualsExpression(null, "ParentUUID", null), new WhereEqualsExpression(null, "ParentUUID", "")));
}
if (!string.IsNullOrEmpty(search))
{
IWhereExpression exp = new FalseExpression();
foreach (var item in schema.Columns.Where(it => it.ShowInGrid))
{
exp = new OrElseExpression(exp, (new WhereContainsExpression(null, item.Name, search)));
}
if (exp != null)
{
query = query.Where(exp);
}
showTreeStyle = false;
}
if (whereClause != null && whereClause.Count() > 0)
{
var expression = WhereClauseToContentQueryHelper.Parse(whereClause, schema, new MVCValueProviderWrapper(ValueProvider));
query = query.Where(expression);
showTreeStyle = false;
}
var contents = query.ToPageList(page ?? 1, pageSize ?? textFolder.PageSize, textFolder.EnablePaging.HasValue ? textFolder.EnablePaging.Value : true);
SelectableViewModel viewModel = new SelectableViewModel()
{
ShowTreeStyle = showTreeStyle, ChildFolders = childFolders, Contents = contents, SingleChoice = singleChoice
};
if (Request.IsAjaxRequest())
{
return(PartialView("", viewModel));
}
else
{
IEnumerable <TextContent> selectedContents = new TextContent[0];
if (!string.IsNullOrEmpty(selected))
{
string[] selectedArr = selected.Split(',');
IContentQuery <TextContent> selectedQuery = textFolder.CreateQuery().DefaultOrder();
foreach (var userKey in selectedArr)
{
selectedQuery = selectedQuery.Or((IWhereExpression)textFolder.CreateQuery().DefaultOrder().WhereEquals("UUID", userKey).Expression);
}
selectedContents = selectedQuery;
}
viewModel.Selected = selectedContents;
}
return(View(viewModel));
}
public RootVisitor(ContentTypeDefinition type, OrchardDataSource dataSource, IContentQuery<ContentItem> contentQuery, bool isAtRoot) {
_type = type;
_dataSource = dataSource;
_contentQuery = contentQuery;
_isAtRoot = isAtRoot;
}
public MongoDBCategoriesQuery(IContentQuery <TextContent> contentQuery)
: base(contentQuery)
{
}
protected override IContentQueryExtensionDuck <TextContent> CreateDuck(IContentQuery <TextContent> contentQuery)
{
return(new ITextContentQueryExtensionDuck(contentQuery));
}
public ITextContentQueryExtensionDuck(IContentQuery <TextContent> contentQuery)
: this(contentQuery, EXTENSION_TYPES)
{
}
public IMediaContentQueryExtensionDuck(IContentQuery <MediaContent> contentQuery, params Type[] extentionTypes)
: base(contentQuery, extentionTypes)
{
}
public IMediaContentQueryExtensionDuck(IContentQuery <MediaContent> contentQuery)
: this(contentQuery, EXTENSION_TYPES)
{
}
public MongoDBChildrenQuery(IContentQuery <TextContent> contentQuery)
: base(contentQuery)
{
}
public MongoDBTextContentQuery(IContentQuery <TextContent> contentQuery)
: base(contentQuery)
{
}
private void OrchardRegister(FacebookAccountVM fvm)
{
string displayas = "";
string AccountType = "";
if (string.IsNullOrEmpty(fvm.PageName))
{
string json = new WebClient().DownloadString("https://graph.facebook.com/me?access_token=" + fvm.UserToken);
displayas = (JObject.Parse(json))["name"].ToString();
AccountType = "User";
}
else
{
displayas = fvm.PageName;
AccountType = "Page";
}
IContentQuery <ContentItem> contentQuery = _orchardServices.ContentManager.Query().ForType(contentType);
Int32 currentiduser = _orchardServices.WorkContext.CurrentUser.Id;
fvm.IdPage = fvm.IdPage ?? "";
Int32 elementi = contentQuery.List().Where(x => x.As <FacebookAccountPart>().IdUser == currentiduser && (x.As <FacebookAccountPart>().DisplayAs == displayas)).Count();
if (elementi > 0)
{
if (string.IsNullOrEmpty(fvm.IdPage))
{
_notifier.Add(NotifyType.Warning, T("User Facebook Account can't be added, is duplicated"));
}
else
{
_notifier.Add(NotifyType.Warning, T("Facebook Page {0} can't be added, is duplicated", fvm.PageName));
}
}
else
{
var newContent = _orchardServices.ContentManager.New(contentType);
_orchardServices.ContentManager.Create(newContent);
newContent.As <FacebookAccountPart>().IdUser = currentiduser;
newContent.As <FacebookAccountPart>().AccountType = AccountType;
newContent.As <FacebookAccountPart>().DisplayAs = displayas;
newContent.As <FacebookAccountPart>().SocialName = "Facebook";
newContent.As <FacebookAccountPart>().UserToken = fvm.UserToken;
newContent.As <FacebookAccountPart>().Valid = false;
newContent.As <FacebookAccountPart>().PageName = fvm.PageName;
newContent.As <FacebookAccountPart>().PageToken = fvm.PageToken;
newContent.As <FacebookAccountPart>().IdPage = fvm.IdPage ?? "";
newContent.As <FacebookAccountPart>().Shared = false;
newContent.As <FacebookAccountPart>().UserIdFacebook = fvm.UserIdFacebook ?? "";
newContent.As <FacebookAccountPart>().UserName = fvm.UserName ?? "";
if (string.IsNullOrEmpty(fvm.IdPage))
{
_notifier.Add(NotifyType.Warning, T("User Facebook Account added"));
}
else
{
_notifier.Add(NotifyType.Warning, T("Facebook Page {0} added", fvm.PageName));
}
}
}
private IContentQuery<ContentItem> OrderByPosition(IContentQuery<ContentItem> query) {
return query.Join<ContainablePartRecord>().OrderByDescending(x => x.Position);
}
public QueryExpressionTranslator()
{
LinqExpression = it => true;
CategoryQueries = new IContentQuery <TextContent> [0];
}
private static object GetCacheData(TakeOperation operation, IContentQuery<TextContent> contentQuery, CacheItemPolicy policy, Func<object> getData)
{
string cacheKey = "TakeOperation:" + operation.ToString() + " " + TextTranslator.Translate(contentQuery);
var data = ObjectCache.Get(cacheKey, CacheRegionName);
if (data == null)
{
data = getData();
ObjectCache.AddOrGetExisting(cacheKey, data, policy, CacheRegionName);
}
return data;
}
public WhereCategoryExpression(IContentQuery<TextContent> categoryQuery)
: this(null, categoryQuery)
{
}
public static Lazy <int> LazyCount <T>(this IContentQuery <T> contentQuery)
where T : ContentBase
{
contentQuery = contentQuery.Create(new CallExpression(contentQuery.Expression, CallType.Count));
return(new Lazy <int>(() => (int)contentQuery.Count()));
}
public MongoDBChildrenQuery(IContentQuery<TextContent> contentQuery)
: base(contentQuery)
{
}
public object Execute(IContentQuery<Models.TextContent> query)
{
Query.MongoDBQueryTranslator translator = new Query.MongoDBQueryTranslator();
return translator.Translate(query).Execute();
}
public static Lazy <T> LazyLastOrDefault <T>(this IContentQuery <T> contentQuery)
where T : ContentBase
{
contentQuery = contentQuery.Create(new CallExpression(contentQuery.Expression, CallType.LastOrDefault));
return(new Lazy <T>(() => contentQuery.LastOrDefault()));
}
protected override IContentQueryExtensionDuck <MediaContent> CreateDuck(IContentQuery <MediaContent> contentQuery)
{
return(new IMediaContentQueryExtensionDuck(contentQuery));
}
public IEnumerable <ContentItem> GetContactList(SearchVM search)
{
IEnumerable <ContentItem> contentItems = null;
List <int> arr = null;
IContentQuery <ContentItem> contentQuery = _contentManager.Query(VersionOptions.Latest).ForType("CommunicationContact");
if (!(string.IsNullOrEmpty(search.Expression) && !search.CommercialUseAuthorization.HasValue && !search.ThirdPartyAuthorization.HasValue))
{
switch (search.Field)
{
case SearchFieldEnum.Name:
contentItems = contentQuery.Where <TitlePartRecord>(w => w.Title.Contains(search.Expression)).List();
break;
case SearchFieldEnum.Mail:
string myQueryMail = @"select cir.Id
from Orchard.ContentManagement.Records.ContentItemVersionRecord as civr
join civr.ContentItemRecord as cir
join cir.EmailContactPartRecord as EmailPart
join EmailPart.EmailRecord as EmailRecord
where 1 = 1 ";
if (!string.IsNullOrEmpty(search.Expression))
{
myQueryMail += "and EmailRecord.Email like '%' + :mail + '%' ";
}
if (search.CommercialUseAuthorization.HasValue)
{
myQueryMail += "and EmailRecord.AccettatoUsoCommerciale = :commuse ";
}
if (search.ThirdPartyAuthorization.HasValue)
{
myQueryMail += "and EmailRecord.AutorizzatoTerzeParti = :tpuse ";
}
myQueryMail += "order by cir.Id";
var mailQueryToExecute = _transactionManager.GetSession().CreateQuery(myQueryMail);
if (!string.IsNullOrEmpty(search.Expression))
{
mailQueryToExecute.SetParameter("mail", search.Expression);
}
if (search.CommercialUseAuthorization.HasValue)
{
mailQueryToExecute.SetParameter("commuse", search.CommercialUseAuthorization.Value, NHibernateUtil.Boolean);
}
if (search.ThirdPartyAuthorization.HasValue)
{
mailQueryToExecute.SetParameter("tpuse", search.ThirdPartyAuthorization.Value, NHibernateUtil.Boolean);
}
var elencoIdMail = mailQueryToExecute.List <int>();
arr = new List <int>(elencoIdMail);
contentItems = contentQuery.Where <CommunicationContactPartRecord>(x => arr.Contains(x.Id)).List();
break;
case SearchFieldEnum.Phone:
string myQuerySms = @"select cir.Id
from Orchard.ContentManagement.Records.ContentItemVersionRecord as civr
join civr.ContentItemRecord as cir
join cir.SmsContactPartRecord as SmsPart
join SmsPart.SmsRecord as SmsRecord
where 1 = 1 ";
if (!string.IsNullOrEmpty(search.Expression))
{
myQuerySms += "and SmsRecord.Sms like '%' + :sms + '%' ";
}
if (search.CommercialUseAuthorization.HasValue)
{
myQuerySms += "and SmsRecord.AccettatoUsoCommerciale = :commuse ";
}
if (search.ThirdPartyAuthorization.HasValue)
{
myQuerySms += "and SmsRecord.AutorizzatoTerzeParti = :tpuse ";
}
myQuerySms += "order by cir.Id";
var smsQueryToExecute = _transactionManager.GetSession().CreateQuery(myQuerySms);
if (!string.IsNullOrEmpty(search.Expression))
{
smsQueryToExecute.SetParameter("sms", search.Expression);
}
if (search.CommercialUseAuthorization.HasValue)
{
smsQueryToExecute.SetParameter("commuse", search.CommercialUseAuthorization.Value, NHibernateUtil.Boolean);
}
if (search.ThirdPartyAuthorization.HasValue)
{
smsQueryToExecute.SetParameter("tpuse", search.ThirdPartyAuthorization.Value, NHibernateUtil.Boolean);
}
var elencoIdSms = smsQueryToExecute.List <int>();
arr = new List <int>(elencoIdSms);
contentItems = contentQuery.Where <CommunicationContactPartRecord>(x => arr.Contains(x.Id)).List();
break;
}
}
else
{
contentItems = contentQuery.List();
};
return(contentItems);
}
public WhereCategoryExpression(IExpression expression, IContentQuery<TextContent> categoryQuery)
: base(expression)
{
this.CategoryQuery = categoryQuery;
}
public IContentQueryExtensionDuck(IContentQuery <T> contentQuery, params Type[] extentionTypes)
: base(contentQuery, extentionTypes)
{
this.innerContentQuery = contentQuery;
}
public MongoDBTextContentQuery(IContentQuery<TextContent> contentQuery)
: base(contentQuery)
{
}
public MysqlVisitor(List <Parameter> parameters)
{
this.parameters = parameters;
CategoryQueries = new IContentQuery <TextContent> [0];
}
public CouchbaseVisitor()
{
CategoryQueries = new IContentQuery<TextContent>[0];
}
public MongoDBVisitor()
{
CategoryQueries = new IContentQuery <TextContent> [0];
}
public MongoDBCategoriesQuery(IContentQuery<TextContent> contentQuery)
: base(contentQuery)
{
}
private static IContentQuery <TextContent> SortByField(string sortField, string sortDir, IContentQuery <TextContent> query)
{
if (string.IsNullOrEmpty(sortField))
{
query = query.DefaultOrder();
}
else
{
if (!string.IsNullOrEmpty(sortDir) && sortDir.ToLower() == "desc")
{
query = query.OrderByDescending(sortField);
}
else
{
query = query.OrderBy(sortField);
}
}
return(query);
}
private static IContentQuery<TextContent> SortByField(string sortField, string sortDir, IContentQuery<TextContent> query)
{
if (string.IsNullOrEmpty(sortField))
{
query = query.DefaultOrder();
}
else
{
if (!string.IsNullOrEmpty(sortDir) && sortDir.ToLower() == "desc")
{
query = query.OrderByDescending(sortField);
}
else
{
query = query.OrderBy(sortField);
}
}
return query;
}
public static void GetCriterion(ContentTypeDefinition type, IContentQuery<ContentItem> contentQuery, Expression expression) {
WhereArgumentsVisitor visitor = new WhereArgumentsVisitor(type, contentQuery);
visitor.Visit(expression);
}
