example of fluent api for publishing and unpublishing page

ProductionEventManager.cs

using System.Collections.Generic;
using System.Linq;
using Ks.Sf.Modules.Dynamic;
using Telerik.Sitefinity;
using Telerik.Sitefinity.Data.Events;
using Telerik.Sitefinity.DynamicModules;
using Telerik.Sitefinity.DynamicModules.Events;
using Telerik.Sitefinity.DynamicModules.Model;
using Telerik.Sitefinity.GenericContent.Model;
using Telerik.Sitefinity.Model;
using Telerik.Sitefinity.Modules.Pages;
using Telerik.Sitefinity.Pages.Model;
using Telerik.Sitefinity.RelatedData;

namespace Ks.Sf.Web.Application
{
    public static class ProductionEventManager
    {
        private const string ApprovalWorkflowStatePublished = "Published";
        private const string ApprovalWorkflowStateUnpublished = "Unpublished";
        private const string ChangedProperties = "ChangedProperties";
        private const string PageEventFullName = "Telerik.Sitefinity.Data.Events.PageEvent";
        private const string ApprovalWorkflowState = "ApprovalWorkflowState";
        private const string Updated = "Updated";
        private const string Title = "Title";
        private const string UrlName = "UrlName";
        private static readonly string[] Keys = {Title, UrlName, ApprovalWorkflowState};

        public static void DynamicContentUpdatedEventHandler(IDynamicContentUpdatedEvent eventInfo)
        {
            if (eventInfo.Item.GetType() != TypeResolver.Production ||
                eventInfo.Item.Status != ContentLifecycleStatus.Master) return;

            var eventBase = eventInfo as DynamicContentEventBase;
            if (eventBase == null) return;

            var relatedPage = eventInfo.Item.GetRelatedItems<PageNode>(ProductionFieldNames.Page).FirstOrDefault();
            if (relatedPage == null) return;

            var changedValues = GetChangedValues(eventBase.ChangedProperties);

            if (!AreAnyValuesDifferent(relatedPage, changedValues)) return;

            using (var fluent = Telerik.Sitefinity.App.WorkWith())
            {
                var pageFacade = fluent.Page(relatedPage.Id);
                pageFacade.AsStandardPage()
                .Do(p =>
                {
                    foreach (var entry in changedValues)
                    {
                        switch (entry.Key)
                        {
                            case Title:
                                p.Title = entry.Value;
                                break;
                            case UrlName:
                                p.UrlName = entry.Value;
                                break;
                            case ApprovalWorkflowState:
                                p.ApprovalWorkflowState.Value = entry.Value;
                                break;
                        }
                    }
                }).CheckOut().Publish().SaveChanges();
            }
        }
        
        // It gets called twice where item id is the same and is updated action
        public static void PageEventHandler(IDataEvent dataEvent)
        {
            if (dataEvent.Action != Updated) return;
            if (dataEvent.GetType().FullName != PageEventFullName) return;

            var changedValues = GetChangedValues(dataEvent);
            if (!changedValues.Any()) return;

            var production = GetProductionItem(dataEvent);

            if (production == null) return;

            if (!AreAnyValuesDifferent(production, changedValues)) return;

            var dynamicModuleManager = DynamicModuleManager.GetManager();
            var checkedOutProduction = (DynamicContent) dynamicModuleManager.Lifecycle.CheckOut(production);

            foreach (var entry in changedValues)
            {
                switch (entry.Key)
                {
                    case Title:
                        checkedOutProduction.UrlName = entry.Value;
                        break;
                    case ApprovalWorkflowState:
                        checkedOutProduction.SetWorkflowStatus(dynamicModuleManager.Provider.ApplicationName,
                            entry.Value);
                        break;
                    default:
                        checkedOutProduction.SetValue(entry.Key, entry.Value);
                        break;
                }
            }

            var checkedInProduction = (DynamicContent) dynamicModuleManager.Lifecycle.CheckIn(checkedOutProduction);

            switch (checkedInProduction.ApprovalWorkflowState)
            {
                case ApprovalWorkflowStatePublished:
                    dynamicModuleManager.Lifecycle.Publish(checkedInProduction);
                    break;
                case ApprovalWorkflowStateUnpublished:
                    var liveProduction = dynamicModuleManager.Lifecycle.GetLive(checkedInProduction);
                    if (liveProduction != null) dynamicModuleManager.Lifecycle.Unpublish(liveProduction);
                    break;
            }

            dynamicModuleManager.SaveChanges();
        }

        private static Dictionary<string, string> GetChangedValues(IDataEvent dataEvent)
        {
            var changedProperties =
                (IDictionary<string, PropertyChange>)
                    dataEvent.GetType().GetProperty(ChangedProperties).GetValue(dataEvent, null);

            return GetChangedValues(changedProperties);
        }

        private static Dictionary<string, string> GetChangedValues(IDictionary<string, PropertyChange> changedProperties)
        {
            return
                changedProperties.Where(changedProperty => Keys.Contains(changedProperty.Key))
                    .ToDictionary(changedProperty => changedProperty.Key,
                        changedProperty => (string) changedProperty.Value.NewValue);
        }

        private static DynamicContent GetProductionItem(IDataEvent dataEvent)
        {
            var itemId = dataEvent.ItemId;
            var pageManager = PageManager.GetManager();
            var pageNode = pageManager.GetPageNode(itemId);

            return
                pageNode.GetRelatedParentItems(TypeResolver.ProductionsFullName, string.Empty, ProductionFieldNames.Page)
                    .OfType<DynamicContent>().SingleOrDefault();
        }

        private static bool AreAnyValuesDifferent(PageNode relatedPage, Dictionary<string, string> changedValues)
        {
            var anyValueDifferent = false;
            foreach (var entry in changedValues)
            {
                switch (entry.Key)
                {
                    case Title:
                        anyValueDifferent |= relatedPage.Title != entry.Value;
                        break;
                    case UrlName:
                        anyValueDifferent |= relatedPage.UrlName != entry.Value;
                        break;
                    case ApprovalWorkflowState:
                        anyValueDifferent |= relatedPage.ApprovalWorkflowState != entry.Value;
                        break;
                }
            }
            return anyValueDifferent;
        }

        private static bool AreAnyValuesDifferent(DynamicContent production, Dictionary<string, string> changedValues)
        {
            var anyValueDifferent = false;
            foreach (var entry in changedValues)
            {
                switch (entry.Key)
                {
                    case Title:
                        anyValueDifferent |= production.GetValue(Title).ToString() != entry.Value;
                        break;
                    case UrlName:
                        anyValueDifferent |= production.UrlName != entry.Value;
                        break;
                    case ApprovalWorkflowState:
                        anyValueDifferent |= production.ApprovalWorkflowState != entry.Value;
                        break;
                }
            }
            return anyValueDifferent;
        }
    }
}