/// <summary>
        /// GET: api/Widget/{title}. Return search results. Empty string gives zero length result.
        /// </summary>
        public HttpResponseMessage Get(string title)
        {
            var bvms = new List<BookViewModel>();
            //var results = new List<KeyValuePair<string, List<string>>>(); // Title, authors
            var results = new List<WidgetResponseRow>();

            if (title != "")
            {
                try
                {
                    bvms = BookServices.SearchBooks(title);
                    foreach (var bvm in bvms)
                    {
                        results.Add(new WidgetResponseRow(bvm.ISBN, bvm.Title, bvm.Authors.Select(i => i.Value).ToList()));
                    }
                }
                catch (DataAccessException)
                {
                    var error = new HttpError("Data access error.");
                    return Request.CreateResponse(HttpStatusCode.InternalServerError, error);
                }
            }

            HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, results);
            response.ReasonPhrase = "OK";

            return response;
        }

 protected override void HandleUnauthorizedRequest(HttpActionContext actionContext)
 {
     // http://blogs.msdn.com/b/youssefm/archive/2012/06/28/error-handling-in-asp-net-webapi.aspx
     var message = string.Format("No HTTP resource was found that matches the request URI '{0}'.", actionContext.Request.RequestUri);
     var error = new HttpError(message);
     actionContext.Response = actionContext.Request.CreateErrorResponse(HttpStatusCode.NotFound, error);
 }

        public HttpResponseMessage Delete(string idUser, string emailUser, string passwordUser, string userRegistration, string statusUser)
        {
            try
            {
                User user = new User();
                DateTime now = DateTime.Now;
                #region Atribuir/valorizar modelo
                if (!String.IsNullOrWhiteSpace(idUser))
                    user.IdUser = Convert.ToInt32(idUser);

                user.RegistrationDateUser = now;

                if (!String.IsNullOrWhiteSpace(userRegistration))
                    user.ChangeUserUser = Convert.ToInt32(userRegistration);
                #endregion

                return Request.CreateResponse(HttpStatusCode.OK, user); ;
            }
            catch (KeyNotFoundException)
            {
                string mensagem = string.Format("Não foi possível criptografar a entrada: ", emailUser);
                HttpError error = new HttpError(mensagem);
                return Request.CreateResponse(HttpStatusCode.NotFound, error);
            }
        }

        public void GetPropertyValue_GetsDefault_IfPropertyMissing()
        {
            HttpError error = new HttpError();

            Assert.Null(error.GetPropertyValue<string>("key"));
            Assert.Equal(0, error.GetPropertyValue<int>("key"));
        }

 public HttpError ToHttpError(params object[] args)
 {
     var http = new HttpError();
     http["Message"] = string.Format(Message, args);
     http["Type"] = Type;
     return http;
 }

        public HttpResponseMessage Get(string id)
        {
            try
            {
                TrataRetorno objRetorno = new TrataRetorno();
                List<Indice> Indices = new List<Indice>();
                string urlInicial = "http://finance.yahoo.com/webservice/v1/symbols/";
                string urlFinal = "/quote?format=xml&view=detail";
                string[] stringSeparators = new string[] { "," };
                string[] result;

                result = id.Split(stringSeparators, StringSplitOptions.None);
                foreach (string s in result)
                {
                    XPathDocument doc = new XPathDocument(urlInicial + s + urlFinal);
                    Indices.Add(objRetorno.TratarRetorno(doc));
                }

                return Request.CreateResponse(HttpStatusCode.OK, Indices); ;
            }
            catch (KeyNotFoundException)
            {
                string mensagem = string.Format("Não foi possível criptografar a entrada: ", id);
                HttpError error = new HttpError(mensagem);
                return Request.CreateResponse(HttpStatusCode.NotFound, error);
            }
        }

 public HttpResponseMessage Post(LogOnModel user)
 {
     try
     {
         Impersonate.ImpersonateUser(ConfigurationManager.AppSettings["Domain"].ToString(), user.UserName, user.Password);
         if (this.ValidateUser(user))
         {
             FormsAuthentication.SetAuthCookie(user.UserName, true);
             return Request.CreateResponse(HttpStatusCode.OK, true);
         }
         return Request.CreateResponse(HttpStatusCode.OK, false);
     }
     catch (DirectoryServicesCOMException dse)
     {
         HttpError error = new HttpError(dse.Message.Replace("\n", " ").Replace("\r", " ").Replace("\t", " "));
         return Request.CreateResponse(HttpStatusCode.Unauthorized, error);
     }
     catch (Exception)
     {
         throw;
     }
     finally
     {
         Impersonate.UndoImpersonation();
     }
 }

        public void SerializeError_serializes_httperror()
        {
            using (var stream = new MemoryStream())
            {
                var textWriter = new StreamWriter(stream);
                var writer = new JsonTextWriter(textWriter);

                var mockInnerException = new Mock<Exception>(MockBehavior.Strict);
                mockInnerException.Setup(m => m.Message).Returns("Inner exception message");
                mockInnerException.Setup(m => m.StackTrace).Returns("Inner stack trace");

                var outerException = new Exception("Outer exception message", mockInnerException.Object);

                var error = new HttpError(outerException, true)
                {
                    StackTrace = "Outer stack trace"
                };
                var jsonSerializer = new JsonSerializer();

                var mockIdProvider = new Mock<IErrorIdProvider>(MockBehavior.Strict);
                mockIdProvider.SetupSequence(p => p.GenerateId(It.IsAny<HttpError>())).Returns("OUTER-ID").Returns("INNER-ID");

                var serializer = new ErrorSerializer(mockIdProvider.Object);
                serializer.SerializeError(error, stream, writer, jsonSerializer);

                writer.Flush();

                var expectedJson = File.ReadAllText("ErrorSerializerTest.json");
                var minifiedExpectedJson = JsonHelpers.MinifyJson(expectedJson);
                var output = System.Text.Encoding.ASCII.GetString(stream.ToArray());
                output.Should().Be(minifiedExpectedJson);
            }
        }

 public override void OnException(HttpActionExecutedContext context)
 {
     if (context.Exception is FormValidationException)
     {
         var exception = context.Exception as FormValidationException;
         var fieldErrors = exception.FieldErrors
             .Select(x => "{ Field: " + x.Item1 + ", Error: " + x.Item2 + " }");
         var error = new HttpError(exception.Message)
         {
             { "Type", "FormValidationException"},
             { "FieldErrors", fieldErrors}
         };
         context.Response = context.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
     }
     else if (context.Exception is DomainException)
     {
         var exception = context.Exception as DomainException;
         var error = new HttpError(exception.Message)
         {
             { "Type", "DomainException"},
         };
         context.Response = context.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
     }
     else
     {
         var error = new HttpError("An unknown error has occurred.");
         context.Response = context.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
     }
 }

 public async override Task Invoke(IOwinContext context)
 {
     try
     {
         await Next.Invoke(context);
     }
     catch(Exception ex)
     {
         _logger.Error("Last chance exception caught.", ex);
         var headers = context.Request.Headers;
         // if server accepts json - just return json error
         if (headers.ContainsKey("Accept") && headers["Accept"].Contains("application/json"))
         {
             var includeDetail = context.Request.LocalIpAddress == context.Request.RemoteIpAddress;
             var message = new HttpError(ex, includeDetail);
             var serializerSettings = new JsonSerializerSettings
             {
                 ContractResolver = new CamelCasePropertyNamesContractResolver()
             };
             context.Response.StatusCode = 500;
             context.Response.Write(JsonConvert.SerializeObject(message, serializerSettings));
         }
         // otherwise - let the owin to return html
         else
         {
             throw;
         }
     }
 }

 private static ODataInnerError ToODataInnerError(HttpError httpError)
 {
     string innerErrorMessage = httpError.GetPropertyValue<string>(HttpErrorKeys.ExceptionMessageKey);
     if (innerErrorMessage == null)
     {
         string messageDetail = httpError.GetPropertyValue<string>(HttpErrorKeys.MessageDetailKey);
         if (messageDetail == null)
         {
             HttpError modelStateError = httpError.GetPropertyValue<HttpError>(HttpErrorKeys.ModelStateKey);
             return (modelStateError == null) ? null
                 : new ODataInnerError { Message = ConvertModelStateErrors(modelStateError) };
         }
         else
         {
             return new ODataInnerError() { Message = messageDetail };
         }
     }
     else
     {
         ODataInnerError innerError = new ODataInnerError();
         innerError.Message = innerErrorMessage;
         innerError.TypeName = httpError.GetPropertyValue<string>(HttpErrorKeys.ExceptionTypeKey);
         innerError.StackTrace = httpError.GetPropertyValue<string>(HttpErrorKeys.StackTraceKey);
         HttpError innerExceptionError = httpError.GetPropertyValue<HttpError>(HttpErrorKeys.InnerExceptionKey);
         if (innerExceptionError != null)
         {
             innerError.InnerError = ToODataInnerError(innerExceptionError);
         }
         return innerError;
     }
 }

        // GET /api/projects/4/researchitems/5
        public virtual HttpResponseMessage Get(int projectId, int researchItemId)
        {
            var researchItems = new List<ResearchItem>();
            var project = new Project();
            try
            {
                // Verify that the user is the owner of project and research item.
                project = _projectRepository.GetByUser(projectId, User.Identity.Name);
                if (project == null)
                {
                    return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Project not found for user " + User.Identity.Name + ".");
                }
                var researchItem = _researchItemRepository.GetByUser(researchItemId, User.Identity.Name);
                if (researchItem == null)
                {
                    return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Research item not found for user " + User.Identity.Name + ".");
                }
                researchItems.Add(researchItem);
            }
            catch (Exception ex)
            {
                var error = new HttpError("Error getting research item: " + ex.Message) { { "Trace", ex.StackTrace } };
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
            }

            var researchItemDto = new ResearchItemDto()
            {
                Meta = new ResearchItemMeta() { NumberResearchItems = researchItems.Count(), ProjectName = project.Name },
                ResearchItems = researchItems
            };

            return Request.CreateResponse<ResearchItemDto>(HttpStatusCode.OK, researchItemDto);
        }

        // Convert the model state errors in to a string (for debugging only).
        // This should be improved once ODataError allows more details.
        private static string ConvertModelStateErrors(HttpError error)
        {
            StringBuilder builder = new StringBuilder();
            foreach (KeyValuePair<string, object> modelStateError in error)
            {
                if (modelStateError.Value != null)
                {
                    builder.Append(modelStateError.Key);
                    builder.Append(" : ");

                    IEnumerable<string> errorMessages = modelStateError.Value as IEnumerable<string>;
                    if (errorMessages != null)
                    {
                        foreach (string errorMessage in errorMessages)
                        {
                            builder.AppendLine(errorMessage);
                        }
                    }
                    else
                    {
                        builder.AppendLine(modelStateError.Value.ToString());
                    }
                }
            }

            return builder.ToString();
        }

 public HttpResponseMessage Post(LogOnModel model)
 {
     try
     {
         if (this.ValidateUser(model))
         {
             FormsAuthentication.SetAuthCookie(model.UserName,true);
             return Request.CreateResponse(HttpStatusCode.OK, true);
         }
         return Request.CreateResponse(HttpStatusCode.OK, false);
     }
     catch (DirectoryServicesCOMException dse)
     {
         HttpError error = new HttpError(dse.Message.Replace("\n", " ").Replace("\r", " ").Replace("\t", " "));
         return Request.CreateResponse(HttpStatusCode.Unauthorized, error);
     }
     catch (Exception ex)
     {
         HttpError error = new HttpError(ex.Message.Replace("\n", " ").Replace("\r", " ").Replace("\t", " "));
         EventLog log = new EventLog();
         log.Source = "Jaguar_Mobile";
         log.WriteEntry(ex.Message);
         return Request.CreateResponse(HttpStatusCode.InternalServerError, error);
     }
 }

        public HttpResponseMessage Get(int id)
        {
            var periodDetialsRequestViewModel = new PeriodDetailsRequestViewModel() { PeriodId = id };
            var serviceResponse = _periodDetailsPresenter.GetListingsByGroupId(periodDetialsRequestViewModel);
            HttpResponseMessage httpResponse;

            switch (serviceResponse.StatusCode)
            {
                case PeriodicTableStatusCodes.Success:
                    httpResponse = Request.CreateResponse(HttpStatusCode.OK, serviceResponse);
                    break;
                case PeriodicTableStatusCodes.Error:
                    var internalServiceError = PeriodicTableServerExceptionResponse.GetInternalServiceError();
                    httpResponse = Request.CreateResponse(HttpStatusCode.InternalServerError, internalServiceError);
                    break;
                default:
                    var error = new HttpError(GetCorrectErrorMessage(serviceResponse.StatusCode))
                                    {
                                        {"ErrorCode", serviceResponse.StatusCode}
                                    };
                    httpResponse = Request.CreateErrorResponse(HttpStatusCode.BadRequest, error);
                    break;
            }
            return httpResponse;
        }

        // POST api/projects (Insert)
        public override HttpResponseMessage Post(Project project)
        {
            // Check for presence of V2 "IsUrgent" flag.
            if (project.IsUrgent == null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The IsUrgent indicator is required.");
            }

            try
            {
                project.UserName = User.Identity.Name;
                project.DateCreated = DateTime.Now;
                project.DateUpdated = DateTime.Now;
                _projectRepository.Insert(project);
                _projectRepository.Commit();
            }
            catch (Exception ex)
            {
                var error = new HttpError("Error inserting project: " + ex.Message) { { "Trace", ex.StackTrace } };
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
            }
            var response = Request.CreateResponse(HttpStatusCode.Created, project);
            string uri = Url.Link("DefaultApi", new { id = project.ProjectId });
            response.Headers.Location = new Uri(uri);
            return response;
        }

        // PUT api/projects/5  (Update)
        public override HttpResponseMessage Put(int id, Project project)
        {
            // Check for presence of V2 "IsUrgent" flag.
            if (project.IsUrgent == null)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, "The IsUrgent indicator is required.");
            }

            var currentProject = new Project();
            try
            {
                // Verify that the user is the owner
                currentProject = _projectRepository.GetByUser(id, User.Identity.Name);
                if (currentProject == null)
                {
                    return Request.CreateErrorResponse(HttpStatusCode.NotFound, "Project not found for user " + User.Identity.Name + ".");
                }
                currentProject.DateUpdated = DateTime.Now;
                currentProject.Name = project.Name;
                currentProject.Description = project.Description;
                currentProject.IsUrgent = project.IsUrgent;
                _projectRepository.Commit();
            }
            catch (Exception ex)
            {
                var error = new HttpError("Error updating project: " + ex.Message) { { "Trace", ex.StackTrace } };
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error);
            }
            var response = Request.CreateResponse(HttpStatusCode.OK, currentProject);
            string uri = Url.Link("DefaultApi", new { id = id });
            response.Headers.Location = new Uri(uri);
            return response;
        }

        private string GenerateErrorKey(HttpError httpError)
        {
            var guid = System.Reflection.Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false)
                .Select(a => ((System.Runtime.InteropServices.GuidAttribute)a).Value)
                .FirstOrDefault();

            return "";
        }

        public void WriteObject_SupportsHttpError()
        {
            var serializer = new ODataErrorSerializer();
            var error = new HttpError("bad stuff");
            Mock<IODataResponseMessage> mockResponseMessage = new Mock<IODataResponseMessage>();
            mockResponseMessage.Setup(response => response.GetStream()).Returns(new MemoryStream());

            Assert.DoesNotThrow(() => serializer.WriteObject(error, new ODataMessageWriter(mockResponseMessage.Object), new ODataSerializerContext()));
        }

        /// <summary>
        /// Occurs before the action method is invoked.
        /// </summary>
        /// <param name="actionContext">The action context.</param>
        public override void OnActionExecuting( HttpActionContext actionContext )
        {
            ModelStateDictionary modelState = actionContext.ModelState;

            IEntity valueArg = null;
            if ( actionContext.ActionArguments.ContainsKey( "value" ) )
            {
                valueArg = actionContext.ActionArguments["value"] as IEntity;
            }

            if ( valueArg != null )
            {
                Type entityType = actionContext.ActionArguments["value"].GetType();
                IgnoreModelErrorsAttribute ignoreModelErrorsAttribute = entityType.GetCustomAttributes( typeof( IgnoreModelErrorsAttribute ), true ).FirstOrDefault() as IgnoreModelErrorsAttribute;

                if ( ignoreModelErrorsAttribute != null )
                {
                    foreach ( string key in ignoreModelErrorsAttribute.Keys )
                    {
                        IEnumerable<string> matchingKeys = modelState.Keys.Where( x => Regex.IsMatch( x, key ) );
                        foreach ( string matchingKey in matchingKeys )
                        {
                            modelState[matchingKey].Errors.Clear();
                        }
                    }
                }
            }

            if ( !actionContext.ModelState.IsValid )
            {
                HttpError httpError = new HttpError();

                foreach ( var item in actionContext.ModelState )
                {
                    var msg = new System.Text.StringBuilder();

                    foreach ( ModelError error in item.Value.Errors )
                    {
                        if ( !string.IsNullOrWhiteSpace( error.ErrorMessage ) )
                        {
                            msg.Append( msg.Length > 0 ? "; " : "" );
                            msg.Append( error.ErrorMessage );
                        }

                        if ( error.Exception != null && !string.IsNullOrWhiteSpace( error.Exception.Message ) )
                        {
                            msg.Append( msg.Length > 0 ? "; " : "" );
                            msg.Append( error.Exception.Message );
                        }
                    }

                    httpError.Add( item.Key, msg.ToString() );
                }

                actionContext.Response = actionContext.Request.CreateErrorResponse( HttpStatusCode.BadRequest, httpError );
            }
        }