public HttpResponseMessage Login(HttpRequestMessage requestMsg)
{
var request = new HttpContextWrapper(HttpContext.Current).Request;
if (request.Form["username"] == null || request.Form["password"] == null)
{
return requestMsg.CreateErrorResponse(
HttpStatusCode.BadRequest,
new ArgumentException("Unable to find username or password.")
);
}
var loginDictionnary = this.AuthService.Login(
request.Form["username"],
request.Form["password"]
);
if (loginDictionnary != null)
{
return requestMsg.CreateResponse(
HttpStatusCode.OK,
loginDictionnary
);
}
return requestMsg.CreateErrorResponse(
HttpStatusCode.Forbidden,
"Wrong credentials"
);
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
const string TOKEN_NAME = "X-Token";
if (request.Headers.Contains(TOKEN_NAME))
{
string encryptedToken = request.Headers.GetValues(TOKEN_NAME).First();
try
{
Token token = Token.Decrypt(encryptedToken);
bool isValidUserId = identityStore.IsValidUserId(token.UserId);
bool requestIPMatchesTokenIP = token.IP.Equals(request.GetClientIP());
if (!isValidUserId || !requestIPMatchesTokenIP)
{
HttpResponseMessage reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid indentity or client machine.");
return Task.FromResult(reply);
}
}
catch (Exception ex)
{
HttpResponseMessage reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid token.");
return Task.FromResult(reply);
}
}
else
{
HttpResponseMessage reply = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Request is missing authorization token.");
return Task.FromResult(reply);
}
return base.SendAsync(request, cancellationToken);
}
protected virtual string ProcessVersionHeader(HttpRequestMessage request, string odataPath)
{
var apiVersion = request.Headers.Where(kv => kv.Key.Equals(VersionMap.VersionHeaderName, StringComparison.InvariantCultureIgnoreCase)).SelectMany(kv => kv.Value).FirstOrDefault();
int version = -1;
if (string.IsNullOrWhiteSpace(apiVersion))
{
version = VersionMap.CurrentVersion;
}
else if (!int.TryParse(apiVersion, out version))
{
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid Api Version specified: " + apiVersion));
}
if (version < VersionMap.MinVersion || version > VersionMap.CurrentVersion) goto UnsupportedVersion;
var endpoint = odataPath;
var targetEndpoint = VersionMap.GetEndpointName(version, endpoint);
if (targetEndpoint == null) goto UnsupportedVersion;
return targetEndpoint;
UnsupportedVersion:
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotAcceptable, string.Format("Unsupported Api Version specified: {0}. Current version: {1}", version, VersionMap.CurrentVersion)));
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
HttpRequestMessage proxiedRequest = null;
try
{
var hostDetails = await apiSettingsData.GetAsync(request.RequestUri);
if (hostDetails == null)
{
return request.CreateErrorResponse(HttpStatusCode.NotFound, string.Format("Host '{0}' not recognised as a valid chaos api", request.RequestUri.Host));
}
var apiToForwardToHostName = hostDetails.ForwardApiHostName;
proxiedRequest = CreateNewRequestToProxiedApi(request, hostDetails, apiToForwardToHostName);
var client = await CreateHttpClientForProxiedRequest(apiToForwardToHostName);
return await client.SendAsync(proxiedRequest, cancellationToken);
}
catch (TaskCanceledException)
{
return cancellationToken.IsCancellationRequested
? request.CreateErrorResponse(HttpStatusCode.RequestTimeout, string.Format("Request forward to '{0}' failed, request timed out", proxiedRequest.RequestUri))
: request.CreateErrorResponse(HttpStatusCode.InternalServerError, string.Format("Request forward to '{0}' failed, ", proxiedRequest.RequestUri));
}
catch (Exception ex)
{
return request.CreateErrorResponse(HttpStatusCode.InternalServerError, string.Format("Request forward to '{0}' failed, {1}", proxiedRequest.RequestUri, ex));
}
}
public static HttpResponseMessage CreateErrorResponse(Exception throwException, HttpRequestMessage request)
{
// Here are some examples of how certain exceptions can be mapped to error responses.
if (throwException is System.ComponentModel.DataAnnotations.ValidationException)
{
// Return when the supplied model (command or query) isn't valid.
return request.CreateResponse<ValidationResult>(HttpStatusCode.BadRequest,
((ValidationException)throwException).ValidationResult);
}
if (throwException is OptimisticConcurrencyException)
{
// Return when there was a concurrency conflict in updating the model.
return request.CreateErrorResponse(HttpStatusCode.Conflict, throwException);
}
if (throwException is BusinessLayer.CrossCuttingConcerns.AuthorizationException)
{
// Return when the current user doesn't have the proper rights to execute the requested operation
// or to access the requested resource.
return request.CreateErrorResponse(HttpStatusCode.Unauthorized, throwException);
}
if (throwException is System.Collections.Generic.KeyNotFoundException)
{
// Return when the requested resource does not exist anymore. Catching a KeyNotFoundException
// is an example, but you probably shouldn't throw KeyNotFoundException in this case, since it
// could be thrown for other reasons (such as program errors) in which case this branch should
// of course not execute.
return request.CreateErrorResponse(HttpStatusCode.NotFound, throwException);
}
// If the throwException can't be handled: return null.
return null;
}
public override HttpControllerDescriptor SelectController(HttpRequestMessage request)
{
Type type;
if (request == null)
{
throw new ArgumentNullException("request");
}
string controllerName = this.GetControllerName(request);
if (string.IsNullOrEmpty(controllerName))
{
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound,
string.Format("No route providing a controller name was found to match request URI '{0}'",
new object[] { request.RequestUri })));
}
IEnumerable<string> fullNames = GetControllerFullName(request, controllerName);
if (fullNames.Count() == 0)
{
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound,
string.Format("No route providing a controller name was found to match request URI '{0}'",
new object[] { request.RequestUri })));
}
if (this._apiControllerCache.Value.TryGetValue(fullNames.First(), out type))
{
return new HttpControllerDescriptor(_configuration, controllerName, type);
}
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound,
string.Format("No route providing a controller name was found to match request URI '{0}'",
new object[] { request.RequestUri })));
}
private HttpResponseMessage Response(HttpRequestMessage request)
{
const string defaultPageName = "index.html";
var path = request.RequestUri.AbsolutePath;
var suffix = path == string.Empty ? defaultPageName : path.Substring(1);
var fullPath = Path.Combine(m_BaseFolder, suffix);
if (!File.Exists(fullPath))
{
return request.CreateErrorResponse(
HttpStatusCode.NotFound,
string.Format("Sorry about that, but there is no file named '{0}' here.", suffix));
}
string extension = Path.GetExtension(path);
FileType fileType;
if (!m_FileTypes.TryGetValue(extension, out fileType))
{
return request.CreateErrorResponse(
HttpStatusCode.UnsupportedMediaType,
string.Format("Sorry I can not process files like '{0}'.", extension));
}
var response = request.CreateResponse();
var fileStream = new FileStream(fullPath, FileMode.Open);
response.Content = new StreamContent(fileStream);
response.Content.Headers.ContentType = fileType.ContentType;
return response;
}
/// <summary>
/// 以异步操作发送 HTTP 请求到内部管理器以发送到服务器。
/// </summary>
/// <returns>
/// 返回 <see cref="T:System.Threading.Tasks.Task`1"/>。 表示异步操作的任务对象。
/// </returns>
/// <param name="request">要发送到服务器的 HTTP 请求消息。</param>
/// <param name="cancellationToken">取消操作的取消标记。</param>
/// <exception cref="T:System.ArgumentNullException"> <paramref name="request"/> 为 null。</exception>
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var result = EncryptRequest(request);
if (result != null)
{
return result;
}
return base.SendAsync(request, cancellationToken)
.ContinueWith(task =>
{
if (task.IsFaulted)
{
var aggregateException = task.Exception;
if (aggregateException != null)
{
var requestException = aggregateException.InnerExceptions.FirstOrDefault(m => m is HttpRequestException);
if (requestException != null && requestException.InnerException is WebException)
{
return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, requestException.InnerException);
}
}
return request.CreateErrorResponse(HttpStatusCode.ExpectationFailed, task.Exception);
}
return DecryptResponse(task.Result);
}, cancellationToken);
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
IEnumerable<string> userNameHeaderValues = null;
if (request.Headers.TryGetValues(KawalDesaHeaders.X_KD_USERID, out userNameHeaderValues))
{
if (!IsValidEmissRequest(request))
{
var response = request.CreateErrorResponse(HttpStatusCode.BadRequest, "Not a Valid Request");
return Task.FromResult<HttpResponseMessage>(response);
}
IEnumerable<String> expireHeaderValues = null;
if (request.Headers.TryGetValues(KawalDesaHeaders.X_KD_EXPIRES, out expireHeaderValues))
{
if (IsExpiredRequest(expireHeaderValues.FirstOrDefault()))
{
var response = request.CreateErrorResponse(HttpStatusCode.BadRequest, "Your Request Has Expired");
return Task.FromResult<HttpResponseMessage>(response);
}
}
var userName = userNameHeaderValues.First();
var userManager = new UserManager<User>(new CUserStore<User>(new DB()));
var user = userManager.FindByName(userName);
if (user != null)
{
string signature = CryptographyHelper.Sign(request, user.SecretKey);
if (signature.Equals(request.Headers.GetValues(KawalDesaHeaders.X_KD_SIGNATURE).FirstOrDefault()))
{
var identity = new KawalDesaIdentity(user, "Emiss");
var principal = new GenericPrincipal(identity, userManager.GetRoles(user.Id).ToArray());
Thread.CurrentPrincipal = principal;
if (HttpContext.Current != null)
{
HttpContext.Current.User = principal;
}
}
}
}
else if (HttpContext.Current.Session != null && !String.IsNullOrEmpty((string)HttpContext.Current.Session[KawalDesaController.USERID_KEY]))
{
var session = HttpContext.Current.Session;
var userManager = new UserManager<User>(new CUserStore<User>(new DB()));
var user = userManager.FindById((string)session[KawalDesaController.USERID_KEY]);
if (user != null)
{
var identity = new KawalDesaIdentity(user, "Session");
var principal = new GenericPrincipal(identity, userManager.GetRoles(user.Id).ToArray());
Thread.CurrentPrincipal = principal;
if (HttpContext.Current != null)
{
HttpContext.Current.User = principal;
}
}
}
return base.SendAsync(request, cancellationToken);
}
/// <inheritdoc />
public override async Task<HttpResponseMessage> ReceiveAsync(string receiver, HttpRequestContext context, HttpRequestMessage request)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
if (request.Method == HttpMethod.Post)
{
EnsureSecureConnection(request);
// Read the request entity body
NameValueCollection data = await ReadAsFormDataAsync(request);
// Verify that the token is correct
string token = data[TokenParameter];
string secretKey = GetWebHookSecret(request, SecretKey, 8, 64);
if (!WebHookReceiver.SecretEqual(token, secretKey))
{
string msg = string.Format(CultureInfo.CurrentCulture, SlackReceiverResources.Receiver_BadToken, TokenParameter);
context.Configuration.DependencyResolver.GetLogger().Error(msg);
HttpResponseMessage invalidCode = request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
return invalidCode;
}
// Get the action
string action = data[ActionParameter];
if (string.IsNullOrEmpty(action))
{
string msg = string.Format(CultureInfo.CurrentCulture, SlackReceiverResources.Receiver_BadBody, ActionParameter);
context.Configuration.DependencyResolver.GetLogger().Error(msg);
HttpResponseMessage badType = request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
return badType;
}
// Get the subtext by removing the trigger word
string text = data[TextParameter];
data[SubtextParameter] = GetSubtext(action, text);
// Call registered handlers
return await ExecuteWebHookAsync(receiver, context, request, new string[] { action }, data);
}
else
{
return CreateBadMethodResponse(request);
}
}
/// <inheritdoc />
public override async Task<HttpResponseMessage> ReceiveAsync(string id, HttpRequestContext context, HttpRequestMessage request)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (request == null)
{
throw new ArgumentNullException("request");
}
if (request.Method == HttpMethod.Post)
{
// Ensure that we use https and have a valid code parameter
await EnsureValidCode(request, id);
// Read the request entity body.
JObject data = await ReadAsJsonAsync(request);
// Pick out action from headers
IEnumerable<string> actions;
if (!request.Headers.TryGetValues(EventHeaderKey, out actions))
{
string msg = string.Format(CultureInfo.CurrentCulture, BitbucketReceiverResources.Receiver_NoEvent, EventHeaderKey);
context.Configuration.DependencyResolver.GetLogger().Error(msg);
HttpResponseMessage noEventHeader = request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
return noEventHeader;
}
// Get the WebHook ID
IEnumerable<string> webHookId;
if (!request.Headers.TryGetValues(UUIDHeaderName, out webHookId))
{
string msg = string.Format(CultureInfo.CurrentCulture, BitbucketReceiverResources.Receiver_NoId, UUIDHeaderName);
context.Configuration.DependencyResolver.GetLogger().Error(msg);
HttpResponseMessage noWebHookIdHeader = request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
return noWebHookIdHeader;
}
// Set the WebHook ID in the payload
data[WebHookIdKey] = webHookId.FirstOrDefault();
// Call registered handlers
return await ExecuteWebHookAsync(id, context, request, actions, data);
}
else
{
return CreateBadMethodResponse(request);
}
}
public static HttpResponseMessage Process(HttpRequestMessage request)
{
// Check if the request contains multipart/form-data.
if (!request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
try
{
Stream reqStream = request.Content.ReadAsStreamAsync().Result;
MemoryStream tempStream = new MemoryStream();
reqStream.CopyTo(tempStream);
tempStream.Seek(0, SeekOrigin.End);
Log.Submit(LogLevel.Debug, "Upload request has " + tempStream.Length + " bytes");
tempStream.Position = 0;
StreamContent streamContent = new StreamContent(tempStream);
foreach (KeyValuePair<string, IEnumerable<string>> header in request.Content.Headers)
{
streamContent.Headers.Add(header.Key, header.Value);
Log.Submit(LogLevel.Debug, "Header " + header.Key + ": " + string.Join(",", header.Value));
}
MultipartFormDataParser parser = new MultipartFormDataParser(tempStream);
// This illustrates how to get the file names.
FilePart file = parser.Files.FirstOrDefault();
if (parser.Files == null || parser.Files.Count != 1)
throw new InvalidOperationException();
if (file == null || file.FileName != "package")
throw new InvalidOperationException();
PackageDAO.ProcessPackage(file.Data);
return request.CreateResponse(HttpStatusCode.Created);
}
catch (AlreadyExistsException e)
{
Log.SubmitException(e);
return request.CreateErrorResponse(HttpStatusCode.Conflict, e);
}
catch (InvalidOperationException e)
{
Log.SubmitException(e);
return request.CreateErrorResponse(HttpStatusCode.BadRequest, e);
}
catch (Exception e)
{
Log.SubmitException(e);
return request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
}
public HttpResponseMessage GetContactCompany(HttpRequestMessage request, int id)
{
var result = this.ContactDao.GetById(id);
if (result == null) {
return request.CreateErrorResponse(HttpStatusCode.NotFound, "Contact not found.");
}
return result.Company != null
? request.CreateResponse(HttpStatusCode.OK, result.Company)
: request.CreateErrorResponse(HttpStatusCode.NotFound, "This contact has no company");
}
public HttpResponseMessage Post(HttpRequestMessage request, Order order)
{
if (!order.Items.Any())
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Order has no items");
if(_orderService.Exists(order.Id))
return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Order already exists");
_orderService.Save(order);
var response = request.CreateResponse(HttpStatusCode.Created);
response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = order.Id }));
return response;
}
public HttpResponseMessage AddCategory(HttpRequestMessage req, RP_AddCategory rpAddCategory)
{
if (rpAddCategory != null)
{
RM_AddCategory rmAddCategory = new RM_AddCategory();
List<RPR_AddCategory> rprAddCategory = rmAddCategory.AddCategory(rpAddCategory);
if (rmAddCategory._IsSuccess)
return req.CreateResponse<List<RPR_AddCategory>>(HttpStatusCode.Created, rprAddCategory);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
public HttpResponseMessage AddHappyHours(HttpRequestMessage req, Rp_AddHappyHours rpAddHappyHours)
{
if (rpAddHappyHours != null)
{
RM_AddHappyHours rmAddHappyHours = new RM_AddHappyHours();
List<RPR_AddHappyHours> rprAddHappyHours = rmAddHappyHours.AddHappyHours(rpAddHappyHours);
if (rmAddHappyHours._IsSuccess)
return req.CreateResponse<List<RPR_AddHappyHours>>(HttpStatusCode.Created, rprAddHappyHours);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
public HttpResponseMessage ChangeOrderStatus(HttpRequestMessage req, RP_ChangeOrderStatus rpChangeOrderStatus)
{
if (rpChangeOrderStatus != null)
{
RM_ChangeOrderStatus rmChangeOrderStatus = new RM_ChangeOrderStatus();
List<RPR_ChangeOrderStatus> rprChangeOrderStatus = rmChangeOrderStatus.ChangeOrderStatus(rpChangeOrderStatus);
if (rmChangeOrderStatus._IsSuccess)
return req.CreateResponse<List<RPR_ChangeOrderStatus>>(HttpStatusCode.Created, rprChangeOrderStatus);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
protected IHttpActionResult ConsumeExceptionFromStore(HttpRequestMessage req, AggregateException ex)
{
if (req!=null && ex !=null) {
HttpStatusCode code = HttpStatusCode.InternalServerError;
if (ex.InnerException is IOException) {
code = HttpStatusCode.InternalServerError;
}
else if (ex.InnerException is ArgumentException) {
code = HttpStatusCode.BadRequest;
}
return ResponseMessage(req.CreateErrorResponse(code, ex.InnerException.Message));
}
return ResponseMessage(req.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unexpected error while consuming the exception from the store"));
}
public HttpResponseMessage CancelOrder(HttpRequestMessage req, RP_CancelOrder rpCancelOrder)
{
if (rpCancelOrder != null)
{
RM_CancelOrder rmCancelOrder = new RM_CancelOrder();
List<RPR_CancelOrder> rprCancelOrder = rmCancelOrder.CancelOrder(rpCancelOrder);
if (rmCancelOrder._IsSuccess)
return req.CreateResponse<List<RPR_CancelOrder>>(HttpStatusCode.Created, rprCancelOrder);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
public HttpResponseMessage AllowToJoinTable(HttpRequestMessage req, RP_AllowToJoinTable rpAllowToJoinTable)
{
if (rpAllowToJoinTable != null)
{
RM_AllowToJoinTable rmAllowToJoinTable = new RM_AllowToJoinTable();
List<RPR_AllowToJoinTable> rprAllowToJoinTable = rmAllowToJoinTable.AllowToJoinTable(rpAllowToJoinTable);
if (rmAllowToJoinTable._IsSuccess)
return req.CreateResponse<List<RPR_AllowToJoinTable>>(HttpStatusCode.Created, rprAllowToJoinTable);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
public HttpResponseMessage AddedToCart(HttpRequestMessage req, RP_AddedToCart rpAddedToCart)
{
if (rpAddedToCart != null)
{
RM_AddedToCart rmAddedToCart = new RM_AddedToCart();
List<RPR_AddedToCart> rprAddedToCart = rmAddedToCart.AddedToCart(rpAddedToCart);
if (rmAddedToCart._IsSuccess)
return req.CreateResponse<List<RPR_AddedToCart>>(HttpStatusCode.Created, rprAddedToCart);
return req.CreateErrorResponse(HttpStatusCode.InternalServerError, "ServerError");
}
return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Bad Request");
}
public HttpControllerDescriptor SelectController(HttpRequestMessage request)
{
var routeData = request.GetRouteData();
var module = request.FindModuleInfo();
// Handle the app-api queries
if (routeData.Route.RouteTemplate.Contains("DesktopModules/2sxc/API/app-api/") && module.DesktopModule.ModuleName == "2sxc-app")
{
var portalSettings = PortalSettings.Current;
var sexy = request.GetSxcOfModuleContext();
// previously we assumed that there is a sub-folder with a future-app-id, but 2015-05-15 decided it's probably not worth trying, because each request currently needs tokens anyhow
// if ((string) routeData.Values["appFolder"] != "auto-detect-app" && (string) routeData.Values["appFolder"] != sexy.App.Folder)
// throw new HttpException("AppFolder was not correct - was " + routeData.Values["appFolder"] + " but should be " + sexy.App.Folder);
var controllerTypeName = routeData.Values["controller"] + "Controller";
var controllerPath = Path.Combine(SexyContent.AppBasePath(portalSettings), sexy.App.Folder,
"Api/" + controllerTypeName + ".cs");
if (File.Exists(HostingEnvironment.MapPath(controllerPath)))
{
var assembly = BuildManager.GetCompiledAssembly(controllerPath);
var type = assembly.GetType(controllerTypeName);
return new HttpControllerDescriptor(_config, controllerTypeName, type);
}
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound, "Controller " + controllerTypeName + " not found in app."));
}
return PreviousSelector.SelectController(request);
}
public override string GetControllerName(System.Net.Http.HttpRequestMessage request)
{
string controllerName = base.GetControllerName(request);
int controllerVersion;
if (request.Headers.Contains("X-Version"))
{
string headerValue = request.Headers.GetValues("X-Version").First();
if (headerValue == "0")
{
return(controllerName);
}
if (!String.IsNullOrEmpty(headerValue) && Int32.TryParse(headerValue, out controllerVersion))
{
controllerName = String.Format("{0}v{1}", controllerName, controllerVersion);
HttpControllerDescriptor controllerDescr = null;
if (!this.GetControllerMapping().TryGetValue(controllerName, out controllerDescr))
{
string message = "No HTTP resource was found for specified request URI {0} and version {1}";
throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.NotFound, String.Format(message, request.RequestUri, controllerVersion)));
}
}
}
return(controllerName);
}
public async Task<HttpResponseMessage> Get(HttpRequestMessage request, [FromUri(Name = "objectContext")]string userId)
{
try
{
// Call the execution pipeline and get the result
IBackloadResult result = await _handler.Execute();
// Get the client plugin specific result
var clientResult = ((IFileStatusResult)result).ClientStatus;
// return result object and status code
return request.CreateResponse(result.HttpStatusCode, clientResult);
#region Optional: Use Backload Api (Services namespace. Pro/Enterprise only)
//// Simple demo: Call the GET execution method and get the result
//IFileStatus status = await _handler.Services.GET.Execute();
//// Create plugin specific result
//result = _handler.Services.Core.CreatePluginResult();
//// return plugin specific result object
//return request.CreateResponse(HttpStatusCode.OK, result.ClientStatus);
#endregion Optional: Use backload Api (Services namespace. Pro/Enterprise only)
}
catch(Exception e)
{
return request.CreateErrorResponse(HttpStatusCode.InternalServerError, e);
}
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// Lookup route data, or if not found as a request property then we look it up in the route table
IHttpRouteData routeData;
if (!request.Properties.TryGetValue(HttpPropertyKeys.HttpRouteDataKey, out routeData))
{
routeData = _configuration.Routes.GetRouteData(request);
if (routeData != null)
{
request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData);
}
else
{
request.Properties.Add(HttpPropertyKeys.NoRouteMatched, true);
return TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoRouteData));
}
}
RemoveOptionalRoutingParameters(routeData.Values);
// routeData.Route could be null if user adds a custom route that derives from System.Web.Routing.Route explicitly
// and add that to the RouteCollection in the web hosted case
var invoker = (routeData.Route == null || routeData.Route.Handler == null) ?
_defaultInvoker : new HttpMessageInvoker(routeData.Route.Handler, disposeHandler: false);
return invoker.SendAsync(request, cancellationToken);
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var setting = Its.Configuration.Settings.Get<Config.SwaggerToolSettings>();
//using refletions to internal
var swaggerProvider = (ISwaggerProvider)_config.GetType().GetMethod("GetSwaggerProvider", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(_config, new object[] { request });
var rootUrl = (string)_config.GetType().GetMethod("GetRootUrl", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).Invoke(_config, new object[] { request });
var q = request.GetRouteData().Values["q"].ToString();
var apiVersion = request.GetRouteData().Values["apiVersion"].ToString();
try
{
var swaggerDoc = swaggerProvider.GetSwagger(rootUrl, apiVersion);
//筛选条件为path包含q
IList<string> keytoremove = new List<string>();
foreach (var item in swaggerDoc.paths)
{
if (!item.Key.ToUpper().Contains(q.ToUpper()))
{
keytoremove.Add(item.Key);
}
}
foreach (var item in keytoremove)
{
swaggerDoc.paths.Remove(item);
}
var content = ContentFor(request, swaggerDoc);
return TaskFor(new HttpResponseMessage { Content = content });
}
catch (UnknownApiVersion ex)
{
return TaskFor(request.CreateErrorResponse(HttpStatusCode.NotFound, ex));
}
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
// Lookup route data, or if not found as a request property then we look it up in the route table
IHttpRouteData routeData;
if (!request.Properties.TryGetValue(HttpPropertyKeys.HttpRouteDataKey, out routeData))
{
routeData = _configuration.Routes.GetRouteData(request);
if (routeData != null)
{
request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, routeData);
}
else
{
return TaskHelpers.FromResult(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoRouteData));
}
}
RemoveOptionalRoutingParameters(routeData.Values);
var invoker = routeData.Route.Handler == null ? _defaultInvoker : new HttpMessageInvoker(routeData.Route.Handler, disposeHandler: false);
return invoker.SendAsync(request, cancellationToken);
}
private Task<HttpResponseMessage> GenerateUnauthorizedResponse(HttpRequestMessage request, CancellationToken cancellationToken)
{
var unauthorizedResponse = request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Unauthorized origin.");
var tsc = new TaskCompletionSource<HttpResponseMessage>();
tsc.SetResult(unauthorizedResponse);
return tsc.Task;
}
/// <summary>
/// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation.
/// </summary>
/// <param name="request">The HTTP request message to send to the server.</param>
/// <param name="cancellationToken">A cancellation token to cancel operation.</param>
/// <returns>
/// Returns <see cref="T:System.Threading.Tasks.Task`1" />. The task object representing the asynchronous operation.
/// </returns>
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var queryParams = HttpUtility.ParseQueryString(request.RequestUri.Query);
var acceptValue = queryParams.Get("accept");
if (acceptValue != null)
{
request.Headers.Accept.Clear();
request.Headers.Accept.ParseAdd(acceptValue);
}
var fieldsValue = queryParams.Get("fields");
if (fieldsValue != null)
{
}
var methodValue = queryParams.Get("method");
if (methodValue != null)
{
try
{
request.Method = ToMethod(methodValue);
}
catch (UnknownHttpMethodException ex)
{
return request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message);
}
}
return await base.SendAsync(request, cancellationToken);
}
protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
var resource = ((string)request.GetRouteData().Values["controller"]).ToLower();
var action = request.GetRouteData().Values.ContainsKey("action") ? ((string)request.GetRouteData().Values["action"]).ToLower() : null;
var method = request.Method.ToString().ToUpper();
var securityToken = GetToken(request);
try
{
_authenticationService.ValidateAccess(securityToken, resource, action, method);
}
catch (UnauthorizedException ex)
{
return request.CreateErrorResponse(HttpStatusCode.Unauthorized, ex.Message);
}
SaveContext(request, _authenticationService);
var response = await base.SendAsync(request, cancellationToken);
UpdateContext(request, _authenticationService);
securityToken = _authenticationService.CreateToken();
if (securityToken != null)
AddTokenToHeader(response, securityToken);
return response;
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
{
if(request.Headers.Any(a=>a.Key == MasterPasswordHeader))
{
var passwordHeader = request.Headers.First(a => a.Key == MasterPasswordHeader);
var passwordHash = passwordHeader.Value.FirstOrDefault();
if (passwordHash == ConfigurationManager.AppSettings[MasterPasswordHashAppConfigKey])
{
IPrincipal principal = new GenericPrincipal(
new GenericIdentity(Roles.Elevated),
new string[] { Roles.Elevated });
Thread.CurrentPrincipal = principal;
if (HttpContext.Current!=null)
{
HttpContext.Current.User = principal;
}
}
else
{
return Task.Factory.StartNew(() => request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Invalid password"));
}
}
return base.SendAsync(request, cancellationToken);
}
public HttpResponseMessage Get(string email, string senha)
{
var configuration = new HttpConfiguration();
var request = new System.Net.Http.HttpRequestMessage();
request.Properties[System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey] = configuration;
try
{
var usuario = _loginAppService.Login(email, senha);
return(request.CreateResponse(HttpStatusCode.OK, usuario));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public HttpControllerDescriptor SelectController(System.Net.Http.HttpRequestMessage request)
{
System.Web.Http.Routing.IHttpRouteData routeData = request.GetRouteData();
if (routeData == null)
{
throw new HttpResponseException(System.Net.HttpStatusCode.NotFound);
}
string version = GetRouteVariable <string>(routeData, VersionKey);
if (string.IsNullOrEmpty(version))
{
version = GetVersionFromHTTPHeaderAndAcceptHeader(request);
}
string controllerName = GetRouteVariable <string>(routeData, ControllerKey);
if (controllerName == null)
{
throw new HttpResponseException(System.Net.HttpStatusCode.NotFound);
}
string key = String.Format(CultureInfo.InvariantCulture, "{0}", controllerName);
if (!string.IsNullOrEmpty(version))
{
key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", version, controllerName);
}
HttpControllerDescriptor controllerDescriptor;
if (_controllers.Value.TryGetValue(key, out controllerDescriptor))
{
return(controllerDescriptor);
}
else if (_duplicates.Contains(key))
{
throw new HttpResponseException(
request.CreateErrorResponse(HttpStatusCode.InternalServerError,
"Multiple controllers were found that match this request."));
}
else
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
public HttpResponseMessage Post(UsuarioViewModel usuarioViewModel)
{
var configuration = new HttpConfiguration();
var request = new System.Net.Http.HttpRequestMessage();
request.Properties[System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey] = configuration;
try
{
var usuario = _usuarioAppService.Adicionar(usuarioViewModel);
var telefoneViewModel = new TelefoneViewModel();
foreach (var telefone in usuario.Telefones)
{
// Adicionando os dados do telefone
telefoneViewModel.Id = Guid.NewGuid();
telefoneViewModel.Numero = telefone.Numero;
telefoneViewModel.Ddd = telefone.Ddd;
telefoneViewModel.UsuarioId = usuario.Id;
// chamanda o serviço para adicionar o telefone
_telefoneAppService.AdicionarTelefone(telefoneViewModel);
// Adicionando dados do telefone para retorno
telefone.Id = telefoneViewModel.Id;
telefone.UsuarioId = telefoneViewModel.UsuarioId;
}
return(request.CreateResponse(HttpStatusCode.OK, usuario));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
public HttpResponseMessage Get(Guid id)
{
var configuration = new HttpConfiguration();
var request = new System.Net.Http.HttpRequestMessage();
request.Properties[System.Web.Http.Hosting.HttpPropertyKeys.HttpConfigurationKey] = configuration;
// Buscando o Header de Autorização
var authorization = Request.Headers.Authorization;
var token = authorization.ToString();
try
{
var usuario = _profilerAppService.ValidarToken(token, id);
return(request.CreateResponse(HttpStatusCode.OK, usuario));
}
catch (Exception e)
{
return(request.CreateErrorResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
/// <summary>
/// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
/// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> with message <paramref name="message"/>
/// and message detail <paramref name="messageDetail"/>.If no formatter is found, this method returns a response with
/// status 406 NotAcceptable.
/// </summary>
/// <remarks>
/// This method requires that <paramref name="request"/> has been associated with an instance of
/// <see cref="HttpConfiguration"/>.
/// </remarks>
/// <param name="request">The request.</param>
/// <param name="statusCode">The status code of the created response.</param>
/// <param name="message">The error message. This message will always be seen by clients.</param>
/// <param name="messageDetail">The error message detail. This message will only be seen by clients if we should include error detail.</param>
/// <returns>An error response with error message <paramref name="message"/> and message detail <paramref name="messageDetail"/>
/// and status code <paramref name="statusCode"/>.</returns>
internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail)
{
return(request.CreateErrorResponse(statusCode, includeErrorDetail => includeErrorDetail ? new HttpError(message, messageDetail) : new HttpError(message)));
}
/// <summary>
/// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
/// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> with message <paramref name="message"/>.
/// If no formatter is found, this method returns a response with status 406 NotAcceptable.
/// </summary>
/// <remarks>
/// This method requires that <paramref name="request"/> has been associated with an instance of
/// <see cref="HttpConfiguration"/>.
/// </remarks>
/// <param name="request">The request.</param>
/// <param name="statusCode">The status code of the created response.</param>
/// <param name="message">The error message.</param>
/// <returns>An error response with error message <paramref name="message"/> and status code <paramref name="statusCode"/>.</returns>
public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message)
{
return(request.CreateErrorResponse(statusCode, new HttpError(message)));
}
public void CreateErrorResponseRangeNotSatisfiable_ThrowsOnNullException()
{
HttpRequestMessage request = new HttpRequestMessage();
Assert.ThrowsArgumentNull(() => request.CreateErrorResponse(invalidByteRangeException: null), "invalidByteRangeException");
}
