public TSResponse(XmlElement element)
 {
     type = (ResponseType)Enum.Parse(typeof(ResponseType), element.GetAttribute("type"), false);
     XmlNodeList l = element.GetElementsByTagName("tuple");
     id = element.GetAttribute("id");
     tuples = new Tuple[l.Count];
     for (int i = 0; i < l.Count; i++)
     {
         XmlElement elTuple = (XmlElement)l[i];
         tuples[i] = new Tuple(elTuple);
     }
 }

		protected void OnBtnSendClicked (object sender, EventArgs e)
		{
			Response = ResponseType.Accept;
			this.UserDescription = textview1.Buffer.Text;
			this.HideAll ();
			Send (ex, sv);
		}

        public HttpWorker(Uri uri, HttpMethod httpMethod = HttpMethod.Get, Dictionary<string, string> headers = null, byte[] data = null)
        {
            _buffer = new byte[8192];
            _bufferIndex = 0;
            _read = 0;
            _responseType = ResponseType.Unknown;
            _uri = uri;
            IPAddress ip;
            var headersString = string.Empty;
            var contentLength = data != null ? data.Length : 0;

            if (headers != null && headers.Any())
                headersString = string.Concat(headers.Select(h => "\r\n" + h.Key.Trim() + ": " + h.Value.Trim()));

            if (_uri.HostNameType == UriHostNameType.Dns)
            {
                var host = Dns.GetHostEntry(_uri.Host);
                ip = host.AddressList.First(i => i.AddressFamily == AddressFamily.InterNetwork);
            }
            else
            {
                ip = IPAddress.Parse(_uri.Host);
            }

            _endPoint = new IPEndPoint(ip, _uri.Port);
            _request = Encoding.UTF8.GetBytes($"{httpMethod.ToString().ToUpper()} {_uri.PathAndQuery} HTTP/1.1\r\nAccept-Encoding: gzip, deflate, sdch\r\nHost: {_uri.Host}\r\nContent-Length: {contentLength}{headersString}\r\n\r\n");

            if (data == null)
                return;

            var tmpRequest = new byte[_request.Length + data.Length];
            Buffer.BlockCopy(_request, 0, tmpRequest, 0, _request.Length);
            Buffer.BlockCopy(data, 0, tmpRequest, _request.Length, data.Length);
            _request = tmpRequest;
        }

		/// <summary>
		///   建構子
		/// </summary>
		/// <param name="tradeOrder">訂單資訊</param>
		/// <param name="symbolId">商品代號</param>
		/// <param name="type">回報類型</param>
		/// <param name="openTrades">開倉交易單列表</param>
		/// <param name="closeTrades">已平倉交易單列表</param>
		public ResponseEvent(ITradeOrder tradeOrder, string symbolId, ResponseType type, TradeList<ITrade> openTrades, List<ITrade> closeTrades) {
			__cTradeOrder = tradeOrder;
			__sSymbolId = symbolId;
			__cType = type;
			__cOpenTrades = openTrades;
			__cCloseTrades = closeTrades;
		}

        public static object Service(this Uri url, RequestType requestType, ResponseType responseType, out int resultCode, string outputFilename, IDictionary<string, string> formData) {
            object result = null;
            resultCode = -1;

            var webRequest = (HttpWebRequest)WebRequest.Create(url);
            webRequest.Proxy = GetProxy();

            webRequest.CookieContainer = Cookies.GetCookieContainer();

            switch (requestType) {
                case RequestType.POST:
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";

                    var encodedFormData = Encoding.UTF8.GetBytes(GetFormData(formData).ToString());
                    using (var requestStream = webRequest.GetRequestStream()) {
                        requestStream.Write(encodedFormData, 0, encodedFormData.Length);
                    }
                    break;
                case RequestType.GET:
                    webRequest.Method = "GET";
                    if (formData != null) {
                        var ub = new UriBuilder(url) {
                            Query = GetFormData(formData).ToString()
                        };
                        url = ub.Uri;
                    }
                    break;
            }

            try {
                if (credentialCache != null) {
                    webRequest.Credentials = credentialCache;
                    webRequest.PreAuthenticate = true;
                }
                var webResponse = webRequest.GetResponse();

                if (!KeepCookiesClean) {
                    Cookies.AddCookies(webRequest.CookieContainer.GetCookies(webResponse.ResponseUri));
                }

                switch (responseType) {
                    case ResponseType.String:
                        result = GetStringResponse(webResponse);
                        resultCode = 200;
                        break;
                    case ResponseType.Binary:
                        result = GetBinaryResponse(webResponse);
                        resultCode = 200;
                        break;
                    case ResponseType.File:
                        result = GetBinaryFileResponse(webResponse, outputFilename);
                        resultCode = 200;
                        break;
                }
            } catch {
                resultCode = 0;
            }
            return result;
        }

        protected override void OnResponse(ResponseType response_id)
        {
            base.OnResponse (response_id);

            if (response_id == ResponseType.Cancel)
                this.Destroy();
        }

		/// <summary>
		/// Creates a new response object with the given XML representation.
		/// </summary>
		/// <param name="xml">XML representation of this response</param>
		public ResponseElement(XmlNode xml) : base(xml)
		{ 
			switch(xml.Name)
			{
				case "success":
					type = ResponseType.Success;
					break;
				case "failure":
					type = ResponseType.Failure;
					break;
				case "stream:error":
					type = ResponseType.StreamError;
					break;
				case "starttls":
					type = ResponseType.StartTls;
					break;
				case "proceed":
					type = ResponseType.ProceedTls;
					break;
				case "challenge":
					type = ResponseType.SaslChallenge;
					break;
				case "response":
					type = ResponseType.SaslResponse;
					break;
				default:
					throw new OpenXMPPException("An unknown response element was received.");
			}
		}

 private void OnLoginResponse(ResponseType responseType, JToken responseData, string callee) {
     if (responseType == ResponseType.Success) {
         authenticationToken = responseData.Value<string>("token");
         if (OnLoggedIn != null) {
             OnLoggedIn();
         }
     } else if (responseType == ResponseType.ClientError) {
         if (OnLoginFailed != null) {
             OnLoginFailed("Could not reach the server. Please try again later.");
         }
     } else {
         JToken fieldToken = responseData["non_field_errors"];
         if (fieldToken == null || !fieldToken.HasValues) {
             if (OnLoginFailed != null) {
                 OnLoginFailed("Login failed: unknown error.");
             }
         } else {
             string errors = "";
             JToken[] fieldValidationErrors = fieldToken.Values().ToArray();
             foreach (JToken validationError in fieldValidationErrors) {
                 errors += validationError.Value<string>();
             }
             if (OnLoginFailed != null) {
                 OnLoginFailed("Login failed: " + errors);
             }
         }
     }
 }

 //RESPONSE
 public NetCommand(ResponseType response, int session)
 {
     Type = CommandType.RESPONSE;
     Session = session;
     Timestamp = Helper.Now;
     Response = response;
 }

        /// <summary>
        /// Constructs an authorize url.
        /// </summary>
        public static string BuildAuthorizeUrl(
            string clientId, 
            string redirectUrl, 
            IEnumerable<string> scopes, 
            ResponseType responseType,
            DisplayType display,
            ThemeType theme,
            string locale,
            string state)
        {
            Debug.Assert(!string.IsNullOrEmpty(clientId));
            Debug.Assert(!string.IsNullOrEmpty(redirectUrl));
            Debug.Assert(!string.IsNullOrEmpty(locale));

            IDictionary<string, string> options = new Dictionary<string, string>();
            options[AuthConstants.ClientId] = clientId;
            options[AuthConstants.Callback] = redirectUrl;
            options[AuthConstants.Scope] = BuildScopeString(scopes);
            options[AuthConstants.ResponseType] = responseType.ToString().ToLowerInvariant();
            options[AuthConstants.Display] = display.ToString().ToLowerInvariant();
            options[AuthConstants.Locale] = locale;
            options[AuthConstants.ClientState] = EncodeAppRequestState(state);

            if (theme != ThemeType.None)
            {
                options[AuthConstants.Theme] = theme.ToString().ToLowerInvariant();
            }

            return BuildAuthUrl(AuthEndpointsInfo.AuthorizePath, options);
        }

        protected override void OnResponse (ResponseType response)
        {
            base.OnResponse (response);

            if (CurrentFolderUri != null) {
                LastFileChooserUri.Set (CurrentFolderUri);
            }
        }

 protected override void OnResponse(ResponseType response)
 {
     if (response == ResponseType.Ok) {
         int timervalue = sleepHour.ValueAsInt * 60 + sleepMin.ValueAsInt;
         service.SleepTimerDuration = timervalue;
         service.SetSleepTimer (timervalue);
     }
 }

 /// <summary>
 /// Constructor that accepts values for all mandatory fields
 /// </summary>
 ///<param name="refId">A RefId</param>
 ///<param name="assessmentFormRefId">This RefId points to the assessment form of which the item is a part.</param>
 ///<param name="responseType">A value that indicates the response type for the item.</param>
 ///<param name="itemLabel">An item number or other identifier for the item.  It may be used to indicate the order or grouping of items.</param>
 ///
 public AssessmentItem( string refId, string assessmentFormRefId, ResponseType responseType, string itemLabel )
     : base(Adk.SifVersion, AssessmentDTD.ASSESSMENTITEM)
 {
     this.RefId = refId;
     this.AssessmentFormRefId = assessmentFormRefId;
     this.SetResponseType( responseType );
     this.ItemLabel = itemLabel;
 }

        protected override void OnResponse(ResponseType response)
        {
            base.OnResponse (response);

            if (response == ResponseType.Help)
                Help.DisplayUriOnScreen ("ghelp:questar/preferences",
                    base.Dialog.Screen);
        }

 protected Uri BuildAuthenticateUri(AuthenticationPermissions scope, ResponseType responseType)
 {
     var builder = new HttpUriBuilder(AuthenticationUrl);
     builder.AddQueryStringParameter("client_id", this.ClientId);
     builder.AddQueryStringParameter("response_type", responseType.ToString().ToLower());
     builder.AddQueryStringParameter("scope", scope.GetParameterValue());
     builder.AddQueryStringParameter("redirect_uri", RedirectUri);
     return builder.Build();
 }

	/* Event members */

	#pragma warning disable 169		//Disables warning about handlers not being used

	protected override bool ProcessResponse (ResponseType response) {
		if (response == ResponseType.Ok) {
			if (dialog.Uri != null) {
				chosenUri = new Uri(dialog.Uri);
			}
			SetReturnValue(true);
		}
		return false;
	}

        public void Broadcast(dynamic data, string[] clients, ResponseType type, long timestamp)
        {
            ClientMessage cb = new ClientMessage();
            cb.clients = clients;
            cb.Data = data;
            cb.Type = type;
            cb.TimeStamp = timestamp;

            Send(Newtonsoft.Json.JsonConvert.SerializeObject(cb));
        }

 /// <summary>
 /// Creates a new message box
 /// </summary>
 /// <param name="parentWindow">Window this box belongs to</param>
 /// <param name="messageType">Type of box</param>
 /// <param name="buttons">Buttons</param>
 /// <param name="message">Value</param>
 /// <param name="title">Title</param>
 public MessageBox(Window parentWindow, MessageType messageType, ButtonsType buttons, string message, string title)
 {
     Message = new MessageDialog(parentWindow, DialogFlags.Modal, messageType, buttons, false, null);
     Message.WindowPosition = WindowPosition.Center;
     Message.Text = message;
     Message.Icon = Gdk.Pixbuf.LoadFromResource("Client.Resources.pigeon_clip_art_hight.ico");
     Message.Title = title;
     result = (ResponseType)Message.Run();
     Message.Destroy();
 }

 private Response(long token, ResponseType responseType, JArray data, List<ResponseNote> responseNotes, Profile profile, Backtrace backtrace, ErrorType errorType)
 {
     this.Token = token;
     this.Type = responseType;
     this.Data = data;
     this.Notes = responseNotes;
     this.Profile = profile;
     this.Backtrace = backtrace;
     this.ErrorType = errorType;
 }

        public void the_LRAP1Attachment_is_submitted_to_the_AgentGateway(ResponseType responseType)
        {
            //Arrange
            A.CallTo(() => _fakeCommsService.Send(_command)).Returns(responseType);

            //Act
            _sut.Process(_command);

            //Assert
            A.CallTo(() => _fakeCommsService.Send(A<SubmitLrap1AttachmentCommand>.Ignored)).MustHaveHappened(Repeated.Exactly.Once);
        }