C# MessageStatus类代码示例

 /// <summary>Initializes a new instance of the <see cref="TextMessage"/> class.</summary>
 /// <param name="_message">The message.</param>
 /// <param name="fromNumber">The number.</param>
 /// <param name="toNumber"></param>
 /// <param name="_dateTime">The date time.</param>
 /// <param name="_sentOrRecieved">The sent or recieved status.</param>
 /// <param name="_filePath">Path of the file.</param>
 public TextMessage(MessageFormat format, string _message, string fromNumber, string toNumber, DateTime _dateTime, MessageStatus _sentOrRecieved, string _filePath)
     : base(_message, fromNumber, toNumber, _dateTime)
 {
     Format = format;
     sentOrRecieved = _sentOrRecieved;
     filePath = _filePath;
 }

 public MessageEventArgs(string message, int queuedMessageCount, MessageStatus status, string error)
 {
     _message = message;
     _queuedMessageCount = queuedMessageCount;
     _status = status;
     _error = error;
 }

        public static void ErrorFsctlrvRequestResumeKeyResponse(int messageId, MessageStatus messageStatus)
        {
            Condition.IsTrue(smbConnection.sentRequest.ContainsKey(messageId));
            Condition.IsTrue((messageStatus == MessageStatus.NetworkSessionExpired)
                                || (messageStatus == MessageStatus.NotSupported));
            Condition.IsTrue(smbConnection.sentRequest[messageId].command == Command.FsctlSrvRequestResumeKey);
            FsctlSrvResumeKeyRequest request = (FsctlSrvResumeKeyRequest)smbConnection.sentRequest[messageId];

            if (messageStatus == MessageStatus.NetworkSessionExpired)
            {
                smbConnection.sessionList.Remove(request.sessionId);
                smbState = SmbState.Closed;
            }
            else if (messageStatus == MessageStatus.NotSupported)
            {
                // As input paramter is valid, that the SUT still reuturn error code indicates that the SUT does not
                // support this operation.
                if (!Parameter.isSupportResumeKey)
                {
                    ModelHelper.CaptureRequirement(
                        30023,
                        @"[In Receiving an FSCTL_SRV_REQUEST_RESUME_KEY Function Code] If this operation [Receiving an
                        FSCTL_SRV_REQUEST_RESUME_KEY Function Code] is successful, then the server MUST construct an
                        FSCTL_SRV_CHOPYCHUNK response as specified in section 2.2.7.2.2, with the following additional
                        requirements: If the server does not support this operation [Receiving an
                        FSCTL_SRV_REQUEST_RESUME_KEY Function Code], then it MUST fail the request with
                        STATUS_NOT_SUPPORTED.");
                }
                smbState = SmbState.End;
            }
            smbConnection.sentRequest.Remove(messageId);
        }

        public IEnumerable<MessageWrapper> GetMessageByFilter(int projectid, int tag, Guid departament, Guid participant,
                                                              ApiDateTime createdStart, ApiDateTime createdStop, int lastId,
                                                              bool myProjects, bool follow, MessageStatus? status)
        {
            var messageEngine = EngineFactory.GetMessageEngine();
            var taskFilter = new TaskFilter
            {
                DepartmentId = departament,
                UserId = participant,
                FromDate = createdStart,
                ToDate = createdStop,
                SortBy = _context.SortBy,
                SortOrder = !_context.SortDescending,
                SearchText = _context.FilterValue,
                TagId = tag,
                Offset = _context.StartIndex,
                Max = _context.Count,
                MyProjects = myProjects,
                LastId = lastId,
                Follow = follow,
                MessageStatus = status
            };

            if (projectid != 0)
                taskFilter.ProjectIds.Add(projectid);

            _context.SetDataPaginated();
            _context.SetDataFiltered();
            _context.SetDataSorted();
            _context.TotalCount = messageEngine.GetByFilterCount(taskFilter);

            return messageEngine.GetByFilter(taskFilter).NotFoundIfNull().Select(r => new MessageWrapper(r)).ToSmartList();
        }

 public MessageErrorInfo(MessageStatus status)
 {
     _statusSpecified = true;
     Status = status;
     Image = GetImage();
     Description = status.GetDescription();
 }

        /// <summary>
        /// Retrieve a list of messages by status and type
        /// </summary>
        /// <param name="status"></param>
        /// <param name="type"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public Paginator<Message> FindPagedMessagesBySiteAndStatusAndType(Site site, MessageStatus status, MessageType type, string orderBy, bool orderAscending, int pageSize)
        {
            DetachedCriteria criteria = DetachedCriteria.For<Message>()
                                       .AddOrder(new Order(orderBy, orderAscending))
                                       .Add(Restrictions.Eq("Site", site));

             return Repository<Message>.GetPaginator(criteria, pageSize);
        }

		public void Process(MessageQueue msgQueue)
		{
			if (IsValid)
			{
				vStatus = MessageStatus.Processing;
				vProcessor(msgQueue, this);
			}
		}

        public void RemoveFlag_ShouldRemoveSingleFlag()
        {
            _status = _status.RemoveFlag(MessageStatus.New);

            Assert.That(_status.HasFlag(MessageStatus.New), Is.False);
            Assert.That(_status.HasFlag(MessageStatus.Sent), Is.False);
            Assert.That(_status.HasFlag(MessageStatus.Received), Is.False);
        }

        public void RemoveFlag_ShouldChainMultipleFlags()
        {
            _status = _status.AddFlag(MessageStatus.Sent).AddFlag(MessageStatus.Received).RemoveFlag(MessageStatus.New);

            Assert.That(_status.HasFlag(MessageStatus.New), Is.False);
            Assert.That(_status.HasFlag(MessageStatus.Sent), Is.True);
            Assert.That(_status.HasFlag(MessageStatus.Received), Is.True);
        }

        public void AddFlag_ShouldAddSingleFlag()
        {
            _status = _status.AddFlag(MessageStatus.Sent);

            Assert.That(_status.HasFlag(MessageStatus.New), Is.True);
            Assert.That(_status.HasFlag(MessageStatus.Sent), Is.True);
            Assert.That(_status.HasFlag(MessageStatus.Received), Is.False);
        }

        public void AddFlag_ShouldChainMultipleFlags()
        {
            status = status.AddFlag(MessageStatus.Sent).AddFlag(MessageStatus.Received);

            Assert.That(status.HasFlag(MessageStatus.New), Is.True);
            Assert.That(status.HasFlag(MessageStatus.Sent), Is.True);
            Assert.That(status.HasFlag(MessageStatus.Received), Is.True);
        }

        public static void ErrorFindFirst2Response(int messageId, MessageStatus messageStatus)
        {
            Condition.IsTrue(smbConnection.sentRequest.ContainsKey(messageId));
            Condition.IsTrue(messageStatus == MessageStatus.NetworkSessionExpired
                                || messageStatus == MessageStatus.NotSupported
                                || messageStatus == MessageStatus.ObjectNameNotFound
                                || messageStatus == MessageStatus.InvalidParameter);

            Condition.IsTrue(smbConnection.sentRequest[messageId].command == Command.TransFindFirst2);
            Trans2FindFirst2Request request = (Trans2FindFirst2Request)smbConnection.sentRequest[messageId];
            switch (messageStatus)
            {
                case MessageStatus.NotSupported:
                    Condition.IsTrue(Parameter.sutPlatform == Platform.NonWindows);
                    Condition.IsTrue(request.gmtTokenIndex != -1);

                    if (request.informationLevel == InformationLevel.SmbFindFileIdBothDirectoryInfo
                            || request.informationLevel == InformationLevel.SmbFindFileIdFullDirectoryInfo)
                    {
                        ModelHelper.CaptureRequirement(
                            4898,
                            "[In Receiving a TRANS2_FIND_FIRST2 Request New Information Levels]If the server does not " +
                            "support the new Information Levels, then it MUST fail the operation with " +
                            "STATUS_NOT_SUPPORTED.<124>");
                    }
                    smbState = SmbState.End;
                    break;
                case MessageStatus.ObjectNameNotFound:
                    if (request.informationLevel == InformationLevel.SmbFindFileIdBothDirectoryInfo
                            || request.informationLevel == InformationLevel.SmbFindFileIdFullDirectoryInfo)
                    {
                        Condition.IsTrue(Parameter.sutPlatform != Platform.NonWindows);
                    }
                    Condition.IsTrue(request.gmtTokenIndex == -1);
                    Condition.IsTrue(request.isFlagsKnowsLongNameSet);
                    smbState = SmbState.End;
                    break;
                case MessageStatus.NetworkSessionExpired:
                    smbConnection.sessionList.Remove(request.sessionId);
                    smbState = SmbState.Closed;
                    break;
                case MessageStatus.InvalidParameter:
                    if (!request.isFlagsKnowsLongNameSet
                            && request.informationLevel != InformationLevel.SmbInfoStandard)
                    {
                        ModelHelper.CaptureRequirement(
                            9280,
                            @"[In Client Request Extensions] InformationLevel (2 bytes): If a client that has not
                            negotiated long names support requests an InformationLevel other than SMB_INFO_STANDARD,
                            then the server MUST return a status of STATUS_INVALID_PARAMETER(ERRDOS/ERRinvalidparam).");
                    }
                    smbState = SmbState.End;
                    break;
                default:
                    break;
            }
            smbConnection.sentRequest.Remove(messageId);
        }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="fullPath">Full path to the file</param>
 /// <param name="status">Current status of this data message</param>
 public ClientDataMessage(string fullPath, MessageStatus status)
 {
     this.FullPath = fullPath;
     if (!string.IsNullOrEmpty(this.FullPath))
     {
         this.Name = Path.GetFileName(this.FullPath);
     }
     this.MessageStatus = status;
 }

        /// <summary>
        /// Verify file standard information 
        /// </summary>
        /// <param name="info">An instance of FileStandardInformation</param>
        /// <param name="status">An instance of MessageStatus</param>
        private void VerifyFileStandardInformation(FileStandardInformation info, MessageStatus status)
        {
            if (this.fileSystem == FileSystem.NTFS)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSA_R46036 Actual FileSystem: {0}", fileSystem);

                //
                // Verify MS-FSA requirement: MS-FSA_R46036
                //
                Site.CaptureRequirementIfAreEqual <MessageStatus>(
                    MessageStatus.SUCCESS,
                    status,
                    46036,
                    @"[In FileStandardInformation] <58> Section 3.1.5.11.27: This algorithm is implemented by NTFS. ");
            }

            if (this.fileSystem == FileSystem.FAT
                || this.fileSystem == FileSystem.EXFAT
                || this.fileSystem == FileSystem.CDFS
                || this.fileSystem == FileSystem.UDFS)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSA_R4637");

                //
                // Verify MS-FSA requirement: MS-FSA_R4637
                //
                Site.CaptureRequirementIfAreEqual<uint>(
                    1,
                    info.NumberOfLinks,
                    4637,
                    @"[In FileStandardInformation] <58> Section 3.1.5.11.27:The FAT, EXFAT, CDFS, and UDFS file systems always return 1.");
            }

            if (info.NumberOfLinks == 0)
            {
                //
                // Add the debug information
                //
                Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSA_R2746");

                //
                // Verify MS-FSA requirement: MS-FSA_R2746
                //
                Site.CaptureRequirementIfAreEqual<byte>(
                    1,
                    info.DeletePending,
                    2746,
                    @"[In FileStandardInformation,Pseudocode for the operation is as follows:]If alignmentInfo.NumberOfLinks is 0,
                    set alignmentInfo.DeletePending to 1.");
            }
        }

 /// <summary>
 /// To check if current transport supports Integrity.
 /// </summary>
 /// <param name="status">NTStatus code to compare with expected status.</param>
 /// <returns>Return True if supported, False if not supported.</returns>
 private bool IsCurrentTransportSupportIntegrity(MessageStatus status)
 {
     if (this.fsaAdapter.Transport == Transport.SMB)
     {
         this.fsaAdapter.AssertAreEqual(this.Manager, MessageStatus.NOT_SUPPORTED, status,
             "This operation is not supported for SMB transport.");
         return false;
     }
     return true;
 }