protected override void Unpublished(PublishContentContext context) {
     var contentTags = context.ContentItem.As<TagsPart>();
     if (contentTags != null) {
         _signals.Trigger(TagCloudService.VandelayTagcloudTagschanged);
     }
     base.Unpublished(context);
 }
        public void Publishing(PublishContentContext context, FieldIndexPart fieldIndexPart) {
            foreach (var part in fieldIndexPart.ContentItem.Parts) {
                foreach(var field in part.PartDefinition.Fields) {
                    
                    // get all drivers for the current field type
                    // the driver will describe what values of the field should be indexed
                    var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == field.FieldDefinition.Name)).ToList();
                    
                    ContentPart localPart = part;
                    ContentPartFieldDefinition localField = field;
                    var membersContext = new DescribeMembersContext( 
                        (storageName, storageType, displayName, description) => {
                            var fieldStorage = _fieldStorageProvider.BindStorage(localPart, localField);

                            // fieldStorage.Get<T>(storageName)
                            var getter = typeof(IFieldStorage).GetMethod("Get").MakeGenericMethod(storageType);
                            var fieldValue = getter.Invoke(fieldStorage, new[] {storageName});

                            _fieldIndexService.Set(fieldIndexPart,
                                localPart.PartDefinition.Name,
                                localField.Name,
                                storageName, fieldValue, storageType);
                        });

                    foreach (var driver in drivers) {
                        driver.Describe(membersContext);
                    }
                }
            }
        }
 protected override void Unpublished(PublishContentContext context)
 {
     var contentTags = context.ContentItem.As<TagsPart>();
     if (contentTags != null) {
         _signals.Trigger(TagsMenuItemEvent.TagsChanged);
     }
     base.Unpublished(context);
 }
 private void OnPublishing(PublishContentContext context, EntityMetadataPart part) {
     if (context.PreviousItemVersionRecord == null) {
         CreateEntity(part);
     }
     else {
         var previousEntity = _contentManager.Get<EntityMetadataPart>(context.Id);
         UpdateEntity(previousEntity, part);
     }
 }
 void CreateIndexingTask(PublishContentContext context, ContentPart part) {
     // "Unpublish" case: Same as "remove"
     if (context.PublishingItemVersionRecord == null) {
         _indexingTaskManager.CreateDeleteIndexTask(context.ContentItem);
         return;
     }
     // "Publish" case: update index
     _indexingTaskManager.CreateUpdateIndexTask(context.ContentItem);
 }
 protected override void Unpublished(PublishContentContext context)
 {
     var contentTags = context.ContentItem.As<TagsPart>();
     if (contentTags != null)
     {
         _signals.Trigger(LocalizedTagsService._localizedTagcloudTagsChanged);
     }
     base.Unpublished(context);
 }
 private void DeferOrPublishAssets(PublishContentContext context, CloudVideoPart part) {
     if (part.MezzanineAsset != null && part.MezzanineAsset.UploadState.Status != AssetUploadStatus.Uploaded) {
         part.PublishOnUpload = true;
         _notifier.Warning(T("The cloud video item was saved, but will not be published until the primary video asset has finished uploading to Windows Azure Media Services."));
         context.Cancel = true;
     }
     else
         _assetManager.PublishAssetsFor(part);
 }
        private void ScheduleUnpublish(PublishContentContext ctx, ProductPart part) {
            _scheduledTaskManager.DeleteTasks(part.ContentItem, t => t.TaskType == Constants.UnpublishTaskName);

            var settings = _workContextAccessor.GetContext().CurrentSite.Get<ProductSettingsPart>();
            if (settings.HideProductDelay > 0) {
                // Schedule the unpublish moment
                var dateToUnpublish = DateTime.UtcNow.AddDays(settings.HideProductDelay);
                _scheduledTaskManager.CreateTask(Constants.UnpublishTaskName, dateToUnpublish, part.ContentItem);
            }
        }
        public override void Published(PublishContentContext context)
        {
            var utcNow = _clock.UtcNow;

            // The first time the content is published, reassign the CreateUtc value
            if(!context.ContentItem.PublishedUtc.HasValue)
            {
                context.ContentItem.CreatedUtc = utcNow;
            }

            context.ContentItem.PublishedUtc = utcNow;
        }
        private void UpdateContentItemRoleSecurityRecords(PublishContentContext context, ContentItem contentItem) {
            var roles = _roleService.GetRoles();

            var allowedRoles = new List<RoleRecord>();

            bool canAnonView = _authorizationService.TryCheckAccess(
                _permission, 
                null /* null signifies anon user */,
                contentItem);

            foreach (var role in roles) {
                var user = UserSimulation.Create(role.Name);

                if (_authorizationService.TryCheckAccess(
                        _permission, 
                        user,
                        contentItem)
                    ) {

                    allowedRoles.Add(role);
                }
            }

            /* Delete and maintain a fresh one on each publish */
            var currentRecord = _roleSecurityRepository
                .Get(o => o.ContentItemRecord == contentItem.Record);

            if (currentRecord != null)
                _roleSecurityRepository.Delete(currentRecord);

            PermissionRecord permissionRecord = _permissionRepository
                .Get(x => x.Name == _permission.Name);

            var entity = new RoleSecurityRecord{
                ContentItemRecord = contentItem.Record,
                AnonymousCanView = canAnonView,
                Permission = permissionRecord};

            _roleSecurityRepository.Create(entity);

            foreach (var allowedRole in allowedRoles) {
                entity.RolesSecurities.Add(
                    new RolesSecuritiesRecord{
                        Role = allowedRole,
                        RoleSecurity = entity });
            }
        }
 protected override void  Published(PublishContentContext context)
 {
     // Check inverse of connector
     var part = context.ContentItem.As<ConnectorPart>();
     if (part!=null) {
         if (part.InverseConnector != null) {
             // Make sure inverse has the correct version
             part.InverseConnector.RightContentVersionId = part.LeftContentVersionId;
             // Publish the inverse
             if (!part.InverseConnector.IsPublished()) {
                 Services.ContentManager.Publish(part.InverseConnector.ContentItem);
             }
         }
     } 
     // Publish all connectors of socket
     var socket = context.ContentItem.As<SocketsPart>();
     if (socket!=null) {
         socket.Sockets.Flush();
         PublishConnectors(socket);
         // TODO: PERF: Could end up with a lot of overhead and triggering all the time when, say, adding comments or any old thing. Actually only need to do this for
         // specific things like menus.
         Trigger(socket);
     }
 }
 private void UpdatePublishedValues(PublishContentContext context, VersionInfoPart part)
 {
     part.Draft = false;
     part.Removed = false;
 }
 protected override void Published(PublishContentContext context) {
     if (context.ContentItem.Has<ImageProfilePart>())
         _signals.Trigger("MediaProcessing_Published_" + context.ContentItem.As<ImageProfilePart>().Name);
     base.Published(context);
 }
 void Generate(PublishContentContext context, ContentPart part) {
     if(_orchardServices.WorkContext.CurrentSite.As<WarmupSettingsPart>().OnPublish) {
         _warmupScheduler.Schedule(true);
     }
 }
Exemple #15
0
 protected virtual void Publishing(PublishContentContext context)
 {
 }
Exemple #16
0
 private void UpdateTemplateClients(PublishContentContext context, LayoutPart part) {
     UpdateTemplateClients(part);
 }
Exemple #17
0
 private static void CreateFilterGroup(PublishContentContext ctx, QueryPart part) {
     if (!part.FilterGroups.Any()) {
         part.FilterGroups.Add(new FilterGroupRecord());
     }
 }
        public async Task Publish(ContentItem contentItem) {
            if (contentItem.VersionRecord.Published) {
                return;
            }
            // create a context for the item and it's previous published record
            var previous = await _session
                .QueryAsync<ContentItemVersionRecord, ContentItemVersionRecordIndex>(x => 
                    x.ContentItemId == contentItem.Id && x.Published)
                .FirstOrDefault();

            var context = new PublishContentContext(contentItem, previous);

            // invoke handlers to acquire state, or at least establish lazy loading callbacks
            Handlers.Invoke(handler => handler.Publishing(context), _logger);

            if (context.Cancel) {
                return;
            }

            if (previous != null) {
                previous.Published = false;
            }
            contentItem.VersionRecord.Published = true;

            Handlers.Invoke(handler => handler.Published(context), _logger);
        }
 void IContentHandler.Publishing(PublishContentContext context)
 {
 }
 public void Unpublished(PublishContentContext context)
 {
     TriggerIfGraph(context);
 }
        public virtual void Create(ContentItem contentItem, VersionOptions options)
        {
            if (contentItem.Number == 0)
            {
                contentItem.Number = 1;
                contentItem.Latest = true;
                contentItem.Published = true;
            }

            // Version may be specified
            if (options.VersionNumber != 0)
            {
                contentItem.Number = options.VersionNumber;
            }

            // Draft flag on create is required for explicitly-published content items
            if (options.IsDraft)
            {
                contentItem.Published = false;
            }

            // Build a context with the initialized instance to create
            var context = new CreateContentContext(contentItem);

            // invoke handlers to add information to persistent stores
            Handlers.Invoke(handler => handler.Creating(context), _logger);

            Handlers.Invoke(handler => handler.Created(context), _logger);

            if (options.IsPublished)
            {
                var publishContext = new PublishContentContext(contentItem, null);

                // invoke handlers to acquire state, or at least establish lazy loading callbacks
                Handlers.Invoke(handler => handler.Publishing(publishContext), _logger);

                // invoke handlers to acquire state, or at least establish lazy loading callbacks
                Handlers.Invoke(handler => handler.Published(publishContext), _logger);
            }

            _session.Save(contentItem);
            _contentManagerSession.Store(contentItem);
        }
 public virtual void Publishing(PublishContentContext context, TPart instance)
 {
 }
        public async Task PublishAsync(ContentItem contentItem)
        {
            if (contentItem.Published)
            {
                return;
            }

            // Create a context for the item and it's previous published record
            // Because of this query the content item will need to be re-enlisted
            // to be saved.
            var previous = await _session
                .QueryAsync<ContentItem, ContentItemIndex>(x =>
                    x.ContentItemId == contentItem.ContentItemId && x.Published)
                .FirstOrDefault();

            var context = new PublishContentContext(contentItem, previous);

            // invoke handlers to acquire state, or at least establish lazy loading callbacks
            Handlers.Invoke(handler => handler.Publishing(context), _logger);

            if (context.Cancel)
            {
                return;
            }

            if (previous != null)
            {
                _session.Save(previous);
                previous.Published = false;
            }

            contentItem.Published = true;

            _session.Save(contentItem);

            Handlers.Invoke(handler => handler.Published(context), _logger);
        }
 protected override void  Unpublishing(PublishContentContext context)
 {
     var part = context.ContentItem.As<SocketsPart>();
     if (part!=null)
         UnpublishSocket(part);
 }
        private void FinalizePath(RoutePart route, PublishContentContext context, Action<RoutePart> processSlug) {
            var path = route.Path;
            route.Path = route.GetPathWithSlug(route.Slug);

            if (context.PublishingItemVersionRecord != null)
                processSlug(route);

            // if the path has changed by having the slug changed on the way in (e.g. user input) or to avoid conflict
            // then update and publish all contained items
            if (path != route.Path) {
                _routablePathConstraint.RemovePath(path);
                _routableService.FixContainedPaths(route);
            }

            if (!string.IsNullOrWhiteSpace(route.Path))
                _routablePathConstraint.AddPath(route.Path);
        }
 public virtual void Unpublished(PublishContentContext context, TPart instance)
 {
 }
 public void Unpublishing(PublishContentContext context)
 {
 }
 private void CancelAndUnpublishAssets(PublishContentContext context, CloudVideoPart part) {
     part.PublishOnUpload = false;
     _assetManager.UnpublishAssetsFor(part);
 }
Exemple #29
0
 protected virtual void Unpublished(PublishContentContext context)
 {
 }
        protected override void  Unpublished(PublishContentContext context)
        {
 	        base.Unpublished(context);
        }
        public virtual void Create(ContentItem contentItem, VersionOptions options) {
            if (contentItem.VersionRecord == null) {
                // produce root record to determine the model id
                contentItem.VersionRecord = new ContentItemVersionRecord {
                    Number = 1,
                    Latest = true,
                    Published = true
                };
            }

            // add to the collection manually for the created case
            contentItem.VersionRecord.ContentType = contentItem.ContentType;

            // version may be specified
            if (options.VersionNumber != 0) {
                contentItem.VersionRecord.Number = options.VersionNumber;
            }

            // draft flag on create is required for explicitly-published content items
            if (options.IsDraft) {
                contentItem.VersionRecord.Published = false;
            }

            // build a context with the initialized instance to create
            var context = new CreateContentContext(contentItem);

            // invoke handlers to add information to persistent stores
            Handlers.Invoke(handler => handler.Creating(context), _logger);

            Handlers.Invoke(handler => handler.Created(context), _logger);

            if (options.IsPublished) {
                var publishContext = new PublishContentContext(contentItem, null);

                // invoke handlers to acquire state, or at least establish lazy loading callbacks
                Handlers.Invoke(handler => handler.Publishing(publishContext), _logger);

                // invoke handlers to acquire state, or at least establish lazy loading callbacks
                Handlers.Invoke(handler => handler.Published(publishContext), _logger);
            }

            _session.Save(contentItem.Record);
            contentItem.VersionRecord.ContentItemId = contentItem.Record.Id;
            _session.Save(contentItem.VersionRecord);

            _contentManagerSession.Store(contentItem);
        }
        public async Task UnpublishAsync(ContentItem contentItem)
        {
            ContentItem publishedItem;
            if (contentItem.Published)
            {
                // The version passed in is the published one
                publishedItem = contentItem;
            }
            else
            {
                // Try to locate the published version of this item
                publishedItem = await GetAsync(contentItem.ContentItemId, VersionOptions.Published);
            }

            if (publishedItem == null)
            {
                // No published version exists. no work to perform.
                return;
            }

            // Create a context for the item. the publishing version is null in this case
            // and the previous version is the one active prior to unpublishing. handlers
            // should take this null check into account
            var context = new PublishContentContext(contentItem, publishedItem)
            {
                PublishingItem = null
            };

            Handlers.Invoke(handler => handler.Unpublishing(context), _logger);

            publishedItem.Published = false;

            _session.Save(contentItem);

            Handlers.Invoke(handler => handler.Unpublished(context), _logger);
        }
 protected override void  Publishing(PublishContentContext context)
 {
     base.Publishing(context);
 }
Exemple #34
0
 protected void AssignPublishingDates(PublishContentContext context, CommonPart part) {
     var utcNow = _clock.UtcNow;
     part.PublishedUtc = utcNow;
     part.VersionPublishedUtc = utcNow;
 }
        public override void Unpublished(PublishContentContext context)
        {
            var utcNow = _clock.UtcNow;

            context.ContentItem.PublishedUtc = null;
        }