public ApiControllerExtensionsTests()
        {
            HttpConfiguration config = new HttpConfiguration();
            IWebHookUser user = new WebHookUser();

            _managerMock = new Mock<IWebHookManager>();
            _resolverMock = new Mock<IDependencyResolver>();
            _resolverMock.Setup(r => r.GetService(typeof(IWebHookManager)))
                .Returns(_managerMock.Object)
                .Verifiable();
            _resolverMock.Setup(r => r.GetService(typeof(IWebHookUser)))
                .Returns(user)
                .Verifiable();

            config.DependencyResolver = _resolverMock.Object;

            ClaimsIdentity identity = new ClaimsIdentity();
            Claim claim = new Claim(ClaimTypes.Name, "TestUser");
            identity.AddClaim(claim);
            _principal = new ClaimsPrincipal(identity);

            _context = new HttpRequestContext()
            {
                Configuration = config,
                Principal = _principal
            };
            _controller = new TestController()
            {
                RequestContext = _context
            };
        }
 public DefaultControllerBehaviorConfig(ApiController controller)
 {
     var request = new HttpRequestMessage();
     var cfg = new HttpConfiguration();
     request.Properties[HttpPropertyKeys.HttpConfigurationKey] = cfg;
     controller.Request = request;
 }
        public async static Task<dynamic> CopyMulipartContent(ApiController controller)
        {
            if (!controller.Request.Content.IsMimeMultipartContent())
            {
                throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
            }

            var root = HttpContext.Current.Server.MapPath("~/App_Data");
            var provider = new MultipartFormDataStreamProvider(root);
            var tempPath = HttpContext.Current.Server.MapPath("~/Content/Temp/");
            var fileNames = new List<string>();

            await controller.Request.Content.ReadAsMultipartAsync(provider);

            foreach (MultipartFileData file in provider.FileData)
            {
                _fileId++;
                if (_fileId + 1 > Int32.MaxValue)
                    _fileId = 0;
                var filename = tempPath + _fileId + "_" + file.Headers.ContentDisposition.FileName.Replace("\"", "").Replace("\\", "");
                fileNames.Add(filename);
                File.Copy(file.LocalFileName, filename);
                FileHelper.WaitFileUnlockedAsync(() => File.Delete(file.LocalFileName), file.LocalFileName, 30, 800);
            }

            return new { formData = provider.FormData, fileNames };
        }
        private void SetupControllerForTesting(ApiController controller, string controllerName)
        {
            string serverUrl = "http://sample-url.com";

            // Setup the Request object of the controller
            var request = new HttpRequestMessage()
            {
                RequestUri = new Uri(serverUrl)
            };

            controller.Request = request;

            // Setup the configuration of the controller
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });
            controller.Configuration = config;

            // Apply the routes to the controller
            controller.RequestContext.RouteData = new HttpRouteData(
                route: new HttpRoute(),
                values: new HttpRouteValueDictionary
                {
                    { "controller", controllerName }
                });
        }
        public OkFileDownloadResult(string localPath, string contentType, string downloadFileName,
            ApiController controller)
        {
            if (localPath == null)
            {
                throw new ArgumentNullException("localPath");
            }

            if (contentType == null)
            {
                throw new ArgumentNullException("contentType");
            }

            if (downloadFileName == null)
            {
                throw new ArgumentNullException("downloadFileName");
            }

            if (controller == null)
            {
                throw new ArgumentNullException("controller");
            }

            LocalPath = localPath;
            ContentType = contentType;
            DownloadFileName = downloadFileName;
            _controller = controller;
        }
 public void ContentIsCorrectlyInitialized(Uri location, Model content, ApiController controller)
 {
     // Exercise system
     var result = new JSendCreatedResult<Model>(location, content, controller);
     // Verify outcome
     result.Content.Should().Be(content);
 }
 public OAuthImplicitAccessTokenResult(string redirectUrl, OAuthImplicitAccessTokenResponse response,
     ApiController controller)
 {
     RedirectUrl = redirectUrl;
     Response = response;
     Request = controller.Request;
 }
        private static async Task<User> GetUserEntityAsync(ApiController controller)
        {
            ClaimsPrincipal principal = (ClaimsPrincipal)controller.User;
            string provider = principal.FindFirst("http://schemas.microsoft.com/identity/claims/identityprovider").Value;

            ProviderCredentials creds;

            if (string.Equals(provider, "microsoftaccount", StringComparison.OrdinalIgnoreCase))
            {
                creds = await controller.User.GetAppServiceIdentityAsync<MicrosoftAccountCredentials>(controller.Request);
            }
            //else if (string.Equals(provider, "facebook", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<FacebookCredentials>(controller.Request);
            //}
            //else if (string.Equals(provider, "google", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<GoogleCredentials>(controller.Request);
            //}
            //else if (string.Equals(provider, "twitter", StringComparison.OrdinalIgnoreCase))
            //{
            //    creds = await controller.User.GetAppServiceIdentityAsync<TwitterCredentials>(controller.Request);
            //}
            else
            {
                throw new NotImplementedException();
            }
            
            return GetUserEntity(creds);
        }
 public void ConstructorThrowsWhenReasonIsWhiteSpace(ApiController controller)
 {
     // Exercise system and verify outcome
     Action ctor = () => new JSendBadRequestResult("  ", controller);
     ctor.ShouldThrow<ArgumentException>()
         .And.Message.Should().StartWith(StringResources.BadRequest_WhiteSpaceReason);
 }
 public void ReasonIsCorrectlyInitialized(string reason, ApiController controller)
 {
     // Exercise system
     var result = new JSendBadRequestResult(reason, controller);
     // Verify outcome
     result.Reason.Should().Be(reason);
 }
 public void ConstructorThrowsWhenRouteNameIsNull(
     Dictionary<string, object> routeValues, Model content, ApiController controller)
 {
     // Exercise system and verify outcome
     Action ctor = () => new JSendCreatedAtRouteResult<Model>(null, routeValues, content, controller);
     ctor.ShouldThrow<ArgumentNullException>();
 }
Example #12
0
 public void RequestIsCorrectlyInitializedUsingController(ApiController controller)
 {
     // Exercise system
     var result = new JSendOkResult(controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="BaseTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which will be tested.</param>
 /// <param name="controllerAttributes">Collected attributes from the tested controller.</param>
 protected BaseTestBuilder(
     ApiController controller,
     IEnumerable<object> controllerAttributes = null)
 {
     this.Controller = controller;
     this.ControllerLevelAttributes = controllerAttributes;
 }
        public static IHttpActionResult GetErrorResult(this IdentityResult result, ApiController controller)
        {
            if (result == null)
            {
                return new System.Web.Http.Results.InternalServerErrorResult(controller);
            }

            if (!result.Succeeded)
            {
                if (result.Errors != null)
                {
                    foreach (string error in result.Errors)
                    {
                        controller.ModelState.AddModelError("", error);
                    }
                }

                if (controller.ModelState.IsValid)
                {
                    // No ModelState errors are available to send, so just return an empty BadRequest.
                    return new System.Web.Http.Results.BadRequestResult(controller);
                }

                return new System.Web.Http.Results.BadRequestResult(controller);
            }

            return new System.Web.Http.Results.OkResult(controller);
        }
 public void LocationIsCorrectlyInitialized(Uri location, ApiController controller)
 {
     // Exercise system
     var result = new JSendRedirectResult(location, controller);
     // Verify outcome
     result.Location.Should().Be(location);
 }
        /// <summary>
        /// Validates the access token for any OAuth connector.
        /// </summary>
        /// <param name="authController">The connector controller which uses access token based authentication</param>
        /// <param name="connectorName">The name of the connector for which the validation will be done.</param>
        /// <param name="getAccessTokenVerificationRequest">Callback that computes the request object that will be used to do access token verification.</param>
        /// <param name="webResponseProcessor">Callback that processes the web response from 3rd party service.</param>
        /// <returns>A status check record indiciating the outcome of access token check.</returns>
        public static async Task<StatusCheckEntry> ValidateAccessToken(ApiController authController, string connectorName, Func<Task<HttpWebRequest>> getAccessTokenVerificationRequest = null, Func<WebResponse, StatusCheckEntry> webResponseProcessor = null)
        {
            Logger.LogMessage(authController.Request, false, "Retrieving {0} connector status", connectorName);
            if (getAccessTokenVerificationRequest == null)
            {
                throw new ArgumentNullException("getAccessTokenVerificationRequest", "getAccessTokenVerificationRequest cannot be null");
            }

            return await Task.Factory.StartNew(() =>
                {
                    var accessTokenStatusCheck = new StatusCheckEntry();
                    try
                    {
                        // Constructing the outgoing request object
                        HttpWebRequest outgoingRequest = null;
                        Logger.LogMessage(authController.Request, false, "Constructing outgoing request object");
                        outgoingRequest = getAccessTokenVerificationRequest().Result;
                        outgoingRequest.ReadWriteTimeout = -1;
                        outgoingRequest.Timeout = -1;
                        outgoingRequest.KeepAlive = false;
                        Logger.LogMessage(authController.Request, false, "Calling {0} API with Request URI: {1}", connectorName, outgoingRequest.RequestUri.ToString());

                        // Make the call and check the response code
                        WebResponse webResponse = outgoingRequest.GetResponse();
                        HttpStatusCode statusCode = ((HttpWebResponse)webResponse).StatusCode;
                        Logger.LogMessage(authController.Request, false, "Status returning , {0}", statusCode);

                        if (webResponseProcessor != null)
                        {
                            accessTokenStatusCheck = webResponseProcessor(webResponse);
                        }
                        else
                        {
                            accessTokenStatusCheck = ProcessStatusCheckResponse(authController, webResponse);
                        }
                    }
                    catch (Exception ex)
                    {
                        if (ex.Message.Equals("The remote server returned an error: (401) Unauthorized."))
                        {
                            Logger.LogMessage(authController.Request, ex.Message);
                            accessTokenStatusCheck = GetInvalidAccessTokenStatusCheckEntry();
                        }
                        else
                        {
                            // Log the exception stack
                            Logger.LogException(authController.Request, ex);

                            // Construct a status check entry mentioning that status check failed
                            accessTokenStatusCheck.Level = StatusLevel.Error;
                            accessTokenStatusCheck.Message = string.Format(CommonResource.StatusCheckFailed, connectorName);
                            accessTokenStatusCheck.Name = StatusMessages.StatusCheckFailed;
                        }
                    }

                    return accessTokenStatusCheck;
                }
            );
        }
 public void UrlFactoryIsCorrectlyInitialized(string routeName, Dictionary<string, object> routeValues,
     ApiController controller)
 {
     // Exercise system
     var result = new JSendRedirectToRouteResult(routeName, routeValues, controller);
     // Verify outcome
     result.UrlFactory.Should().BeSameAs(controller.Url);
 }
 public void RequestIsCorrectlyInitializedUsingController(
     IEnumerable<AuthenticationHeaderValue> challenges, ApiController controller)
 {
     // Exercise system
     var result = new JSendUnauthorizedResult(challenges, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="VoidActionResultTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Caught exception during the action execution.</param>
 /// <param name="actionAttributes">Collected action attributes from the method call.</param>
 public VoidActionResultTestBuilder(
     ApiController controller,
     string actionName,
     Exception caughtException,
     IEnumerable<object> actionAttributes)
     : base(controller, actionName, caughtException, actionAttributes)
 {
 }
        public static IHttpActionResult ToActionResult(this HalModel model, ApiController controller, HttpStatusCode statusCode = HttpStatusCode.OK)
        {
            var baseUri = controller.Url.Content("~/");
            var models = GetFlattenedModelList(model);
            models.ForEach(m => m.SetRequestPath(baseUri));

            return new NegotiatedContentResult<HalModel>(statusCode, model, controller);
        }
        public static void SetupMockUrl(ApiController controller)
        {
            string locationUrl = "http://location/";

            var mockUrlHelper = new Mock<UrlHelper>();
            mockUrlHelper.Setup(x => x.Link(It.IsAny<string>(), It.IsAny<object>())).Returns(locationUrl);
            controller.Url = mockUrlHelper.Object;
        }
 public void RequestIsCorrectlyInitializedUsingController(
     [InvalidModelState] ModelStateDictionary modelState, ApiController controller)
 {
     // Exercise system
     var result = new JSendInvalidModelStateResult(modelState, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 public void RequestIsCorrectlyInitializedUsingController(
     string message, int? code, Exception data, ApiController controller)
 {
     // Exercise system
     var result = new JSendInternalServerErrorResult(message, code, data, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 public void RequestIsCorrectlyInitializedUsingController(
     Exception ex, string message, int? code, object data, ApiController controller)
 {
     // Exercise system
     var result = new JSendExceptionResult(ex, message, code, data, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ShouldThrowTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Caught exception during the action execution.</param>
 public ShouldThrowTestBuilder(
     ApiController controller,
     string actionName,
     Exception caughtException)
     : base(controller, actionName, caughtException)
 {
     this.exceptionTestBuilder = new ExceptionTestBuilder(this.Controller, this.ActionName, this.CaughtException);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="HttpResponseExceptionTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Actual received HttpResponseException.</param>
 public HttpResponseExceptionTestBuilder(
     ApiController controller,
     string actionName,
     HttpResponseException caughtException)
     : base(controller, actionName, caughtException)
 {
     this.httpResponseException = caughtException;
 }
 public void RequestIsCorrectlyInitializedUsingController(
     string routeName, Dictionary<string, object> routeValues, Model content, ApiController controller)
 {
     // Exercise system
     var result = new JSendCreatedAtRouteResult<Model>(routeName, routeValues, content, controller);
     // Verify outcome
     result.Request.Should().Be(controller.Request);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="BaseTestBuilderWithAction" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="actionAttributes">Collected action attributes from the method call.</param>
 protected BaseTestBuilderWithAction(
     ApiController controller,
     string actionName,
     IEnumerable<object> actionAttributes = null)
     : base(controller)
 {
     this.ActionName = actionName;
     this.ActionLevelAttributes = actionAttributes;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ModelErrorTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Caught exception during the action execution.</param>
 /// <param name="modelState">Optional model state dictionary to use the class with. Default is controller's model state.</param>
 public ModelErrorTestBuilder(
     ApiController controller,
     string actionName,
     Exception caughtException,
     ModelStateDictionary modelState = null)
     : base(controller, actionName, caughtException)
 {
     this.ModelState = modelState ?? controller.ModelState;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="BaseTestBuilderWithCaughtException" /> class.
 /// </summary>
 /// <param name="controller">Controller on which the action will be tested.</param>
 /// <param name="actionName">Name of the tested action.</param>
 /// <param name="caughtException">Caught exception during the action execution.</param>
 /// <param name="actionAttributes">Collected action attributes from the method call.</param>
 protected BaseTestBuilderWithCaughtException(
     ApiController controller,
     string actionName,
     Exception caughtException,
     IEnumerable<object> actionAttributes = null)
     : base(controller, actionName, actionAttributes)
 {
     this.CaughtException = caughtException;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ActionContentResult" /> class.
 /// </summary>
 public ActionContentResult(IActionLinkService actionLinkService, ActionItem action, ApiController controller)
 {
     ActionLinkService = actionLinkService;
     Action            = action;
     Controller        = controller;
 }
Example #32
0
 /// <summary>
 /// Get Request object
 /// </summary>
 /// <param name="controller">ApiController value</param>
 /// <returns>HttpRequestBase object</returns>
 public static HttpRequestBase Request(this ApiController controller)
 {
     return(controller.GetContext().Request);
 }
        /// <summary>
        /// Handles a controller action's request to update email address.
        /// </summary>
        /// <param name="updatedEmailAddress">The updated email address.</param>
        /// <param name="controller">The controller making the request.</param>
        /// <returns>The updated email address.</returns>
        public async Task <IHttpActionResult> HandleUpdateEmailAddressAsync(UpdatedEmailAddressBindingModel updatedEmailAddress, ApiController controller)
        {
            if (controller.ModelState.IsValid)
            {
                var currentUser  = this.userProvider.GetCurrentUser();
                var businessUser = this.userProvider.GetBusinessUser(currentUser);
                await this.emailAddressService.UpdateAsync(updatedEmailAddress.ToUpdatedEmailAddress(businessUser));

                await this.emailAddressService.SaveChangesAsync();

                var dto = await this.emailAddressService.GetByIdAsync(updatedEmailAddress.Id);

                return(new OkNegotiatedContentResult <EmailAddressDTO>(dto, controller));
            }
            else
            {
                return(new InvalidModelStateResult(controller.ModelState, controller));
            }
        }
Example #34
0
 public static HttpResponseMessage GenerateErrorResponse(this ApiController controller, Exception ex)
 {
     return(controller.GenerateErrorResponse(HttpStatusCode.InternalServerError, ex));
 }
Example #35
0
 public ChallengeResult(string loginProvider, ApiController controller)
 {
     LoginProvider = loginProvider;
     Request       = controller.Request;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="CreatedODataResult{T}"/> class.
 /// </summary>
 /// <param name="entity">The created entity.</param>
 /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
 public CreatedODataResult(T entity, ApiController controller)
     : this(new NegotiatedContentResult <T>(HttpStatusCode.Created, CheckNull(entity), controller))
 {
 }
Example #37
0
 public MyContentNegotiationResult(T content, ApiController _controller)
 {
     Content       = content;
     configuration = _controller.Configuration;
     request       = _controller.Request;
 }
 public static ODataPath GetODataPath(ApiController controller)
 {
     return(controller.Request.GetODataPath());
 }
Example #39
0
 /// <summary>Initializes a new instance of the <see cref="NotFoundResult"/> class.</summary>
 /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
 public OkResult(ApiController controller)
     : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
 {
 }
Example #40
0
 public static IHttpActionResult TokenResponse(this ApiController controller, TokenResponse response)
 {
     return(new TokenResult(response));
 }
        public static ODataQueryOptions <TEntity> CreateQueryOptions <TEntity>(ApiController controller)
        {
            ODataQueryContext context = new ODataQueryContext(controller.Request.GetEdmModel(), typeof(TEntity));

            return(new ODataQueryOptions <TEntity>(context, controller.Request));
        }
Example #42
0
 public static IHttpActionResult TokenErrorResponse(this ApiController controller, string error, string errorDescription)
 {
     return(new TokenErrorResult(error, errorDescription));
 }
Example #43
0
 /// <summary>
 /// Inicia uma nova instância da classe <see cref="Aceito"/>.
 /// </summary>
 /// <param name="apiController">O controller que está sendo executado.</param>
 /// <param name="mensagem">A mensagem que será exibida na tela.</param>
 public Aceito(ApiController apiController, string mensagem)
     : base(apiController, mensagem)
 {
 }
Example #44
0
 private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context,
                                                                  ApiController controller, IAuthenticationFilter[] filters, IHttpActionResult innerResult)
 {
     return(new AuthenticationFilterResult(context, controller, filters, innerResult));
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ActionContentResult" /> class.
 /// </summary>
 public ActionContentResult(ApiController controller)
 {
     Controller = controller;
 }
Example #46
0
 /// <summary>
 /// Recupera a estratégia de validação para o cálculo de área em m².
 /// </summary>
 /// <param name="apiController">O controller que está sendo executado.</param>
 /// <param name="tipoValidacao">O tipo de validação que será feita.</param>
 /// <returns>O objeto que contém as validações a serem feitas, de acordo com o tipo.</returns>
 public static IValidacaoCalculoAreaM2 ObterEstrategiaCalculoAreaM2(ApiController apiController, string tipoValidacao)
 {
     return(new ValidacaoCalculoAreaM2SemOperacaoStrategy());
 }
Example #47
0
 /// <summary>
 /// Creates, initializes and returns a new instance of the <see cref="BadRequestBrokenRulesActionResult"/> class.
 /// </summary>
 /// <param name="controller">
 /// The Api Controller to grab the response from.
 /// </param>
 /// <param name="brokenRules">
 /// A IEnumerable of broken Validation Rules.
 /// </param>
 /// <param name="className">
 /// The name of the Entity Type that failed validation.
 /// </param>
 /// <returns>
 /// A custom 400 - Bad Request Http response, for validation failures.
 /// </returns>
 public static BadRequestBrokenRulesActionResult BadRequest(ApiController controller, IEnumerable <ValidationRule> brokenRules, string className)
 {
     return(new BadRequestBrokenRulesActionResult(controller.Request, brokenRules, className));
 }
 public static NotFoundPlainTextActionResult NotFound(ApiController controller, string message)
 {
     return(new NotFoundPlainTextActionResult(controller.Request, message));
 }
Example #49
0
 private static OkNegotiatedContentResult <object> CreateProductUnderTest(object content,
                                                                          ApiController controller)
 {
     return(new OkNegotiatedContentResult <object>(content, controller));
 }
 /// <summary>
 /// Inicia uma nova instância da classe <see cref="ExibicaoSvgProjetoStrategy"/>.
 /// </summary>
 /// <param name="sessao">A transação com o banco de dados.</param>
 /// <param name="apiController">O controller que está sendo executado.</param>
 public ExibicaoSvgProjetoStrategy(GDASession sessao, ApiController apiController)
 {
     this.sessao        = sessao;
     this.apiController = apiController;
 }
Example #51
0
        public static HttpResponseMessage GenerateErrorResponse(this ApiController controller, HttpStatusCode statusCode, Exception ex)
        {
            var errorMessage = Constants.ERRORMSG + ex.Message;

            return(controller.Request.CreateErrorResponse(statusCode, ex.InnerException == null ? errorMessage : errorMessage + Constants.INNEREXCEPTION + ex.InnerException.Message));
        }
Example #52
0
 /// <summary>
 /// Get request content length
 /// </summary>
 /// <param name="controller">ApiController value</param>
 /// <returns>long value</returns>
 public static long GetRequestContentLength(this ApiController controller)
 {
     return(controller.GetContext().Request.ContentLength);
 }
Example #53
0
 public ETagOkActionResult(byte[] entityVersion, T content, ApiController controller) : base(content, controller)
 {
     _entityVersion = entityVersion;
 }
Example #54
0
 /// <summary>
 /// Get Context object
 /// </summary>
 /// <param name="controller">ApiController value</param>
 /// <returns>HttpContextWrapper object</returns>
 public static HttpContextWrapper GetContext(this ApiController controller)
 {
     return((HttpContextWrapper)controller.Request.Properties["MS_HttpContext"]);
 }
Example #55
0
 /// <summary>
 /// Get Download Path
 /// </summary>
 /// <param name="controller">ApiController value</param>
 /// <returns>String value</returns>
 public static string GetDownloadPath(this ApiController controller)
 {
     return(controller.GetContext().Server.MapPath("~/Downloads"));
 }
 public BadRequestNegotiatedContentResult(T content, ApiController controller)
     : base(content, controller)
 {
 }
Example #57
0
        /// <summary>
        /// 显示当前控制器的所有开发API
        /// </summary>
        /// <param name="apiController"></param>
        /// <returns></returns>
        public static string ShowWebApi(ApiController apiController)
        {
            List <ReflectModel> controls = new List <ReflectModel>();
            var asm = System.Reflection.Assembly.GetExecutingAssembly();

            System.Collections.Generic.List <Type> typeList = new List <Type>();
            var types = asm.GetTypes().Where(type => typeof(IHttpController).IsAssignableFrom(type));

            foreach (Type type in types)
            {
                string s = type.FullName.ToLower();
                typeList.Add(type);
            }
            typeList.Sort(delegate(Type type1, Type type2) { return(type1.FullName.CompareTo(type2.FullName)); });
            foreach (Type type in typeList)
            {
                ReflectModel rm = new ReflectModel();
                rm.ActionDesction = new List <ReflectActionModel>();

                string controller = type.Name.Replace("Controller", "");
                rm.ControllerName = controller;
                System.Reflection.MethodInfo[] memthods = type.GetMethods(
                    System.Reflection.BindingFlags.Public |
                    System.Reflection.BindingFlags.Static |
                    System.Reflection.BindingFlags.NonPublic |
                    System.Reflection.BindingFlags.Instance |
                    System.Reflection.BindingFlags.DeclaredOnly);
                foreach (var m in memthods)
                {
                    if (m.DeclaringType.Attributes.HasFlag(System.Reflection.TypeAttributes.Public) != true)
                    {
                        continue;
                    }
                    ReflectActionModel ram    = new ReflectActionModel();
                    string             action = m.Name;
                    if (action.Contains("<") || action.Contains(">"))
                    {
                        continue;
                    }
                    ram.ActionName = action;
                    foreach (var item in m.CustomAttributes)
                    {
                        string nn = item.AttributeType.Name;
                        if (nn.StartsWith("Http"))
                        {
                            nn = nn.Remove(0, 4).Replace("Attribute", "");
                            if (string.IsNullOrEmpty(ram.ActionType))
                            {
                                ram.ActionType += nn;
                            }
                            else
                            {
                                ram.ActionType += "," + nn;
                            }
                        }
                    }

                    ram.ActionLink = controller + "/" + action;
                    ParameterInfo[]    ps       = m.GetParameters();
                    List <ReflectData> DataList = new List <ReflectData>();
                    foreach (var par in ps)
                    {
                        DataList.Add(new ReflectData {
                            name = par.Name, des = par.ParameterType.ToString()
                        });
                    }
                    ram.ActionData = DataList;
                    rm.ActionDesction.Add(ram);
                }
                controls.Add(rm);
            }
            //return controls;
            string html = "";

            foreach (var item in apiController.Configuration.Routes)
            {
                if (!string.IsNullOrEmpty(item.RouteTemplate))
                {
                    html += "Route:" + item.RouteTemplate + "<br/>";
                }
            }
            html += "<br/>";
            html += DateTime.Now.ToString();
            html += "<br/>";
            foreach (var item in controls)
            {
                html += "--------------------------------------<br/>";
                html += "Controller:" + item.ControllerName + "<br/>";
                html += "-----------------<br/>";
                foreach (var res in item.ActionDesction)
                {
                    html += "Url:" + res.ActionLink + "  (" + res.ActionType + ")<br/>";
                    foreach (var pro in res.ActionData)
                    {
                        html += "&nbsp;&nbsp;Parameter Name:" + pro.name + "(" + pro.des + ")<br/>";
                    }
                    html += "-----------------<br/>";
                }
            }
            html = "<!DOCTYPE html><html lang=\"zh-CN\" ><head><title>接口清单列表</title><style>*{font-size: 12px;}</style></head><body> " + html + "</body></html>";
            return(html);
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="ActionContentResult" /> class.
 /// </summary>
 public ActionContentResult(HttpStatusCode statusCode, IActionLinkService actionLinkService, ActionItem action, ApiController controller)
 {
     StatusCode        = statusCode;
     ActionLinkService = actionLinkService;
     Action            = action;
     Controller        = controller;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="ControllerTestBuilder" /> class.
 /// </summary>
 /// <param name="controller">Controller which will be tested.</param>
 /// <param name="controllerAttributes">Collected attributes from the tested controller.</param>
 public ControllerTestBuilder(
     ApiController controller,
     IEnumerable <object> controllerAttributes)
     : base(controller, controllerAttributes)
 {
 }
        /// <summary>
        /// Handles a controller action's request to add a email address to an entity.
        /// </summary>
        /// <typeparam name="T">The ECA Data entity type that will have a email address added.</typeparam>
        /// <param name="emailAddressModel">The email address to add.</param>
        /// <param name="controller">The controller handling the request.</param>
        /// <returns>The http action result.</returns>
        public async Task <IHttpActionResult> HandleEmailAddressAsync <T>(EmailAddressBindingModelBase <T> emailAddressModel, ApiController controller)
            where T : class, IEmailAddressable
        {
            if (controller.ModelState.IsValid)
            {
                var currentUser  = userProvider.GetCurrentUser();
                var businessUser = userProvider.GetBusinessUser(currentUser);
                var emailAddress = await this.emailAddressService.CreateAsync(emailAddressModel.ToEmailAddress(businessUser));

                await this.emailAddressService.SaveChangesAsync();

                var dto = await this.emailAddressService.GetByIdAsync(emailAddress.EmailAddressId);

                var result = new OkNegotiatedContentResult <EmailAddressDTO>(dto, controller);
                return(result);
            }
            else
            {
                return(new InvalidModelStateResult(controller.ModelState, controller));
            }
        }