public ProjectionsStatisticsHttpFormatted(
     ProjectionManagementMessage.Statistics source, Func<string, string> makeAbsouteUrl)
 {
     _projections =
         source.Projections.Select(v => new ProjectionStatisticsHttpFormatted(v, makeAbsouteUrl)).ToArray();
     _transactionFileHeadPosition = source.TransactionFileHeadPosition;
 }

 public Definition(
     string name, string handlerType, string query, SlaveProjectionRequestedNumber requestedNumber,
     ProjectionMode mode, bool emitEnabled, bool checkpointsEnabled, bool enableRunAs,
     ProjectionManagementMessage.RunAs runAs)
 {
     _name = name;
     _handlerType = handlerType;
     _query = query;
     _requestedNumber = requestedNumber;
     _runAs = runAs;
     _enableRunAs = enableRunAs;
     _checkpointsEnabled = checkpointsEnabled;
     _emitEnabled = emitEnabled;
     _mode = mode;
 }

 public void Handle(ProjectionManagementMessage.Command.Abort message)
 {
     _lastAccessed = _timeProvider.Now;
     UpdateProjectionVersion();
     SetLastReplyEnvelope(message.Envelope);
     Disable();
     Abort();
 }

 private void DoDisable(ProjectionManagementMessage.Disable message)
 {
     if (!Enabled)
     {
         message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed("Not enabled"));
         return;
     }
     Disable();
     PrepareAndBeginWrite(
         forcePrepare: false,
         completed: () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)));
 }

 public void InitializeNew(ProjectionManagementMessage.Post message, Action completed)
 {
     LoadPersistedState(
         new PersistedState
             {
                 Enabled = message.Enabled,
                 HandlerType = message.HandlerType,
                 Query = message.Query,
                 Mode = message.Mode
             });
     PrepareAndBeginWrite(forcePrepare: true, completed: () => StartNew(completed));
 }

 public void Handle(ProjectionManagementMessage.Enable message)
 {
     if (Enabled)
     {
         message.Envelope.ReplyWith(new ProjectionManagementMessage.OperationFailed("Not disabled"));
         return;
     }
     Enable();
     PrepareAndBeginWrite(
         forcePrepare: true,
         completed:
             () =>
             Start(
                 () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name))));
 }

 private void DoDelete(ProjectionManagementMessage.Delete message)
 {
     if (Enabled)
         Disable();
     Delete();
     Action completed = () =>
         {
             message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(_name));
             DisposeCoreProjection();
             _output.Publish(new ProjectionManagementMessage.Internal.Deleted(_name, Id));
         };
     UpdateProjectionVersion();
     if (Enabled)
         Prepare(() => BeginWrite(completed));
     else
         BeginWrite(completed);
 }

 private void UpdateQuery(ProjectionManagementMessage.Command.UpdateQuery message)
 {
     PersistedProjectionState.HandlerType = message.HandlerType ?? HandlerType;
     PersistedProjectionState.Query = message.Query;
     PersistedProjectionState.EmitEnabled = message.EmitEnabled ?? PersistedProjectionState.EmitEnabled;
     _pendingWritePersistedState = true;
     if (_state == ManagedProjectionState.Completed)
     {
         Reset();
     }
 }

 private void SetRunAs(ProjectionManagementMessage.Command.SetRunAs message)
 {
     PersistedProjectionState.RunAs = message.Action == ProjectionManagementMessage.Command.SetRunAs.SetRemove.Set
         ? SerializedRunAs.SerializePrincipal(message.RunAs)
         : null;
     _runAs = SerializedRunAs.DeserializePrincipal(PersistedProjectionState.RunAs);
     _pendingWritePersistedState = true;
 }

        public static SerializedRunAs SerializePrincipal(ProjectionManagementMessage.RunAs runAs)
        {
            if (runAs.Principal == null)
                return null; // anonymous
            if (runAs.Principal == SystemAccount.Principal)
                return new SerializedRunAs {Name = "$system"};

            var genericPrincipal = runAs.Principal as OpenGenericPrincipal;
            if (genericPrincipal == null)
                throw new ArgumentException(
                    "OpenGenericPrincipal is the only supported principal type in projections", "runAs");
            return new SerializedRunAs {Name = runAs.Principal.Identity.Name, Roles = genericPrincipal.Roles};
        }

 private void DoUpdateQuery(ProjectionManagementMessage.UpdateQuery message)
 {
     _persistedState.HandlerType = message.HandlerType ?? HandlerType;
     _persistedState.Query = message.Query;
     _persistedState.EmitEnabled = message.EmitEnabled ?? _persistedState.EmitEnabled;
     if (_state == ManagedProjectionState.Completed)
     {
         ResetProjection();
     }
     Action completed = () =>
         {
             StartOrLoadStopped(() => { });
             message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name));
         };
     UpdateProjectionVersion();
     Prepare(() => BeginWrite(completed));
 }

        public void Handle(ProjectionManagementMessage.GetQuery message)
        {
            _lastAccessed = _timeProvider.Now;
            if (!ProjectionManagementMessage.RunAs.ValidateRunAs(Mode, ReadWrite.Read, _runAs, message)) return;

            var emitEnabled = _persistedState.EmitEnabled ?? false;
            message.Envelope.ReplyWith(
                new ProjectionManagementMessage.ProjectionQuery(_name, Query, emitEnabled, _persistedState.SourceDefinition));
        }

 private void DoDelete(ProjectionManagementMessage.Delete message)
 {
     if (Enabled)
         Disable();
     Delete();
     PrepareAndBeginWrite(
         forcePrepare: false,
         completed: () => message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name)));
 }

 private void DoUpdateQuery(ProjectionManagementMessage.UpdateQuery message)
 {
     UpdateQuery(message.HandlerType ?? HandlerType, message.Query);
     PrepareAndBeginWrite(
         forcePrepare: true, completed: () =>
             {
                 if (Enabled)
                     Start(() => { });
                 message.Envelope.ReplyWith(new ProjectionManagementMessage.Updated(message.Name));
             });
 }