private IEnumerable <T> LoadContentItems <T>(IQuery query, QueryHints hints = null) where T : class, IContent
{
var rows = query.List <object>();
var versionIds = rows.Cast <object[]>().Select(x => (int)x[0]);
return(_contentManager.GetManyByVersionId <T>(versionIds, hints ?? QueryHints.Empty));
}
private void InitializerTermsLoader(TermsPart part) {
if (part._termParts != null) {
return;
}
var queryHint = new QueryHints()
.ExpandRecords("ContentTypeRecord", "CommonPartRecord", "TermsPartRecord");
foreach (var field in part.ContentItem.Parts.SelectMany(p => p.Fields).OfType<TaxonomyField>()) {
var tempField = field.Name;
field.TermsField.Loader(() => {
var fieldTermRecordIds = part.Record.Terms.Where(t => t.Field == tempField).Select(tci => tci.TermRecord.Id);
var terms = _contentManager.GetMany<TermPart>(fieldTermRecordIds, VersionOptions.Published, queryHint);
return terms.ToList();
});
}
part._termParts = new LazyField<IEnumerable<TermContentItemPart>>();
part._termParts.Loader(() => {
var ids = part.Terms.Select(t => t.TermRecord.Id).Distinct();
var terms = _contentManager.GetMany<TermPart>(ids, VersionOptions.Published, queryHint)
.ToDictionary(t => t.Id, t => t);
return
part.Terms.Select(
x =>
new TermContentItemPart {
Field = x.Field,
TermPart = terms[x.TermRecord.Id]
}
);
});
}
public virtual ContentItem Get(int id, VersionOptions options, QueryHints hints, string contentType)
{
ContentItem contentItem;
ContentItemVersionRecord versionRecord = null;
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentType);
if (contentTypeDefinition == null)
{
contentTypeDefinition = new ContentTypeDefinitionBuilder().Named(contentType).Build();
}
if (hints == QueryHints.Empty)
{
hints = new QueryHints();
}
hints = hints.ExpandRecords(contentTypeDefinition.Parts.Select(c => c.PartDefinition.Name + "Record"));
// do a query to load the records in case Get is called directly
contentItem = GetContentItem(hints, contentTypeDefinition,
(contentItemCriteria, contentItemVersionCriteria) =>
{
contentItemCriteria.Add(Restrictions.Eq("Id", id));
if (options.IsPublished)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Published", true));
}
else if (options.IsLatest)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItemVersionCriteria.Add(
Restrictions.And(Restrictions.Eq("Published", false),
Restrictions.Eq("Latest", true)));
}
else if (options.IsDraft || options.IsDraftRequired)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
if (options.VersionNumber != default(int))
{
contentItemVersionCriteria.Add(Restrictions.Eq("VersionNumber", options.VersionNumber));
}
contentItemVersionCriteria.SetFetchMode("ContentItemRecord", FetchMode.Eager);
contentItemVersionCriteria.SetFetchMode("ContentItemRecord.ContentType", FetchMode.Eager);
contentItemVersionCriteria.SetMaxResults(1);
});
FinalizeContentItem(contentItem, options, contentType);
return(contentItem);
}
public ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
return(_glimpseService.PublishTimedAction(() => _decoratedService.Get(id, options, hints), (r, t) => new ContentManagerGetMessage {
ContentId = id,
ContentType = GetContentType(id, r),
Name = r.GetContentName(),
Duration = t.Duration,
VersionOptions = options
}, TimelineCategories.ContentManager, r => "Get: " + GetContentType(id, r), r => r.GetContentName()).ActionResult);
}
public new ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
return(_performanceMonitor.PublishTimedAction(() => base.Get(id, options, hints), (r, t) => new ContentManagerMessage
{
ContentId = id,
ContentType = GetContentType(id, r, options),
Name = r.GetContentName(),
Duration = t.Duration,
//VersionOptions = options
}, TimelineCategories.ContentManagement, r => "Get: " + GetContentType(id, r, options), r => r.GetContentName()).ActionResult);
}
public new ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
return _performanceMonitor.PublishTimedAction(() => base.Get(id, options, hints), (r, t) => new ContentManagerMessage
{
ContentId = id,
ContentType = GetContentType(id, r, options),
Name = r.GetContentName(),
Duration = t.Duration,
//VersionOptions = options
}, TimelineCategories.ContentManagement, r => "Get: " + GetContentType(id, r, options), r=> r.GetContentName()).ActionResult;
}
public IEnumerable <ProductPartQuantity> GetProductQuantitiesFor(BundlePart bundle)
{
var quantities = bundle.ProductQuantities.ToDictionary(q => q.ProductId, q => q.Quantity);
var queryHints = new QueryHints()
.ExpandRecords <TitlePartRecord, MediaPartRecord>();
var parts = _contentManager.GetMany <ProductPart>(quantities.Keys, VersionOptions.Published, queryHints);
return(parts.Select(p => new ProductPartQuantity {
Product = p,
Quantity = quantities[p.ContentItem.Id]
}).ToList());
}
private IEnumerable <TerritoryPart> GetTerritoryParents(TerritoryQueryContext context)
{
IEnumerable <TerritoryPart> list;
var root = context.ForTerritory;
// make sure root we'll use belongs to hierarchy
if (root.HierarchyPart.Id != ConfiguredHierarchy.Id)
{
root = SingleTerritory(root.Record.TerritoryInternalRecord.Id);
}
if (root == null)
{
// if the root is not valid for the hierarchy, we cannot return
// any city.
return(Enumerable.Empty <TerritoryPart>());
}
var rootPath = root.TerritoriesFullPath;
var parentIds = rootPath.Split(new string[] { "\\" }, StringSplitOptions.RemoveEmptyEntries).Select(x => {
int id = 0;
int.TryParse(x, out id);
return(id);
}).ToList();
parentIds.ToList().Remove(root.Id);
var queryHints = new QueryHints()
.ExpandRecords <TerritoryAdministrativeTypePartRecord, TitlePartRecord>();
var query = _contentManager.Query();
query = query
.Join <TerritoryAdministrativeTypePartRecord>()
.Where(x => x.AdministrativeType == context.TerritoryAdministrativeType.Value && parentIds.Contains(x.Id))
.Join <TitlePartRecord>()
.OrderBy(x => x.Title);
if (context.MaxResultItems.HasValue)
{
list = query
.ForPart <TerritoryPart>()
.Join <TerritoryPartRecord>()
.Slice(0, context.MaxResultItems.Value);
}
else
{
list = query
.ForPart <TerritoryPart>()
.Join <TerritoryPartRecord>()
.List();
}
return(list);
}
internal void SetHints(QueryHints hints)
{
if (hints.IsEmpty)
{
return;
}
IntPtr qptr = _functions.SetHints(Collection.Database.DatabaseHandle, this, hints.ToByteArray());
if (qptr == IntPtr.Zero)
{
//TODO: throw more specific exception
//throw new EJDBQueryException(_jb);
EjdbException.FromDatabase(Collection.Database, "Failed to set hints");
}
}
private ContentItem GetContentItem(QueryHints hints, ContentTypeDefinition contentTypeDefinition, Action <ICriteria, ICriteria> predicate)
{
var session = _sessionLocator.Value.For(typeof(ContentItemRecord));
var contentItemVersionCriteria = session.CreateCriteria(typeof(ContentItemVersionRecord));
var contentItemCriteria = contentItemVersionCriteria.CreateCriteria("ContentItemRecord");
predicate(contentItemCriteria, contentItemVersionCriteria);
var contentItemMetadata = session.SessionFactory.GetClassMetadata(typeof(ContentItemRecord));
var contentItemVersionMetadata = session.SessionFactory.GetClassMetadata(typeof(ContentItemVersionRecord));
if (hints != QueryHints.Empty)
{
// break apart and group hints by their first segment
var hintDictionary = hints.Records
.Select(hint => new { Hint = hint, Segments = hint.Split('.') })
.GroupBy(item => item.Segments.FirstOrDefault())
.ToDictionary(grouping => grouping.Key, StringComparer.InvariantCultureIgnoreCase);
// locate hints that match properties in the ContentItemVersionRecord
foreach (var hit in contentItemVersionMetadata.PropertyNames.Where(hintDictionary.ContainsKey).SelectMany(key => hintDictionary[key]))
{
contentItemVersionCriteria.SetFetchMode(hit.Hint, FetchMode.Eager);
hit.Segments.Take(hit.Segments.Count() - 1).Aggregate(contentItemVersionCriteria, ExtendCriteria);
}
// locate hints that match properties in the ContentItemRecord
foreach (var hit in contentItemMetadata.PropertyNames.Where(hintDictionary.ContainsKey).SelectMany(key => hintDictionary[key]))
{
contentItemVersionCriteria.SetFetchMode("ContentItemRecord." + hit.Hint, FetchMode.Eager);
hit.Segments.Take(hit.Segments.Count() - 1).Aggregate(contentItemCriteria, ExtendCriteria);
}
if (hintDictionary.SelectMany(x => x.Value).Any(x => x.Segments.Count() > 1))
{
contentItemVersionCriteria.SetResultTransformer(new DistinctRootEntityResultTransformer());
}
}
contentItemCriteria.SetCacheable(true);
ContentItemTransformer contentItemTransformer = new ContentItemTransformer(contentTypeDefinition, this.partTypeRecordMatchingService, this.New);
var returnValue = contentItemVersionCriteria.SetResultTransformer(contentItemTransformer).List <ContentItem>();
return(returnValue.FirstOrDefault());
}
void IDisposable.Dispose()
{
if (_dataConnection != null)
{
if (_dataConnection.QueryHints.Count > 0)
{
QueryHints.AddRange(_queryHints);
}
if (_dataConnection.NextQueryHints.Count > 0)
{
NextQueryHints.AddRange(_nextQueryHints);
}
_dataConnection.Dispose();
_dataConnection = null;
}
}
internal void ReleaseQuery()
{
if (_dataConnection != null)
{
if (LockDbManagerCounter == 0 && KeepConnectionAlive == false)
{
if (_dataConnection.QueryHints.Count > 0)
{
QueryHints.AddRange(_queryHints);
}
if (_dataConnection.NextQueryHints.Count > 0)
{
NextQueryHints.AddRange(_nextQueryHints);
}
_dataConnection.Dispose();
_dataConnection = null;
}
}
}
/// <summary>
/// Closes underlying connection and fires <see cref="OnClosing"/> event (only if connection existed).
/// </summary>
void Close()
{
if (_dataConnection != null)
{
if (OnClosing != null)
{
OnClosing(this, EventArgs.Empty);
}
if (_dataConnection.QueryHints.Count > 0)
{
QueryHints.AddRange(_queryHints);
}
if (_dataConnection.NextQueryHints.Count > 0)
{
NextQueryHints.AddRange(_nextQueryHints);
}
_dataConnection.Dispose();
_dataConnection = null;
}
}
private void InitializerTermsLoader(TermsPart part)
{
if (part._termParts != null)
{
return;
}
var queryHint = new QueryHints()
.ExpandRecords("ContentTypeRecord", "CommonPartRecord", "TermsPartRecord");
foreach (var field in part.ContentItem.Parts.SelectMany(p => p.Fields).OfType <TaxonomyField>())
{
var tempField = field.Name;
field.TermsField.Loader(() => {
var fieldTermRecordIds = part.Record.Terms.Where(t => t.Field == tempField).Select(tci => tci.TermRecord.Id);
var terms = _contentManager.GetMany <TermPart>(fieldTermRecordIds, VersionOptions.Published, queryHint);
return(terms.ToList());
});
}
part._termParts = new LazyField <IEnumerable <TermContentItemPart> >();
part._termParts.Loader(() => {
var ids = part.Terms.Select(t => t.TermRecord.Id).Distinct();
var terms = _contentManager.GetMany <TermPart>(ids, VersionOptions.Published, queryHint)
.ToDictionary(t => t.Id, t => t);
return
(part.Terms.Select(
x =>
new TermContentItemPart {
Field = x.Field,
TermPart = terms[x.TermRecord.Id]
}
));
});
}
public IEnumerable <T> GetMany <T>(IEnumerable <int> ids, VersionOptions options, QueryHints hints) where T : class, IContent
{
return(_decoratedService.GetMany <T>(ids, options, hints));
}
public IEnumerable <T> GetManyByVersionId <T>(IEnumerable <int> versionRecordIds, QueryHints hints) where T : class, IContent
{
return(_decoratedService.GetManyByVersionId <T>(versionRecordIds, hints));
}
public IEnumerable <ContentItem> GetManyByVersionId(IEnumerable <int> versionRecordIds, QueryHints hints)
{
return(_decoratedService.GetManyByVersionId(versionRecordIds, hints));
}
public IEnumerable <T> GetMany <T>(IEnumerable <int> contentItemIds, QueryHints hints = null) where T : class, IContent
{
var query = GetDeletedVersionsQuery(contentItemIds);
return(LoadContentItems <T>(query, hints));
}
public IEnumerable <ContentItem> GetMany(IEnumerable <int> contentItemIds, QueryHints hints = null)
{
return(GetMany <ContentItem>(contentItemIds, hints));
}
public IEnumerable <T> GetMany <T>(IEnumerable <int> ids, VersionOptions options, QueryHints hints) where T : class, IContent
{
var idList = ids.ToList();
return(_contentItems
.Where(i => idList.Contains(i.Id))
.Select(i => i.As <T>()));
}
public IContentQuery <TPart, TRecord> WithQueryHints(QueryHints hints)
{
return(this);
}
public IEnumerable <T> GetManyByVersionId <T>(IEnumerable <int> versionRecordIds, QueryHints hints) where T : class, IContent
{
throw new NotImplementedException();
}
public ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
throw new NotImplementedException();
}
public IDictionary <string, IEnumerable <T> > GetRelatedByContentItems <T>(int contentId, VersionOptions options, QueryHints hints) where T : class, IContent
{
var query = from record in mRepository.Table where record.RelatedContentItemId == contentId select record;
var records = query.ToList();
var relatedContentItemIds = records.Select(x => x.ContentItemId).ToList();
var relatedContentItems = mContentManager.GetMany <T>(relatedContentItemIds, options, hints).ToLookup(x => x.Id);
var dictionary = new Dictionary <string, IEnumerable <T> >();
foreach (var record in records)
{
if (!dictionary.ContainsKey(record.Discriminator))
{
dictionary.Add(record.Discriminator, new List <T>());
}
var list = (IList <T>)dictionary[record.Discriminator];
list.AddRange(relatedContentItems[record.ContentItemId]);
}
return(dictionary);
}
public IEnumerable <T> GetRelatedContentItems <T>(int contentId, VersionOptions options, QueryHints hints, string discriminator = null) where T : class, IContent
{
var query = from record in mRepository.Table where record.ContentItemId == contentId select record;
if (!String.IsNullOrEmpty(discriminator))
{
query = from record in query where record.Discriminator == discriminator select record;
}
var relatedContentItemIds = query.Select(x => x.RelatedContentItemId).ToList();
return(mContentManager.GetMany <T>(relatedContentItemIds, options, hints));
}
public IEnumerable <T> GetMany <T>(IEnumerable <int> ids, VersionOptions options, QueryHints hints) where T : class, IContent
{
throw new NotImplementedException();
}
internal void SetHints(QueryHints hints)
{
if (hints.IsEmpty)
{
return;
}
IntPtr qptr = _setHints(Collection.Database.DatabaseHandle, this, hints.ToByteArray());
if (qptr == IntPtr.Zero)
{
//TODO: throw more specific exception
//throw new EJDBQueryException(_jb);
EjdbException.FromDatabase(Collection.Database, "Failed to set hints");
}
}
public IEnumerable <ContentItem> GetManyByVersionId(IEnumerable <int> versionRecordIds, QueryHints hints)
{
throw new NotImplementedException();
}
public ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
return(_decoratedService.Get(id, options, hints));
}
