public ContentLogic(IContentService contentService, IAttachmentService attachmentService, ILegacyContentService legacyContentService, IFileViewerService fileViewerService) { if (contentService == null) { throw new ArgumentNullException("contentService"); } if (attachmentService == null) { throw new ArgumentNullException("attachmentService"); } if (fileViewerService == null) { throw new ArgumentNullException("fileViewerService"); } if (legacyContentService == null) { throw new ArgumentNullException("legacyContentService"); } ContentService = contentService; AttachmentService = attachmentService; LegacyContentService = legacyContentService; FileViewerService = fileViewerService; }
private void Album_saved(IContentService sender, SaveEventArgs<IContent> e) { foreach (IContent node in e.SavedEntities) { if (node.ContentType.ContentTypeCompositionExists("Album") || node.ContentType.Alias == "Album") { IMediaService ms = UmbracoContext.Current.Application.Services.MediaService; IContent parent = node.Parent(); int media_parentId; if (parent.ContentType.ContentTypeCompositionExists("Album") || parent.ContentType.Alias == "Album") { IMedia media_parent = ms.GetRootMedia().Where(x => x.Name == parent.Name).First(x => x.ContentType.Alias == "Folder"); if (media_parent == null) { media_parent = ms.CreateMedia(parent.Name, -1, "Folder"); ms.Save(media_parent); } media_parentId = media_parent.Id; } else media_parentId = -1; IMedia media_album = ms.CreateMedia(node.Name, media_parentId, "Folder"); ms.Save(media_album); } } }
private void ContentServiceOnDeleted(IContentService sender, DeleteEventArgs<IContent> deleteEventArgs) { foreach(var deletedEntity in deleteEventArgs.DeletedEntities) { DeleteEntityIndex(deletedEntity); } }
static void ContentService_Created(IContentService sender, NewEventArgs<IContent> e) { if (UmbracoContext.Current == null) return; if (e.Entity.ContentType.Alias.InvariantEquals("ArticulateRichText") || e.Entity.ContentType.Alias.InvariantEquals("ArticulateMarkdown")) { if (UmbracoContext.Current.Security.CurrentUser != null) { e.Entity.SetValue("author", UmbracoContext.Current.Security.CurrentUser.Name); } e.Entity.SetValue("publishedDate", DateTime.Now); e.Entity.SetValue("enableComments", 1); } else if (e.Entity.ContentType.Alias.InvariantEquals("Articulate")) { e.Entity.SetValue("theme", "VAPOR"); e.Entity.SetValue("pageSize", 10); e.Entity.SetValue("categoriesUrlName", "categories"); e.Entity.SetValue("tagsUrlName", "tags"); e.Entity.SetValue("searchUrlName", "search"); e.Entity.SetValue("categoriesPageName", "Categories"); e.Entity.SetValue("tagsPageName", "Tags"); e.Entity.SetValue("searchPageName", "Search results"); } }
/// <summary> /// Initializes a new instance of the ContentController class. /// </summary> /// <param name="contentService">Instance of Content Service</param> /// <param name="profileService">Instance of profile Service</param> public ContentController(IContentService contentService, IProfileService profileService, INotificationService queueService, ICommunityService communityService) : base(profileService) { _contentService = contentService; _notificationService = queueService; _communityService = communityService; }
/// <summary> /// public ctor - will generally just be used for unit testing /// </summary> /// <param name="contentService"></param> /// <param name="mediaService"></param> /// <param name="contentTypeService"></param> /// <param name="dataTypeService"></param> /// <param name="fileService"></param> /// <param name="localizationService"></param> /// <param name="packagingService"></param> /// <param name="entityService"></param> /// <param name="relationService"></param> /// <param name="sectionService"></param> /// <param name="treeService"></param> /// <param name="tagService"></param> public ServiceContext( IContentService contentService, IMediaService mediaService, IContentTypeService contentTypeService, IDataTypeService dataTypeService, IFileService fileService, ILocalizationService localizationService, PackagingService packagingService, IEntityService entityService, IRelationService relationService, ISectionService sectionService, IApplicationTreeService treeService, ITagService tagService) { _tagService = new Lazy<ITagService>(() => tagService); _contentService = new Lazy<IContentService>(() => contentService); _mediaService = new Lazy<IMediaService>(() => mediaService); _contentTypeService = new Lazy<IContentTypeService>(() => contentTypeService); _dataTypeService = new Lazy<IDataTypeService>(() => dataTypeService); _fileService = new Lazy<IFileService>(() => fileService); _localizationService = new Lazy<ILocalizationService>(() => localizationService); _packagingService = new Lazy<PackagingService>(() => packagingService); _entityService = new Lazy<IEntityService>(() => entityService); _relationService = new Lazy<IRelationService>(() => relationService); _sectionService = new Lazy<ISectionService>(() => sectionService); _treeService = new Lazy<IApplicationTreeService>(() => treeService); }
public ApiController( IEntitiesContext entitiesContext, IPackageService packageService, IPackageFileService packageFileService, IUserService userService, INuGetExeDownloaderService nugetExeDownloaderService, IContentService contentService, IIndexingService indexingService, ISearchService searchService, IAutomaticallyCuratePackageCommand autoCuratePackage, IStatusService statusService, IAppConfiguration config) { EntitiesContext = entitiesContext; PackageService = packageService; PackageFileService = packageFileService; UserService = userService; NugetExeDownloaderService = nugetExeDownloaderService; ContentService = contentService; StatisticsService = null; IndexingService = indexingService; SearchService = searchService; AutoCuratePackage = autoCuratePackage; StatusService = statusService; _config = config; }
// private readonly IMemberService _memberService; public VideoService(IContentService content) { _content = content; _context = new UmbracoContextProvider(); //var umbracoConextProvider = DependencyResolver.Current.GetService<IUmbracoConextProvider>(); _umbracoHelper = new UmbracoHelper(UmbracoContext.Current); }
public ContentTypeService(IDatabaseUnitOfWorkProvider provider, RepositoryFactory repositoryFactory, IContentService contentService, IMediaService mediaService) { _uowProvider = provider; _repositoryFactory = repositoryFactory; _contentService = contentService; _mediaService = mediaService; }
/// <summary> /// our save routine, checks to see if the item has been renamed, or if it's been moved /// then saves. /// </summary> void SaveContentItemsToDisk(IContentService sender, IEnumerable<IContent> items) { SourceInfo.Load(); ContentExporter w = new ContentExporter(); foreach (var item in items) { LogHelper.Info<ContentExporter>("Saving {0} [{1}]", () => item.Name, () => item.Name.ToSafeAlias()); string sourceName = SourceInfo.GetName(item.Key); if ( (sourceName!= null) && (item.Name != sourceName ) ) { LogHelper.Info<ContentExporter>("Rename {0}", () => item.Name); w.RenameContent(item, SourceInfo.GetName(item.Key)); } int? parent = SourceInfo.GetParent(item.Key) ; if ( (parent != null) && (item.ParentId != parent.Value)) { LogHelper.Info<ContentExporter>("Move {0}", () => item.Name); w.MoveContent(item, parent.Value); } w.SaveContent(item); } SourceInfo.Save(); }
/// <summary> /// Set auto-properties on content saving /// We can't do these properties on create as the source values will not exist /// </summary> /// <param name="sender">The content service</param> /// <param name="e">The save event arguments</param> protected void ContentServiceOnSaving(IContentService sender, SaveEventArgs<IContent> e) { foreach (IContent entity in e.SavedEntities) { entity.SetDefaultValue("headTitle", entity.Name); } }
private void ContentService_Creating(IContentService sender, Umbraco.Core.Events.NewEventArgs<IContent> e) { //if (e.Alias == "SOSU-Nyhed") //{ // e.Entity.SetValue("contentDate", DateTime.Now); // // e.Entity.SetValue("umbracoNaviHide", true); //} }
public RelationsController() { relationService = ApplicationContext.Services.RelationService; contentService = ApplicationContext.Services.ContentService; mediaService = ApplicationContext.Services.MediaService; contentTypeService = ApplicationContext.Services.ContentTypeService; entityService = ApplicationContext.Services.EntityService; }
public PagesController(IContentService contentService, IMessageService messageService, ISupportRequestService supportRequestService) { _contentService = contentService; _messageService = messageService; _supportRequestService = supportRequestService; }
/// <summary> /// when something is deleted it's plopped in the recycle bin /// </summary> void ContentService_Trashing(IContentService sender, Umbraco.Core.Events.MoveEventArgs<IContent> e) { LogHelper.Info<ContentEvents>("Trashing {0}", () => e.Entity.Name); ArchiveContentItem(e.Entity); }
int importCount = 0; // used just to say how many things we imported public ContentImporter() { _contentService = ApplicationContext.Current.Services.ContentService; _mediaService = ApplicationContext.Current.Services.MediaService ; // load the import table (from disk) ImportPairs.LoadFromDisk(); }
public CommonController(IUnitOfWork unitOfWork, ICategoryService categoryService, IStoreService storeService, IContentService contentService) { this._unitOfWork = unitOfWork; this._categoryService = categoryService; this._storeService = storeService; this._contentService = contentService; }
public MemberInformationService() { _contentService = ApplicationContext.Current.Services.ContentService; // Get ahold of the root/home node var root = _contentService.GetRootContent().First(); // Get the API uri apiUri = root.GetValue<string>("apiUri"); }
public ContentPostValidateAttribute(IContentService contentService, IUserService userService, WebSecurity security) { if (contentService == null) throw new ArgumentNullException("contentService"); if (userService == null) throw new ArgumentNullException("userService"); if (security == null) throw new ArgumentNullException("security"); _contentService = contentService; _userService = userService; _security = security; }
public ConfigurationBuilder(IContentService contentService) { if (contentService == null) { throw new ArgumentNullException("contentService", "Configuration builder requires a content service to configure."); } ContentService = contentService; }
void ContentService_Saving(IContentService sender, SaveEventArgs<IContent> e) { var ContentService = sender; IContent content = ContentService.GetById(e.SavedEntities.First().Id); var pubDate = (e.SavedEntities.First().ReleaseDate != null) ? e.SavedEntities.First().ReleaseDate : e.SavedEntities.First().UpdateDate; content.SetValue("publishedDate", pubDate); ContentService.Save(content, raiseEvents: false); }
void ContentServiceMoving(IContentService sender, MoveEventArgs<IContent> e) { Logger.Info("Received moved event"); var runtimeContentModel = RuntimeUmbracoContext.Instance.UmbracoContentSerialiser.Remove(e.Entity); foreach (var adapter in RuntimeUmbracoContext.Instance.DeploymentAdapters) { adapter.DeployContent(runtimeContentModel, DeploymentAction.Delete); } }
private void ContentService_Saving(IContentService sender, SaveEventArgs<IContent> e) { foreach (var doc in e.SavedEntities) { var mapping = MapProvider.Mappings.SingleOrDefault(n => n.DocumentType.Equals(doc.ContentType.Alias, StringComparison.CurrentCultureIgnoreCase)); if (mapping != null) SaveDocument(mapping, sender, doc); } }
private void ContentService_Creating(IContentService sender, Umbraco.Core.Events.NewEventArgs<IContent> e) { //Bruges til at udføre custom-handlinger når et dokument oprettes //Eksempel: sæt en default dato på egenskaben "contentDate" //if (e.Alias == "Kunde-Nyhed") //{ // e.Entity.SetValue("contentDate", DateTime.Now); //} }
///Constructors needed for testability and DI public CommentSurfaceController(UmbracoContext umbracoContext, IContentService _contentService, IMemberService _memberService, IRelationService _relationServices) : base(umbracoContext) { this._contentService = _contentService; this._memberService = _memberService; this._relationService = _relationServices; }
private void ContentService_Deleting(IContentService sender, DeleteEventArgs<IContent> e) { foreach (var entity in e.DeletedEntities) { string documentType = entity.ContentType.Alias; var mapping = MapProvider.Mappings.SingleOrDefault(n => n.DocumentType == documentType); if (mapping != null) DeleteDocument(mapping, sender, entity); } }
public void LoadContent(IContentService content) { if (!_contentLoaded) { foreach (var entity in _entities) { entity.LoadContent(content); } _contentLoaded = true; } }
public DefinedContent(string configDirectory = "") { _contentService = UmbracoContext.Current.Application.Services.ContentService; if (string.IsNullOrEmpty(configDirectory)) _configDirectory = HttpContext.Current.Server.MapPath("~/") + Constants.CONFIG_DIRECTORY; else _configDirectory = configDirectory; FullRefresh(); }
void ContentService_Deleted(IContentService sender, Umbraco.Core.Events.DeleteEventArgs<Umbraco.Core.Models.IContent> e) { var fs = new ForumService(ApplicationContext.Current.DatabaseContext); foreach (var ent in e.DeletedEntities.Where(x => x.ContentType.Alias == "Forum")) { var f = fs.GetById(ent.Id); if (f != null) fs.Delete(f); } }
/// <summary> /// Ensures that node name is the same as post title. /// </summary> void ContentService_Saved(IContentService sender, SaveEventArgs<IContent> e) { foreach (var entity in e.SavedEntities) { if (entity.ContentType.Alias == "uBlogsyPost" && entity.ParentId != -20) { PostService.Instance.EnsureCorrectPostTitle(entity); PostService.Instance.EnsureCorrectPostNodeName(entity); PostService.Instance.EnsureNavigationTitle(entity); } } }
public TeamApiController(IContentService contentService, IContentTypeService contentTypeService, IMapper mapper) { _contentService = contentService; _contentTypeService = contentTypeService; _mapper = mapper; }
/// <summary> /// Default constructor. /// </summary> /// <param name="api">The current api</param> /// <param name="db">The current db context</param> /// <param name="factory">The content service factory</param> /// <param name="cache">The optional model cache</param> public SiteRepository(Api api, IDb db, IContentServiceFactory factory, ICache cache = null) : base(db, cache) { this.api = api; this.contentService = factory.CreateSiteService(); }
/// <summary> /// Initializes a new instance of the <see cref="GetServerControlWidgetForEditCommand" /> class. /// </summary> /// <param name="categoryService">The category service.</param> /// <param name="contentService">The content service.</param> /// <param name="optionService">The option service.</param> public GetServerControlWidgetForEditCommand(ICategoryService categoryService, IContentService contentService, IOptionService optionService) { this.contentService = contentService; this.categoryService = categoryService; this.optionService = optionService; }
public SitecoreContentNodeConverter(IContentService contentService, ISitecoreContext sitecoreContext) { _contentService = contentService; _sitecoreContext = sitecoreContext; }
public ConfirmEmailContentNode(IContentService contentService, IContentTypeService contentTypeService, ILogger logger) { this.contentService = contentService; this.contentTypeService = contentTypeService; this.logger = logger; }
/// <summary> /// Gets the URLs of the content item. /// </summary> /// <remarks> /// <para>Use when displaying URLs. If errors occur when generating the URLs, they will show in the list.</para> /// <para>Contains all the URLs that we can figure out (based upon domains, etc).</para> /// </remarks> public static async Task <IEnumerable <UrlInfo> > GetContentUrlsAsync( this IContent content, IPublishedRouter publishedRouter, IUmbracoContext umbracoContext, ILocalizationService localizationService, ILocalizedTextService textService, IContentService contentService, IVariationContextAccessor variationContextAccessor, ILogger <IContent> logger, UriUtility uriUtility, IPublishedUrlProvider publishedUrlProvider) { if (content == null) { throw new ArgumentNullException(nameof(content)); } if (publishedRouter == null) { throw new ArgumentNullException(nameof(publishedRouter)); } if (umbracoContext == null) { throw new ArgumentNullException(nameof(umbracoContext)); } if (localizationService == null) { throw new ArgumentNullException(nameof(localizationService)); } if (textService == null) { throw new ArgumentNullException(nameof(textService)); } if (contentService == null) { throw new ArgumentNullException(nameof(contentService)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (publishedUrlProvider == null) { throw new ArgumentNullException(nameof(publishedUrlProvider)); } if (uriUtility == null) { throw new ArgumentNullException(nameof(uriUtility)); } if (variationContextAccessor == null) { throw new ArgumentNullException(nameof(variationContextAccessor)); } var result = new List <UrlInfo>(); if (content.Published == false) { result.Add(UrlInfo.Message(textService.Localize("content", "itemNotPublished"))); return(result); } // build a list of URLs, for the back-office // which will contain // - the 'main' URLs, which is what .Url would return, for each culture // - the 'other' URLs we know (based upon domains, etc) // // need to work through each installed culture: // on invariant nodes, each culture returns the same URL segment but, // we don't know if the branch to this content is invariant, so we need to ask // for URLs for all cultures. // and, not only for those assigned to domains in the branch, because we want // to show what GetUrl() would return, for every culture. var urls = new HashSet <UrlInfo>(); var cultures = localizationService.GetAllLanguages().Select(x => x.IsoCode).ToList(); // get all URLs for all cultures // in a HashSet, so de-duplicates too foreach (UrlInfo cultureUrl in await GetContentUrlsByCultureAsync(content, cultures, publishedRouter, umbracoContext, contentService, textService, variationContextAccessor, logger, uriUtility, publishedUrlProvider)) { urls.Add(cultureUrl); } // return the real URLs first, then the messages foreach (IGrouping <bool, UrlInfo> urlGroup in urls.GroupBy(x => x.IsUrl).OrderByDescending(x => x.Key)) { // in some cases there will be the same URL for multiple cultures: // * The entire branch is invariant // * If there are less domain/cultures assigned to the branch than the number of cultures/languages installed if (urlGroup.Key) { result.AddRange(urlGroup.DistinctBy(x => x.Text.ToUpperInvariant()) .OrderBy(x => x.Text).ThenBy(x => x.Culture)); } else { result.AddRange(urlGroup); } } // get the 'other' URLs - ie not what you'd get with GetUrl() but URLs that would route to the document, nevertheless. // for these 'other' URLs, we don't check whether they are routable, collide, anything - we just report them. foreach (UrlInfo otherUrl in publishedUrlProvider.GetOtherUrls(content.Id).OrderBy(x => x.Text) .ThenBy(x => x.Culture)) { // avoid duplicates if (urls.Add(otherUrl)) { result.Add(otherUrl); } } return(result); }
/// <summary> /// Tries to return a <see cref="UrlInfo" /> for each culture for the content while detecting collisions/errors /// </summary> private static async Task <IEnumerable <UrlInfo> > GetContentUrlsByCultureAsync( IContent content, IEnumerable <string> cultures, IPublishedRouter publishedRouter, IUmbracoContext umbracoContext, IContentService contentService, ILocalizedTextService textService, IVariationContextAccessor variationContextAccessor, ILogger logger, UriUtility uriUtility, IPublishedUrlProvider publishedUrlProvider) { var result = new List <UrlInfo>(); foreach (var culture in cultures) { // if content is variant, and culture is not published, skip if (content.ContentType.VariesByCulture() && !content.IsCulturePublished(culture)) { continue; } // if it's variant and culture is published, or if it's invariant, proceed string url; try { url = publishedUrlProvider.GetUrl(content.Id, culture: culture); } catch (Exception ex) { logger.LogError(ex, "GetUrl exception."); url = "#ex"; } switch (url) { // deal with 'could not get the URL' case "#": result.Add(HandleCouldNotGetUrl(content, culture, contentService, textService)); break; // deal with exceptions case "#ex": result.Add(UrlInfo.Message(textService.Localize("content", "getUrlException"), culture)); break; // got a URL, deal with collisions, add URL default: // detect collisions, etc Attempt <UrlInfo> hasCollision = await DetectCollisionAsync(logger, content, url, culture, umbracoContext, publishedRouter, textService, variationContextAccessor, uriUtility); if (hasCollision) { result.Add(hasCollision.Result); } else { result.Add(UrlInfo.Url(url, culture)); } break; } } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="DeletePageContentCommand" /> class. /// </summary> /// <param name="contentService">The content service.</param> public DeletePageContentCommand(IContentService contentService) { this.contentService = contentService; }
/// <summary> /// Gets the culture that would be selected to render a specified content, /// within the context of a specified current request. /// </summary> /// <param name="umbracoContext">An <see cref="UmbracoContext"/> instance.</param> /// <param name="domainService">An <see cref="IDomainService"/> implementation.</param> /// <param name="localizationService">An <see cref="ILocalizationService"/> implementation.</param> /// <param name="contentService">An <see cref="IContentService"/> implementation.</param> /// <param name="contentId">The content identifier.</param> /// <param name="contentPath">The content path.</param> /// <param name="current">The request Uri.</param> /// <returns>The culture that would be selected to render the content.</returns> internal static CultureInfo GetCulture(UmbracoContext umbracoContext, IDomainService domainService, ILocalizationService localizationService, IContentService contentService, int contentId, string contentPath, Uri current) { var route = umbracoContext == null ? null // for tests only : umbracoContext.ContentCache.GetRouteById(contentId); // may be cached var domainHelper = new DomainHelper(domainService); IDomain domain; if (route == null) { // if content is not published then route is null and we have to work // on non-published content (note: could optimize by checking routes?) var content = contentService.GetById(contentId); if (content == null) { return(GetDefaultCulture(localizationService)); } var hasDomain = domainHelper.NodeHasDomains(content.Id); while (hasDomain == false && content != null) { content = content.Parent(); hasDomain = content != null && domainHelper.NodeHasDomains(content.Id); } domain = hasDomain ? domainHelper.DomainForNode(content.Id, current).UmbracoDomain : null; } else { // if content is published then we have a route // from which we can figure out the domain var pos = route.IndexOf('/'); domain = pos == 0 ? null : domainHelper.DomainForNode(int.Parse(route.Substring(0, pos)), current).UmbracoDomain; } var rootContentId = domain == null ? -1 : domain.RootContentId; var wcDomain = DomainHelper.FindWildcardDomainInPath(domainService.GetAll(true), contentPath, rootContentId); if (wcDomain != null) { return(new CultureInfo(wcDomain.LanguageIsoCode)); } if (domain != null) { return(new CultureInfo(domain.LanguageIsoCode)); } return(GetDefaultCulture(localizationService)); }
private void Content_Deleted(IContentService sender, DeleteEventArgs <IContent> e) { ClearCache(); }
private void Content_Moved(IContentService sender, MoveEventArgs <IContent> e) { ClearCache(); }
public ContentController(IContentService contentService) { _contentService = contentService; }
public ContentController(IContentService service) { this.service = service; }
private static void ContentService_Saved(IContentService contentService, ContentSavedEventArgs e) { foreach (IContent content in e.SavedEntities) { List <string> editors = new List <string> { Umbraco.Core.Constants.PropertyEditors.Aliases.Grid, BentoItemDataEditor.EditorAlias, BentoStackDataEditor.EditorAlias }; foreach (Property contentProperty in content.Properties.Where(x => editors.Contains(x.PropertyType.PropertyEditorAlias))) { IDataType editor = DataTypeService.GetDataType(contentProperty.PropertyType.DataTypeId); IRelationType bentoBlocksRelationType = RelationService.GetRelationTypeByAlias(RelationTypes.BentoItemsAlias); if (bentoBlocksRelationType == null) { RelationType relationType = new RelationType( RelationTypes.BentoItemsAlias, RelationTypes.BentoItemsName, true, UmbracoObjectTypes.Document.GetGuid(), UmbracoObjectTypes.Document.GetGuid()); RelationService.Save(relationType); bentoBlocksRelationType = RelationService.GetRelationTypeByAlias(RelationTypes.BentoItemsAlias); } //todo: this does work but it's a bit brute force... //i guess we could store the current relationships and then store the ones we're creating and compare them and then //delete the ones from the old list that arent in the new list? but that's a lot of db hits... IEnumerable <IRelation> rels = RelationService.GetByParentId(content.Id); foreach (IRelation currentRelation in rels.Where(x => x.RelationType.Id == bentoBlocksRelationType.Id)) { RelationService.Delete(currentRelation); } if (contentProperty.PropertyType.PropertyEditorAlias == BentoItemDataEditor.EditorAlias) { foreach (Property.PropertyValue value in contentProperty.Values) { if (value.PublishedValue == null) { break; } var area = JsonConvert.DeserializeObject <Area>(value.PublishedValue.ToString()); if (area.Id <= 0) { continue; } var bentoContent = contentService.GetById(area.Id); if (bentoContent == null) { continue; } BentoItemConfiguration config = (BentoItemConfiguration)editor.Configuration; ProcessRelationship(contentService, bentoContent, content, bentoBlocksRelationType, config.ItemDoctypeCompositionAlias); } } else { foreach (Property.PropertyValue value in contentProperty.Values) { if (value.PublishedValue == null) { break; } string valueString = value.PublishedValue?.ToString(); if (string.IsNullOrWhiteSpace(valueString)) { continue; } IEnumerable <StackItem> items = JsonConvert.DeserializeObject <IEnumerable <StackItem> >(valueString, new StackItemConverter()); var itemList = items.Where(x => x.Areas != null && x.Areas.Any()) .SelectMany(stackItem => stackItem.Areas.Where(x => x.Id > 0), (stackItem, x) => contentService.GetById(x.Id)) .Where(bentoContent => bentoContent != null) .Distinct(); BentoStackConfiguration config = (BentoStackConfiguration)editor.Configuration; foreach (IContent item in itemList) { ProcessRelationship(contentService, item, content, bentoBlocksRelationType, config.ItemDoctypeCompositionAlias); } } } } } }
public PublishMethodologyFunction(IContentService contentService) { _contentService = contentService; }
public HomeController(ApplicationDbContext context, IContentService service, ICarService carService) { _conService = service; _ctx = context; _carService = carService; }
public void Get_Paged_Mixed_Entities_By_Ids() { // Create content IContentService contentService = GetRequiredService <IContentService>(); IContentTypeService contentTypeService = GetRequiredService <IContentTypeService>(); var createdContent = new List <IContent>(); ContentType contentType = ContentTypeBuilder.CreateBasicContentType("blah"); contentTypeService.Save(contentType); for (int i = 0; i < 10; i++) { Content c1 = ContentBuilder.CreateBasicContent(contentType); contentService.Save(c1); createdContent.Add(c1); } // Create media IMediaService mediaService = GetRequiredService <IMediaService>(); IMediaTypeService mediaTypeService = GetRequiredService <IMediaTypeService>(); var createdMedia = new List <IMedia>(); MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage"); mediaTypeService.Save(imageType); for (int i = 0; i < 10; i++) { Media c1 = MediaBuilder.CreateMediaImage(imageType, -1); mediaService.Save(c1); createdMedia.Add(c1); } // Create members IMemberService memberService = GetRequiredService <IMemberService>(); IMemberTypeService memberTypeService = GetRequiredService <IMemberTypeService>(); MemberType memberType = MemberTypeBuilder.CreateSimpleMemberType("simple"); memberTypeService.Save(memberType); var createdMembers = MemberBuilder.CreateMultipleSimpleMembers(memberType, 10).ToList(); memberService.Save(createdMembers); IScopeProvider provider = ScopeProvider; using (provider.CreateScope()) { EntityRepository repo = CreateRepository((IScopeAccessor)provider); IEnumerable <int> ids = createdContent.Select(x => x.Id).Concat(createdMedia.Select(x => x.Id)).Concat(createdMembers.Select(x => x.Id)); System.Guid[] objectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }; IQuery <IUmbracoEntity> query = provider.CreateQuery <IUmbracoEntity>() .WhereIn(e => e.Id, ids); var entities = repo.GetPagedResultsByQuery(query, objectTypes, 0, 20, out long totalRecords, null, null).ToList(); Assert.AreEqual(20, entities.Count); Assert.AreEqual(30, totalRecords); // add the next page entities.AddRange(repo.GetPagedResultsByQuery(query, objectTypes, 1, 20, out totalRecords, null, null)); Assert.AreEqual(30, entities.Count); Assert.AreEqual(30, totalRecords); var contentEntities = entities.OfType <IDocumentEntitySlim>().ToList(); var mediaEntities = entities.OfType <IMediaEntitySlim>().ToList(); var memberEntities = entities.OfType <IMemberEntitySlim>().ToList(); Assert.AreEqual(10, contentEntities.Count); Assert.AreEqual(10, mediaEntities.Count); Assert.AreEqual(10, memberEntities.Count); } }
public NearConetntViewComponent(IContentService contentService) { this._contentService = contentService; }
private static UrlInfo HandleCouldNotGetUrl(IContent content, string culture, IContentService contentService, ILocalizedTextService textService) { // document has a published version yet its URL is "#" => a parent must be // unpublished, walk up the tree until we find it, and report. IContent parent = content; do { parent = parent.ParentId > 0 ? contentService.GetParent(parent) : null; } while (parent != null && parent.Published && (!parent.ContentType.VariesByCulture() || parent.IsCulturePublished(culture))); if (parent == null) { // oops, internal error return(UrlInfo.Message(textService.Localize("content", "parentNotPublishedAnomaly"), culture)); } if (!parent.Published) { // totally not published return(UrlInfo.Message(textService.Localize("content", "parentNotPublished", new[] { parent.Name }), culture)); } // culture not published return(UrlInfo.Message(textService.Localize("content", "parentCultureNotPublished", new[] { parent.Name }), culture)); }
/// <summary> /// Default constructor. /// </summary> /// <param name="db">The current db connection</param> /// <param name="factory">The current content service factory</param> public PostRepository(IDb db, IContentServiceFactory factory) { _db = db; _contentService = factory.CreatePostService(); }
public StreamController(IContentService contentService, IAutorizationService autorizationService) { _contentService = contentService; _autorizationService = autorizationService; }
public CertificateFacade(Web3 web3, IContentService contentService, IAccountService accountService) : base(web3, accountService) { _contentService = contentService; }
public ContentReaderContext(Stream stream, GraphicsDevice device, IContentService content) { _stream = stream; _device = device; _content = content; }
public PublishTaxonomyFunction(IContentService contentService) { _contentService = contentService; }
public ContentController(IContentService contentService, IContentTypeService contentTypeService, IFileService fileService) { this._fileService = fileService; this._contentTypeService = contentTypeService; _contentService = contentService; }
public TemplateService(IContentService contentService, ISearcher templateSearcher) { _contentService = contentService; _templateSearcher = templateSearcher; }
private void OnPublishedAssert(IContentService sender, PublishEventArgs <IContent> args) { _onPublishedAssertAction?.Invoke(); }
public TagController(IContentService contentService, ITagQuery tagService) { _contentService = contentService; _tagService = tagService; }
/// <summary> /// Default constructor. /// </summary> /// <param name="api">The current api</param> /// <param name="factory">The content service factory</param> public BlockController(IApi api, IContentServiceFactory factory) : base(api) { // Block transformation is not dependent on which content // type is actually selected, so let's create a page service. _contentService = factory.CreatePageService(); }
public PagesController(IContentService contentService) { ContentService = contentService; }