/// <summary>
/// 帮助信息.
/// </summary>
/// <returns></returns>
private TextResponse GetHelp(AbstractRequest req)
{
TextResponse result = new TextResponse()
{
// 接收方帐号（收到的OpenID）
ToUserName = req.FromUserName,
// 开发者微信号
FromUserName = req.ToUserName,
};
StringBuilder buff = new StringBuilder("您好，输入下列信息选择服务类型：");
buff.AppendLine();
foreach (IMessageProcessService service in MessageServiceList)
{
buff.AppendFormat("{0}:{1}", service.CommandText, service.CommandDesc);
buff.AppendLine();
}
result.Content = buff.ToString();
return(result);
}
/// <summary>
/// 处理请求.
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public AbstractResponse ProcessRequest(AbstractRequest req)
{
if (req.MsgType == MessageType.EventMsgType)
{
// 处理事件.
AbstractEventRequest e = req as AbstractEventRequest;
if (!this.EventServiceDictionary.ContainsKey(e.Event))
{
// 不包含特定的事件处理.
return(null);
}
IMessageProcessService service = this.EventServiceDictionary[e.Event];
return(service.ProcessRequest(req));
}
if (req.MsgType == MessageType.TextMsgType)
{
// 处理文本请求.
IMessageProcessService service = this.MessageServiceList.FirstOrDefault(p => p.CommandText.ToUpper() == ((TextRequest)req).Content.ToUpper());
if (service != null)
{
// 找到服务， 进行处理.
return(service.ProcessRequest(req));
}
}
// 未知的命令， 或者未知的 消息类型.
return(GetHelp(req));
}
/// <summary>
/// Creates the culture.
/// </summary>
private void CreateCulture(AbstractRequest request)
{
String culture = request.Language.ToString();
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(culture);
Thread.CurrentThread.CurrentUICulture = new CultureInfo(culture);
}
public override AbstractResponse DefaultResponse(AbstractRequest requestMessage)
{
ReplyInfo mismatchReply = ReplyHelper.GetMismatchReply();
AbstractResponse result;
if (mismatchReply == null || this.IsOpenManyService())
{
result = this.GotoManyCustomerService(requestMessage);
}
else
{
AbstractResponse response = this.GetResponse(mismatchReply, requestMessage.FromUserName);
if (response == null)
{
result = this.GotoManyCustomerService(requestMessage);
}
else
{
response.ToUserName = requestMessage.FromUserName;
response.FromUserName = requestMessage.ToUserName;
result = response;
}
}
return(result);
}
/// <summary>
/// Gets the order builder.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="orderId">The order identifier.</param>
/// <param name="transactionType">Type of the transaction.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException">Occurs when TransactionType is not AUTHORIZATION,
/// AUTHORIZATION_AND_CAPTURE, CAPTURE, VOID neither REFUND.</exception>
public static AbstractOrderBuilder GetOrderBuilder(AbstractRequest request, int?orderId, TransactionType transactionType)
{
switch (transactionType)
{
case TransactionType.AUTHORIZATION:
case TransactionType.AUTHORIZATION_AND_CAPTURE:
if (!orderId.HasValue)
{
return(new AuthCaptureNewOrderBuilder(request));
}
else
{
return(new AuthCaptureExistingOrderBuilder(request));
}
case TransactionType.CAPTURE:
case TransactionType.VOID:
case TransactionType.REFUND:
return(new ExistingOrderBuilder(request));
default:
throw new NotImplementedException(
string.Format("OrderBuilder not implemented for: ", transactionType));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CreditCardAuthAndCaptureAuthTransactionBuilder"/> class.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="transactionType">Type of the transaction.</param>
public CreditCardAuthAndCaptureAuthWithTokenTransactionBuilder(AbstractRequest request,
TransactionType transactionType)
: base(request, transactionType)
{
base.transaction.CreditCardTokenId = DataConverter.GetValue(
base.request.InternalParameters, PayUParameterName.TOKEN_ID);
}
private AbstractResponse GetKeyResponse(string key, AbstractRequest request)
{
IList <Hidistro.Entities.VShop.ReplyInfo> replies = ReplyHelper.GetReplies(ReplyType.Vote);
if ((replies != null) && (replies.Count > 0))
{
foreach (Hidistro.Entities.VShop.ReplyInfo info in replies)
{
if (info.Keys == key)
{
VoteInfo voteById = StoreHelper.GetVoteById((long)info.ActivityId);
if ((voteById != null) && voteById.IsBackup)
{
NewsResponse response = new NewsResponse
{
CreateTime = DateTime.Now,
FromUserName = request.ToUserName,
ToUserName = request.FromUserName,
Articles = new List <Article>()
};
Article item = new Article
{
Description = voteById.VoteName,
PicUrl = this.FormatImgUrl(voteById.ImageUrl),
Title = voteById.VoteName,
Url = string.Format("http://{0}/vshop/Vote.aspx?voteId={1}", HttpContext.Current.Request.Url.Host, voteById.VoteId)
};
response.Articles.Add(item);
return(response);
}
}
}
}
return(null);
}
private AbstractResponse GetKeyResponse(string key, AbstractRequest request)
{
System.Collections.Generic.IList <Hidistro.Entities.VShop.ReplyInfo> replies = ReplyHelper.GetReplies(ReplyType.Vote);
if (replies != null && replies.Count > 0)
{
foreach (Hidistro.Entities.VShop.ReplyInfo current in replies)
{
if (current.Keys == key)
{
VoteInfo voteById = StoreHelper.GetVoteById((long)current.ActivityId);
if (voteById != null && voteById.IsBackup)
{
return(new NewsResponse
{
CreateTime = System.DateTime.Now,
FromUserName = request.ToUserName,
ToUserName = request.FromUserName,
Articles = new System.Collections.Generic.List <Article>
{
new Article
{
Description = voteById.VoteName,
PicUrl = this.FormatImgUrl(voteById.ImageUrl),
Title = voteById.VoteName,
Url = string.Format("http://{0}/vshop/Vote.aspx?voteId={1}", System.Web.HttpContext.Current.Request.Url.Host, voteById.VoteId)
}
}
});
}
}
}
}
return(null);
}
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
var userParameters = AbstractRequest.GetParameter(req, "userId");
var result = new ComparisonProvider(new BoostRepository()).GetUserComparison(userParameters);
return(AbstractRequest.SerializeRespone(req, result));
}
public void JoinGame(Guid id)
{
var request = new JoinGameRequest(curUser, id);
curGame = id; // TODO: Если добавим в пакет ответа, то это убрать
client.Send(AbstractRequest.ToBytes(request));
}
public AbstractResponse GetResponse(ReplyInfo reply, string openId, AbstractRequest bstractRequest = null)
{
if (reply.MessageType == MessageType.Text)
{
TextReplyInfo textReplyInfo = reply as TextReplyInfo;
TextResponse textResponse = new TextResponse();
textResponse.CreateTime = DateTime.Now;
if (textReplyInfo != null && !string.IsNullOrEmpty(textReplyInfo.Text))
{
textResponse.Content = textReplyInfo.Text;
}
if (reply.Keys == "登录")
{
string arg = $"http://{HttpContext.Current.Request.Url.Host}/Vshop/MemberCenter.aspx?SessionId={openId}";
textResponse.Content = textResponse.Content.Replace("$login$", $"<a href=\"{arg}\">一键登录</a>");
}
if (reply.Keys == "红包")
{
string value = ((SubscribeEventRequest)bstractRequest).EventKey.Split('_')[1];
RedEnvelopeSendRecord redEnvelopeSendRecordById = WeiXinRedEnvelopeProcessor.GetRedEnvelopeSendRecordById(Convert.ToInt32(value));
if (redEnvelopeSendRecordById != null)
{
string arg2 = $"http://{HttpContext.Current.Request.Url.Host}/Vshop/GetRedEnvelope?SendCode={redEnvelopeSendRecordById.SendCode}&OrderId={redEnvelopeSendRecordById.OrderId}";
textResponse.Content += $"<a href=\"{arg2}\">立即领取红包</a>";
}
}
if (reply.Keys == "今日已领红包")
{
string arg3 = $"http://{HttpContext.Current.Request.Url.Host}/Vshop/Default.aspx";
textResponse.Content += $"<a href=\"{arg3}\">你今日已领取过了，立即购物</a>";
}
if (reply.Keys == "分销注册")
{
string arg4 = $"http://{HttpContext.Current.Request.Url.Host}/Vshop/ReferralRegister.aspx?again=1";
textResponse.Content += $"感谢您的关注。点击<a href=\"{arg4}\">注册</a>成为本商城分销员，赚取丰厚奖励！";
}
return(textResponse);
}
HttpContext current = HttpContext.Current;
NewsResponse newsResponse = new NewsResponse();
newsResponse.CreateTime = DateTime.Now;
newsResponse.Articles = new List <Article>();
foreach (NewsMsgInfo item2 in (reply as NewsReplyInfo).NewsMsg)
{
Article item = new Article
{
Description = item2.Description,
PicUrl = $"{Globals.GetProtocal(current)}://{HttpContext.Current.Request.Url.Host}{item2.PicUrl}",
Title = item2.Title,
Url = (string.IsNullOrEmpty(item2.Url) ? $"{Globals.GetProtocal(current)}://{HttpContext.Current.Request.Url.Host}/Vshop/ImageTextDetails.aspx?messageId={item2.Id}" : item2.Url)
};
newsResponse.Articles.Add(item);
}
return(newsResponse);
}
protected void Authenticate(AbstractRequest request)
{
MonoscapeCredentials requestCredentials = request.Credentials;
if ((requestCredentials == null) || (!requestCredentials.AccessKey.Equals(Credentials.AccessKey)) || (!requestCredentials.SecretKey.Equals(Credentials.SecretKey)))
{
Log.Error(this, "Monoscape request authentication failed!");
throw new MonoscapeSecurityException("Invalid Monoscape credentials");
}
Log.Debug(this, "Monoscape request authenticated");
}
public AbstractResponse GotoManyCustomerService(AbstractRequest requestMessage)
{
if (!this.IsOpenManyService())
{
return(null);
}
return(new AbstractResponse {
FromUserName = requestMessage.ToUserName, ToUserName = requestMessage.FromUserName, MsgType = ResponseMsgType.transfer_customer_service
});
}
public AbstractResponse GotoManyCustomerService(AbstractRequest requestMessage)
{
WeiXinHelper.UpdateRencentOpenID(requestMessage.FromUserName, this.wid);
if (!this.IsOpenManyService())
{
return(null);
}
return(new AbstractResponse {
FromUserName = requestMessage.ToUserName, ToUserName = requestMessage.FromUserName, MsgType = ResponseMsgType.transfer_customer_service
});
}
protected void Authenticate(AbstractRequest request)
{
MonoscapeCredentials requestCredentials = request.Credentials;
if ((requestCredentials == null) || (!requestCredentials.AccessKey.Equals(Credentials.AccessKey)) || (!requestCredentials.SecretKey.Equals(Credentials.SecretKey)))
{
Log.Error(this, "Monoscape request authentication failed!");
throw new MonoscapeSecurityException("Invalid Monoscape credentials");
}
Log.Debug(this, "Monoscape request authenticated");
}
/// <summary>
/// Gets the transaction builder with token.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="transactionType">Type of the transaction.</param>
/// <returns></returns>
/// <exception cref="System.NotSupportedException"></exception>
private static AbstractTransactionBuilder GetTransactionBuilderWithToken(AbstractRequest request,
TransactionType transactionType)
{
string tokenId = DataConverter.GetValue(request.InternalParameters, PayUParameterName.TOKEN_ID);
switch (transactionType)
{
case TransactionType.AUTHORIZATION:
case TransactionType.AUTHORIZATION_AND_CAPTURE:
return(new CreditCardAuthAndCaptureAuthWithTokenTransactionBuilder(request, transactionType));
}
throw new NotSupportedException(string.Format("Not supported {0} for token operation", transactionType));
}
public AbstractResponse GotoManyCustomerService(AbstractRequest requestMessage)
{
if (!this.IsOpenManyService())
{
return(null);
}
AbstractResponse abstractResponse = new AbstractResponse();
abstractResponse.FromUserName = requestMessage.ToUserName;
abstractResponse.ToUserName = requestMessage.FromUserName;
abstractResponse.MsgType = ResponseMsgType.transfer_customer_service;
return(abstractResponse);
}
public TReturn Send <TReturn>(AbstractRequest <TReturn> request, IRequestOptions options = null)
where TReturn : class
{
try
{
if (logger.IsDebugEnabled)
{
var debugMessage = request.GetDebugLogMessage();
if (!string.IsNullOrWhiteSpace(debugMessage))
{
logger.Debug(debugMessage);
}
}
if (logger.IsInfoEnabled)
{
var infoMessage = request.GetInfoLogMessage();
if (!string.IsNullOrEmpty(infoMessage))
{
logger.Info(infoMessage);
}
}
TReturn result = null;
options = options ?? DefaultRequestOptions;
var clientForRequest = PickClientForApiName(request.GetApiName());
RetryLogic.DoWithRetry(options.RetryAttempts, request.GetName(),
() => result = request.GetSendFunc(clientForRequest)(), logger);
return(result);
}
catch (WebServiceException webx)
{
string errorCode = string.Empty;
if (!string.IsNullOrEmpty(webx.ErrorCode))
{
errorCode = string.Format(" ({0})", webx.ErrorCode);
}
var msg = string.Format("{0} status: {1} ({2}) Message: {3}{4}", request.GetName(), webx.StatusCode,
webx.StatusDescription, webx.ErrorMessage, errorCode);
throw new BaseSpaceException(msg, webx.ErrorCode, webx);
}
catch (Exception x)
{
throw new BaseSpaceException(request.GetName() + " failed", string.Empty, x);
}
}
/// <summary>
/// 服务器响应微信请求
/// </summary>
/// <param name="weixin"></param>
/// <returns></returns>
private ActionResult ResponseMsg(string weixin)
{
// 尝试读取消息.
AbstractRequest requestMessage = messageReader.ReadMessage(weixin);
if (logger.IsDebugEnabled)
{
logger.DebugFormat("尝试读取消息, 读取结果: {0}", requestMessage);
}
if (requestMessage == null)
{
logger.Warn("无法识别的消息！");
// 无法识别的消息.
return(Content(""));
}
// 消息处理管理器.
ProcessServerManager manager = ProcessServerManager.Instance();
// 处理具体请求.
AbstractResponse response = manager.ProcessRequest(requestMessage);
if (logger.IsDebugEnabled)
{
logger.DebugFormat("尝试处理消息, 处理结果: {0}", response);
}
if (response != null)
{
// 处理成功.
string xmlData = response.ToXml();
if (logger.IsDebugEnabled)
{
logger.DebugFormat("提交反馈的 XML 消息: {0}", xmlData);
}
return(Content(xmlData, "text/xml", Encoding.UTF8));
}
logger.WarnFormat("存在有消息，没有进行处理：{0}", weixin);
return(Content(""));
}
/// <summary>
/// send the request
/// </summary>
/// <typeparam name="T">the response the request return</typeparam>
/// <param name="httpRequest">the request you want to send</param>
/// <returns></returns>
public T SendRequest <T>(AbstractRequest <T> httpRequest) where T : BaseResponse
{
auth.GetTokenAndProjectId(out string projectId, out string authToken);
AddCommonHeaders(httpRequest, authToken, projectId);
httpRequest.SmnConfiguration = smnConfiguration;
httpRequest.ClientConfiguration = clientConfiguration;
httpRequest.ProjectId = projectId;
HttpWebResponse response = HttpTool.GetHttpResponse(httpRequest, this.clientConfiguration);
if (HttpTool.IsNoPermission(response))
{
// if no permission to clear the cache
CleanToken();
}
return(httpRequest.GetResponse(response));
}
/// <summary>
/// Gets the transaction builder for Authorization and Authorizatin and Capture operations.
/// See <see cref="TransactionType"/>.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="transactionType">Type of the transaction.</param>
/// <returns><see cref="AbstractTransactionBuilder"/> instance for build <see cref="Transaction"/> objects.</returns>
/// <exception cref="System.NotImplementedException">Occurs when PaymentMethodMain is not CREDIT_CARD neither
/// CASH neither REFERENCED.</exception>
/// <exception cref="System.NotSupportedException">Occurs when TransactionType is not AUTHORIZATION neither
/// AUTHORIZATION_AND_CAPTURE.</exception>
public static AbstractTransactionBuilder GetTransactionBuilder(AbstractRequest request,
TransactionType transactionType)
{
string value;
if (DataConverter.TryGetValue(request.InternalParameters, PayUParameterName.PAYMENT_METHOD, out value))
{
return(GetTransactionBuilderWithPaymentMethod(request, transactionType));
}
if (DataConverter.TryGetValue(request.InternalParameters, PayUParameterName.TOKEN_ID, out value))
{
return(GetTransactionBuilderWithToken(request, transactionType));
}
throw new ArgumentNullException(string.Format(PayUSdkMessages.RequiredParameter, "PAYMENT_METHOD | TOKEN_ID"));
}
private AbstractResponse GetKeyResponse(string key, AbstractRequest request)
{
AbstractResponse abstractResponse;
IList <Hidistro.Entities.VShop.ReplyInfo> replies = ReplyHelper.GetReplies(ReplyType.Vote);
if (replies != null && replies.Count > 0)
{
using (IEnumerator <Hidistro.Entities.VShop.ReplyInfo> enumerator = replies.GetEnumerator())
{
while (enumerator.MoveNext())
{
Hidistro.Entities.VShop.ReplyInfo current = enumerator.Current;
if (current.Keys != key)
{
continue;
}
VoteInfo voteById = StoreHelper.GetVoteById((long)current.ActivityId);
if (voteById == null || !voteById.IsBackup)
{
continue;
}
NewsResponse newsResponse = new NewsResponse()
{
CreateTime = DateTime.Now,
FromUserName = request.ToUserName,
ToUserName = request.FromUserName,
Articles = new List <Article>()
};
IList <Article> articles = newsResponse.Articles;
Article article = new Article()
{
Description = voteById.VoteName,
PicUrl = this.FormatImgUrl(voteById.ImageUrl),
Title = voteById.VoteName,
Url = string.Format("http://{0}/vshop/Vote.aspx?voteId={1}", HttpContext.Current.Request.Url.Host, voteById.VoteId)
};
articles.Add(article);
abstractResponse = newsResponse;
return(abstractResponse);
}
return(null);
}
return(abstractResponse);
}
return(null);
}
/// <summary>
/// 处理请求.
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public AbstractResponse ProcessRequest(AbstractRequest req)
{
T1 t1 = (T1)req;
T2 result = DoProcessRequest(t1);
// 接收方帐号（收到的OpenID）
result.ToUserName = t1.FromUserName;
// 开发者微信号
result.FromUserName = t1.ToUserName;
return(result);
}
public override AbstractResponse DefaultResponse(AbstractRequest requestMessage)
{
WeiXinHelper.UpdateRencentOpenID(requestMessage.FromUserName);
Hidistro.Entities.VShop.ReplyInfo mismatchReply = ReplyHelper.GetMismatchReply();
if (mismatchReply == null || this.IsOpenManyService())
{
return(this.GotoManyCustomerService(requestMessage));
}
AbstractResponse response = this.GetResponse(mismatchReply, requestMessage.FromUserName);
if (response == null)
{
return(this.GotoManyCustomerService(requestMessage));
}
response.ToUserName = requestMessage.FromUserName;
response.FromUserName = requestMessage.ToUserName;
return(response);
}
public ActAbstract ParseCommand(byte[] bytes, Socket socket)
{
var command = AbstractRequest.ToObject(bytes);
ActAbstract act = null;
if (command is CreateGameRequest)
{
act = new ActCreateGame(command as CreateGameRequest, gameService, sender);
}
else if (command is GameListRequest)
{
act = new ActGamesList(command as GameListRequest, gameService, sender);
}
else if (command is JoinGameRequest)
{
act = new ActJoinGame(command as JoinGameRequest, gameService, sender);
}
else if (command is LoginRequest)
{
act = new ActLogin(command as LoginRequest, socket, loginService, sender);
}
else if (command is MoveObjectRequest)
{
act = new ActMoveObject(command as MoveObjectRequest, gameService, sender);
}
else if (command is SendMazeRequest)
{
act = new ActSendMaze(command as SendMazeRequest, gameService, sender);
}
else if (command is SendStartPositionRequest)
{
act = new ActSendStartPoint(command as SendStartPositionRequest, gameService, sender);
}
else if (command is UserCountRequest)
{
act = new ActUserCount(command as UserCountRequest, sender);
}
return(act);
}
private void SendRequest(AbstractRequest request)
{
lock (this)
{
var conn = GetOrMakeConnection();
try
{
conn.Write(request);
}
catch (KafkaConnectionException)
{
Disconnect();
throw;
}
if (Config.ReconnectTimeInterval >= 0 && (DateTime.Now - lastConnectionTime).TotalMilliseconds >= Config.ReconnectTimeInterval)
{
Disconnect();
Connect();
lastConnectionTime = DateTime.Now;
}
}
}
public override AbstractResponse DefaultResponse(AbstractRequest requestMessage)
{
IDictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary.Add("CreateTime", requestMessage.CreateTime.ToNullString());
dictionary.Add("FromUserName", requestMessage.FromUserName.ToNullString());
dictionary.Add("MsgId", requestMessage.MsgId.ToNullString());
dictionary.Add("MsgType", requestMessage.MsgType.ToNullString());
ReplyInfo mismatchReply = ReplyHelper.GetMismatchReply();
if (mismatchReply == null || this.IsOpenManyService())
{
return(this.GotoManyCustomerService(requestMessage));
}
AbstractResponse response = this.GetResponse(mismatchReply, requestMessage.FromUserName, null);
if (response == null)
{
return(this.GotoManyCustomerService(requestMessage));
}
response.ToUserName = requestMessage.FromUserName;
response.FromUserName = requestMessage.ToUserName;
return(response);
}
public string send(AbstractRequest request)
{
string data = JsonConvert.SerializeObject(request);
string fullEndpoint = this.mainEndpoint + request.getEndpoint();
var nullJsonCheck = data.ToString().Replace("{", "").Replace("}", "").Trim();
var signiture = this.sign(fullEndpoint, String.IsNullOrEmpty(nullJsonCheck) ? null:data);
var httpWebRequest = (HttpWebRequest)WebRequest.Create(fullEndpoint);
httpWebRequest.Accept = "application/json";
httpWebRequest.Headers["X-Token"] = token;
httpWebRequest.Headers["X-Signature"] = signiture;
if (!String.IsNullOrEmpty(nullJsonCheck))
{
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
streamWriter.Write(data);
streamWriter.Flush();
streamWriter.Close();
}
}
else
{
httpWebRequest.Method = "GET";
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
return(streamReader.ReadToEnd());
}
}
public WebRequest RequestWithVkRequest(AbstractRequest vkRequest)
{
WebRequest request = null;
VKParameters preparedParameters = vkRequest.GetPreparedParameters();
var urlstringBuilder = new StringBuilder();
urlstringBuilder.AppendFormat("http{0}://api.vk.com/method/{1}", vkRequest.secure ? "s" : "",
vkRequest.methodName);
switch (vkRequest.httpMethod)
{
case AbstractRequest.HttpMethod.GET:
if (preparedParameters.Count > 0)
{
urlstringBuilder.Append("?").Append(VKstringJoiner.joinUriParams(preparedParameters));
}
request = _creator.Create(urlstringBuilder.ToString());
break;
case AbstractRequest.HttpMethod.POST:
request = _creator.Create(urlstringBuilder.ToString());
request.Method = "POST";
var pairs = new Dictionary<string, object>(preparedParameters.Count);
foreach (var entry in preparedParameters)
{
object value = entry.Value;
if (value is Collection<object>)
{
var values = (List<object>)value;
foreach (object v in values)
{
// This will add a parameter for each value in the Collection/List
pairs.Add(string.Format("{0}[]", entry.Key), v == null ? null : Convert.ToString(v));
}
}
else
{
pairs.Add(entry.Key, value == null ? null : Convert.ToString(value));
}
}
var boundary = "-----------------------------28520690214962";
var newLine = Environment.NewLine;
var propFormat = boundary + newLine +
"Content-Disposition: form-data; name=\"{0}\"" + newLine + newLine +
"{1}" + newLine + newLine;
using (var reqStream = request.GetRequestStream())
{
var reqWriter = new StreamWriter(reqStream);
StringBuilder bilBuilder = new StringBuilder();
foreach (var pair in pairs)
{
bilBuilder.AppendFormat(propFormat, pair.Key, pair.Value);
}
reqWriter.Write(bilBuilder.ToString());
reqWriter.Write(boundary + "--");
reqWriter.Flush();
}
break;
}
Dictionary<string, string> defaultHeaders = GetDefaultHeaders();
foreach (var key in defaultHeaders)
{
request.Headers.Add(key.Key, key.Value);
}
return request;
}
public AbstractResponse Send(AbstractRequest message)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Process and respond to a token request using HttpListenerRequest and HttpListenerResponse objects.
/// </summary>
/// <param name="request">Request to process.</param>
/// <param name="response">Response object to respond with.</param>
/// <param name="mode">Token request mode.</param>
/// <param name="store">Token storage object.</param>
public static void HandleTokenRequest(HttpListenerRequest request, HttpListenerResponse response, ServerRequestMode mode, IServerTokenStore store)
{
AbstractRequest arequest = new AbstractRequest(request);
AbstractResponse aresponse = new AbstractResponse(response);
HandleHttpTokenRequest(arequest, aresponse, mode, store);
}
/// <summary>
/// Abstract method to handle token requests.
/// </summary>
/// <param name="request">Abstracted HTTP request object.</param>
/// <param name="response">Abstracted HTTP response object.</param>
/// <param name="mode">Token request mode.</param>
/// <param name="store">Token storage provider.</param>
static void HandleHttpTokenRequest(AbstractRequest request, AbstractResponse response, ServerRequestMode mode, IServerTokenStore store)
{
StreamWriter sw = new StreamWriter(response.OutputStream);
NameValueCollection nvc = null;
nvc = DecodeRequest(request);
if (nvc == null)
{
response.StatusCode = 400;
sw.Write("Unsupported HTTP request method");
sw.Dispose();
return;
}
TokenProcessingResult result = HandleTokenRequest(mode, request.Url, request.HttpMethod, nvc, store);
if (!result.Success)
{
switch (result.FailGenericCondition)
{
case FailureGenericType.BadRequest:
response.StatusCode = 400;
break;
case FailureGenericType.Unauthorized:
response.StatusCode = 401;
break;
}
sw.Write(result.FailReason);
sw.Dispose();
return;
}
sw.Write(OAuthUtility.ArgsToVal(result.ResponseArguments, AuthenticationMethod.Post));
sw.Dispose();
}
/// <summary>
/// Given an abstracted HTTP request object, extract all OAuth parameters and return the arguments.
/// </summary>
/// <param name="request">The abstracted HTTP request object.</param>
/// <returns>A populated collection of OAuth parameters in the request.</returns>
static NameValueCollection DecodeRequest(AbstractRequest request)
{
NameValueCollection nvc = new NameValueCollection();
if (request.Headers["Authorization"] != null
&& request.Headers["Authorization"].StartsWith("OAuth", StringComparison.Ordinal))
{
string arguments = request.Headers["Authorization"];
string a = arguments.Substring(arguments.IndexOf("OAuth ", StringComparison.Ordinal) + 5);
string[] args = a.Split(',');
foreach (string s in args)
{
string[] keyval = s.Trim().Split('=');
if (keyval.Length == 2)
{
nvc[keyval[0]] = HttpUtility.UrlDecode(keyval[1]).Trim('\"');
}
}
}
nvc.Add(request.QueryString);
nvc.Add(request.Form);
if (nvc.Keys.Count == 0) return null;
return nvc;
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractPersonBuilder{T}"/> class.
/// </summary>
/// <param name="request">The request.</param>
public AbstractPersonBuilder(AbstractRequest request)
{
this.request = request;
}
/// <summary>
/// Initializes a new instance of the <see cref="CreditCardTokenBuilder"/> class.
/// </summary>
/// <param name="request">The request.</param>
public CreditCardTokenBuilder(AbstractRequest request)
{
this.request = request;
this.creditCardToken = new CreditCardToken();
}
/// <summary>
/// Authenticate a user HTTP Request.
/// </summary>
/// <param name="request">HttpRequest to authenticate.</param>
/// <param name="store">Token storage object to use.</param>
/// <returns>If valid, returns the matching ServerAccessToken. If not valid, returns null.</returns>
public static ServerAccessToken AuthenticateUser(HttpListenerRequest request, IServerTokenStore store)
{
AbstractRequest arequest = new AbstractRequest(request);
NameValueCollection nvc = DecodeRequest(arequest);
if (nvc == null) return null;
return AuthenticateUser(arequest.Url, arequest.HttpMethod, nvc, store);
}
public abstract AbstractResponse DefaultResponse(AbstractRequest requestMessage);
/**
* Called when request has failed attempt, and ready to do next attempt
*
* @param request Failed request
* @param attemptNumber Number of failed attempt, started from 1
* @param totalAttempts Total request attempts defined for request
*/
public void attemptFailed(AbstractRequest request, int attemptNumber, int totalAttempts)
{
}
