namespace UrbanCherry.Net.SDLTridion.Workflow
{
    public class ScheduleForPublish : ExternalActivity
    {
        /// <summary>
        ///
        /// </summary>
        protected override void Execute()
        {
            Utilities util = new Utilities(CoreServiceClient, ActivityInstance);
            string publishDateFieldSource = util.GetActivityParamValue("PublishDateFieldSource");//could be data or metadata
            string publishDateXPath = util.GetActivityParamValue("PublishDateXPath");

            ComponentData workflowItem = (ComponentData)CoreServiceClient.Read(ActivityInstance.WorkItems[0].Subject.IdRef + "-v0", new ReadOptions());

            XDocument sourceXml = new XDocument();
            if (publishDateFieldSource == "data")
            {
                sourceXml = XDocument.Parse(workflowItem.Content);
            }else
            {
                sourceXml = XDocument.Parse(workflowItem.Metadata);
            }


            ActivityFinishData finishData = new ActivityFinishData
            {
                //NextActivityDueDate = publishTime,
                Message = "Placing in Publishing Override Queue for default period, because no date or time was set, or it was in the past",
                NextActivityTitle = "Holding for default publish delay"
            };

            XElement dateElement = sourceXml.XPathSelectElement(publishDateXPath);

            if (dateElement != null)
            {
                DateTime enteredDateTime = DateTime.Parse(dateElement.Value);
                if (enteredDateTime > DateTime.Now)
                {
                    //publishTime = enteredDateTime;
                    finishData.Message = "Placing in Publishing Override Queue until:"  + enteredDateTime;
                    finishData.NextActivityDueDate = enteredDateTime;
                    finishData.NextActivityTitle = "Holding for future publishing";
                }
            }


            CoreServiceClient.FinishActivity(ActivityInstance.Id, finishData, new ReadOptions());

        }
    }
}

using Tridion.ContentManager.CoreService.Client;
using Tridion.ContentManager.CoreService.Workflow;


namespace UrbanCherry.Net.SDLTridion.Workflow
{
    public class PublishingExpirationHandler : ExternalActivity
    {
        /// <summary>
        /// This Expiration script should be to automatically finish a manual activity that expires
        /// the script will read what activity to assign to, and finish the current activity
        /// </summary>
        protected override void Expire()
        {
            //Create a Utility Class
            Utilities util = new Utilities(CoreServiceClient, ActivityInstance);
            string expirationActivity = util.GetActivityParamValue("ExpirationActivityName", Utilities.ScriptType.Expiration);

            string uriNextActivity = util.GetActivityURI(expirationActivity, ProcessInstance.ProcessDefinition.IdRef);
            DecisionActivityFinishData decisionActivityFinishData = new DecisionActivityFinishData
            {
                NextActivity = new LinkToActivityDefinitionData { IdRef = uriNextActivity },
                Message = "Released for publishing by workflow at " + DateTime.Now
            };

            CoreServiceClient.FinishActivity(ActivityInstance.Id, decisionActivityFinishData, null);

        }
    }


}

using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tridion.ContentManager.CoreService.Client;
using Tridion.ContentManager.CoreService.Workflow;


namespace UrbanCherry.Net.SDLTridion.Workflow
{
    public class Publish : ExternalActivity
    {
        /// <summary>
        ///
        /// </summary>
        protected override void Execute()
        {
            Utilities util = new Utilities(CoreServiceClient, ActivityInstance);
            string targetTypeName = util.GetActivityParamValue("TargetTypeName");

            ActivityFinishData finishData = new ActivityFinishData
            {

                Message = "Items placed in the queue for publishing"

            };
            CoreServiceClient.FinishActivity(ActivityInstance.Id, finishData, new ReadOptions());
            util.PublishToTargetType(new string[] { ActivityInstance.WorkItems[0].Subject.IdRef }, targetTypeName);
        }
    }
}


public void PublishToTargetType(string[] publishItems, string TargetTypeName, PublishDirection direction = PublishDirection.Publish)
    {
        string uriTargetType = null;

        TargetTypesFilterData filter = new TargetTypesFilterData();

        IdentifiableObjectData[] targetTypes = _client.GetSystemWideList(filter);
        foreach (IdentifiableObjectData targetType in targetTypes)
        {
            if (targetType.Title == TargetTypeName)
            {
                uriTargetType = targetType.Id;
            }
        }

        if (!string.IsNullOrEmpty(uriTargetType))
        {
            string[] targets = new String[] { uriTargetType };

            RenderInstructionData renderInstruction = new RenderInstructionData();
            ResolveInstructionData resolveInstruction = new ResolveInstructionData();

            if (direction == PublishDirection.UnPublish)
            {
                UnPublishInstructionData unpublishInstruction = new UnPublishInstructionData
                {
                    ResolveInstruction = resolveInstruction,
                    RollbackOnFailure = false,
                    StartAt = DateTime.Now
                };
                _client.UnPublish(publishItems, unpublishInstruction, targets, PublishPriority.High, new ReadOptions());
            }
            else
            {

                PublishInstructionData publishInstruction = new PublishInstructionData
                {
                    DeployAt = DateTime.Now,
                    MaximumNumberOfRenderFailures = 0,
                    RenderInstruction = renderInstruction,
                    ResolveInstruction = resolveInstruction,
                    StartAt = DateTime.Now.AddSeconds(10)

                };
                _client.Publish(publishItems, publishInstruction, targets, PublishPriority.Normal, new ReadOptions());
            }
        }


    }