public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.AddToSet(
         "failed",
         context.JobId,
         JobHelper.ToTimestamp(DateTime.UtcNow));
 }

        public FailedStateHandlerFacts()
        {
            _context = new ApplyStateContextMock();
            _context.StateContextValue.JobIdValue = JobId;
            _context.NewStateValue = new FailedState(new InvalidOperationException());

            _transaction = Substitute.For<IWriteOnlyTransaction>();
        }

 public override void Apply(
     ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.AddToSet(
         "processing",
         context.JobId,
         JobHelper.ToTimestamp(DateTime.UtcNow));
 }

        public void OnStateUnapplied(
            ApplyStateContext context, IWriteOnlyTransaction transaction)
        {
            Assert.NotNull(context);
            Assert.NotNull(transaction);

            _results.Add(String.Format("{0}::{1}", _name, "OnStateUnapplied"));
        }

        public ProcessingStateHandlerFacts()
        {
            _context = new ApplyStateContextMock();
            _context.StateContextValue.JobIdValue = JobId;
            _context.NewStateValue = new ProcessingState("server", 1);

            _transaction = Substitute.For<IWriteOnlyTransaction>();
        }

        public DeletedStateHandlerFacts()
        {
            _context = new ApplyStateContextMock();
            _context.StateContextValue.JobIdValue = JobId;
            _context.NewStateValue = new DeletedState();

            _transaction = Substitute.For<IWriteOnlyTransaction>();
        }

        public SucceededStateHandlerFacts()
        {
            _context = new ApplyStateContextMock();
            _context.StateContextValue.JobIdValue = JobId;
            _context.NewStateValue = new SucceededState(null, 11, 123);

            _transaction = Substitute.For<IWriteOnlyTransaction>();
        }

 public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     var awaitingState = context.NewState as AwaitingState;
     if (awaitingState != null)
     {
         context.JobExpirationTimeout = awaitingState.Expiration;
     }
 }

 public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     var failedState = context.NewState as FailedState;
     if (failedState != null)
     {
         Logger.ErrorException(
             String.Format("Background job #{0} was failed with an exception.", context.JobId), 
             failedState.Exception);
     }
 }

            public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
            {
                var enqueuedState = context.NewState as EnqueuedState;
                if (enqueuedState == null)
                {
                    throw new InvalidOperationException(String.Format(
                        "`{0}` state handler can be registered only for the Enqueued state.",
                        typeof(Handler).FullName));
                }

                transaction.AddToQueue(enqueuedState.Queue, context.JobId);
            }

            public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
            {
                var scheduledState = context.NewState as ScheduledState;
                if (scheduledState == null)
                {
                    throw new InvalidOperationException(String.Format(
                        "`{0}` state handler can be registered only for the Scheduled state.",
                        typeof(Handler).FullName));
                }

                var timestamp = JobHelper.ToTimestamp(scheduledState.EnqueueAt);
                transaction.AddToSet("schedule", context.JobId, timestamp);
            }

        public void ApplyState(IWriteOnlyTransaction transaction, ApplyStateContext context)
        {
            var filterInfo = GetFilters(context.Job);
            var filters = filterInfo.ApplyStateFilters;

            foreach (var state in context.TraversedStates)
            {
                transaction.AddJobState(context.JobId, state);
            }

            foreach (var handler in _handlers.GetHandlers(context.OldStateName))
            {
                handler.Unapply(context, transaction);
            }

            foreach (var filter in filters)
            {
                filter.OnStateUnapplied(context, transaction);
            }

            transaction.SetJobState(context.JobId, context.NewState);

            foreach (var handler in _handlers.GetHandlers(context.NewState.Name))
            {
                handler.Apply(context, transaction);
            }

            foreach (var filter in filters)
            {
                filter.OnStateApplied(context, transaction);
            }

            if (context.NewState.IsFinal)
            {
                transaction.ExpireJob(context.JobId, context.JobExpirationTimeout);
            }
            else
            {
                transaction.PersistJob(context.JobId);
            }
        }

 public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.InsertToList("deleted", context.BackgroundJob.Id);
     transaction.TrimList("deleted", 0, 99);
 }

 public void Unapply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.RemoveFromList("deleted", context.BackgroundJob.Id);
 }

 public void Unapply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.DecrementCounter("stats:deleted");
 }

 public void Unapply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.RemoveFromList("succeeded", context.JobId);
 }

 public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.InsertToList("succeeded", context.JobId);
     transaction.TrimList("succeeded", 0, 99);
 }

		public void Unapply(ApplyStateContext context, IWriteOnlyTransaction transaction)
		{
			transaction.RemoveFromSet("failed", context.JobId);
		}

 /// <inheritdoc />
 public void OnStateApplied(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     if (context.NewState is ScheduledState &&
         context.NewState.Reason != null &&
         context.NewState.Reason.StartsWith("Retry attempt"))
     {
         transaction.AddToSet("retries", context.BackgroundJob.Id);
     }
 }

 public void Apply(ApplyStateContext context, IWriteOnlyTransaction transaction)
 {
     transaction.IncrementCounter("stats:succeeded");
 }