public virtual JsonResult Crear(CategoriaProducto entidad)
        {
            var jsonResponse = new JsonResponse { Success = false };

            if (ModelState.IsValid)
            {
                try
                {
                    entidad.UsuarioCreacion = UsuarioActual.IdUsuario.ToString();
                    entidad.UsuarioModificacion = UsuarioActual.IdUsuario.ToString();

                    if (entidad.CAT_NombreIngles == null)
                        entidad.CAT_NombreIngles = "";
                    if (entidad.CAT_Descripcion == null)
                        entidad.CAT_Descripcion = "";
                    entidad.CAT_IndicadorArea = "A"; // cambiar 22/01/2013

                    CategoriaProductoBL.Instancia.Add(entidad);

                    jsonResponse.Success = true;
                    jsonResponse.Message = "Se Proceso con éxito";
                }
                catch (Exception ex)
                {
                    logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
                    jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
                }
            }
            else
            {
                jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
            }
            return Json(jsonResponse, JsonRequestBehavior.AllowGet);
        }

        public virtual JsonResult Crear(CentroCosto entidad)
        {
            var jsonResponse = new JsonResponse { Success = false };

            if (ModelState.IsValid)
            {
                try
                {
                    entidad.UsuarioCreacion = UsuarioActual.IdUsuario.ToString();
                    entidad.UsuarioModificacion = UsuarioActual.IdUsuario.ToString();
                    CentroCostoBL.Instancia.Add(entidad);

                    jsonResponse.Success = true;
                    jsonResponse.Message = "Se Proceso con éxito";
                }
                catch (Exception ex)
                {
                    logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
                    jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
                }
            }
            else
            {
                jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
            }
            return Json(jsonResponse, JsonRequestBehavior.AllowGet);
        }

        public virtual JsonResult BuscarIDCargo(string nombre)
        {
            var jsonResponse = new JsonResponse {Success = false};
            if (ModelState.IsValid)
            {
                try
                {
                    string[] name = nombre.Split('-');
                    //var lista = (Cargo)TrabajadorBL.Instancia.Search(name.ElementAt(1).Trim()).SingleOrDefault();
                    var lista = (Cargo)TrabajadorBL.Instancia.Search(nombre.Trim()).SingleOrDefault();

                    jsonResponse.Data = lista.IDCargo;
                    jsonResponse.Success = true;
                }
                catch (Exception ex)
                {
                    jsonResponse.Success = false;
                    return Json("ERROR - Vuelva a cargar la Página", JsonRequestBehavior.AllowGet);
                }
            }
            else
            {
                jsonResponse.Message = "Por favor ingrese todos los campos requeridos";
            }
            return Json(jsonResponse, JsonRequestBehavior.AllowGet);
        }

    public static JsonResponse AppendFile(string path)
    {
        JsonResponse response = new JsonResponse()
        {
            Data = string.Empty,
            Success = false,
            Message = ""
        };
        //check rights
        if (!Security.IsAuthorizedTo(Rights.CreateNewPosts))
        {
            response.Success = false;
            response.Message = "Access denied";
            return response;
        }

        var file = BlogService.GetFile(path);
        if (file != null)
        {
            if (file.IsImage)
            {
                var imagePath = string.Format("<img src=\"{0}\" />", file.AsImage.ImageUrl);
                response.Success = true;
                response.Data = imagePath;
            }
            else
            {
                var filePath = string.Format("<p><a href=\"{1}\" >{0}</a></p>", file.FileDescription, file.FileDownloadPath);
                response.Success = true;
                response.Data = filePath;
            }
        }
        return response;
    }

        public ActionResult GetRegions(string id)
        {
            string regionid = Request.Form["regionid"];

            JsonResponse result = new JsonResponse();            
            Country c = Country.FindByBvin(id);
            if ((c != null))
            {
                StringBuilder sb = new StringBuilder();
                result.Regions = string.Empty;

                foreach (Region r in c.Regions)
                {
                    sb.Append("<option ");
                    if (r.Abbreviation == regionid)
                    {
                        sb.Append(" selected=\"selected\" ");
                    }
                    sb.Append(" value=\"" + r.Abbreviation + "\">" + r.Name + "</option>");
                }

                result.Regions = sb.ToString();
            }

            return new JsonResult() { Data = result };
        }

        public ActionResult Edit(int boardId, Competitor updatedCompetitor)
        {
            var board = _repository.GetBoardById(boardId);
            var competitor = _repository.GetCompetitorByName(boardId, updatedCompetitor.Name);
            var response = new JsonResponse<bool>();

            if (competitor == null)
            {
                response.Message = "Competitor not found";
                response.Error = true;
            }
            else if (!competitor.CanEdit(board, User.Identity.Name))
            {
                response.Message = "Invalid authority";
                response.Error = true;
            }
            else
            {
                // Just update status for now (owner only can change status)
                if(board.IsOwner(User.Identity.Name))
                    competitor.Status = updatedCompetitor.Status;

                _repository.CommitChanges();
                response.Result = true;
            }

            return (Json(response));
        }

        public void Should_fail_to_return_xml_body_on_non_xml_response()
        {
            var response = new JsonResponse<Model>(new Model() { Dummy = "Data" });
            var context = new NancyContext() { Response = response };

            Assert.Throws<InvalidOperationException>(() => context.XmlBody<Model>());
        }

 public static void EnableCors(this IPipelines pipelines, CorsConfiguration corsConfiguration)
 {
     pipelines.AfterRequest.AddItemToEndOfPipeline(ctx =>
     {
         UpdateResponseHeaders(ctx.Request, ctx.Response, corsConfiguration);
     });
     pipelines.OnError.AddItemToEndOfPipeline((ctx, exception) =>
     {
         if (exception == null)
         {
             // Nothing to serialize, just return default 500 response
             return HttpStatusCode.InternalServerError;
         }
         Response response;
         if (ctx.Request.Headers.Accept.Any(x => x.Item1.ToLowerInvariant().Contains("application/json")))
         {
             // Return the exception detail as JSON
             response = new JsonResponse(new ExceptionDetailObject(exception),
                 new DefaultJsonSerializer()) {StatusCode = HttpStatusCode.InternalServerError};
         }
         else
         {
             // Return the exception message as text/plain
             response = new TextResponse(HttpStatusCode.InternalServerError, exception.Message);
         }
         UpdateResponseHeaders(ctx.Request, response, corsConfiguration);
         return response;
     });
 }

        public string Upload(HttpPostedFileBase file, FormCollection forms)
        {
            var jsonResponse = new JsonResponse { Success = false };
            try
            {
                var content = new byte[file.ContentLength];
                file.InputStream.Read(content, 0, file.ContentLength);
                var indexOfLastDot = file.FileName.LastIndexOf('.');
                var extension = file.FileName.Substring(indexOfLastDot + 1, file.FileName.Length - indexOfLastDot - 1);
                var name = file.FileName.Substring(0, indexOfLastDot);

                var fileUpload = new ImageFile
                {
                    Id = string.Format("_{0}", DateTime.Now.ToString("M_dd_yyyy_H_M_s")),
                    Name = name,
                    DirectoryPath = ConfigurationManager.AppSettings["TempFilePath"],
                    ApplicationPath = System.Web.HttpContext.Current.Request.PhysicalApplicationPath,
                    Extension = extension,
                    Data = content
                };

                jsonResponse.Data = fileUpload.RelativePath;
                jsonResponse.Success = true;
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("Mensaje: {0} Trace: {1}", ex.Message, ex.StackTrace));
                jsonResponse.Message = "Ocurrio un error, por favor intente de nuevo o más tarde.";
            }

            return JsonConvert.SerializeObject(jsonResponse);
        }

 public static JsonResponse GetUploadStatus(string qid)
 {
     var j = new JsonResponse();
     // try and turn the id into a guid
     Guid id;
     if (!Guid.TryParse(qid, out id)) {
         j.Message = "Id not a valid Guid.";
         j.Error = 1;
         return j;
     }
     if(!Core.UploadStatuses.ContainsKey(id)) {
         j.Message = "Upload does not exist or status has expired.";
         j.Error = 2;
         return j;
     }
     var u = Core.UploadStatuses[id];
     j.Add("BytesRead", u.BytesRead);
     j.Add("BytesTotal", u.BytesTotal);
     j.Add("Complete", u.Complete);
     j.Add("CurrentFile", u.CurrentFile);
     j.Add("Id", u.Id);
     j.Add("LastUpdated", u.LastUpdated);
     j.Add("Message", u.Message);
     j.Add("StartedOn", u.StartedOn);
     return j;
 }

 public static JsonResponse Upload(string targetPath, IList<UploadedFile> files)
 {
     var j = new JsonResponse();
     if(files.Count>1) {
         j.Error = 1;
         j.Message = "FileManager.Upload only supports one file at a time.  Use FileManager.UploadFiles instead.";
         return j;
     }
     if (files.Count == 0) {
         j.Error = 2;
         j.Message = "Source file is missing from upload request.";
         return j;
     }
     try {
         targetPath = targetPath.Replace("~\\", Core.BaseDirectory) + files[0].OriginalFileName;
         if(File.Exists(targetPath)) {
             File.Delete(targetPath);
         }
         File.Move(files[0].Path, targetPath);
     }catch(Exception e) {
         j.Error = e.Message.GetHashCode();
         j.Message = e.Message;
         return j;
     }
     j.Error = 0;
     j.Message = "File uploaded successfully.";
     return j;
 }

        public ActionResult Create(PostViewModel post)
        {
            var response = new JsonResponse<PostViewModel>();
            var newPost = new Post();

            try
            {
                newPost.Board = _repository.GetBoardById(post.BoardId);
                newPost.Owner = _repository.GetCompetitorByUserName(post.BoardId, User.Identity.Name);
                newPost.Body = post.Body;

                _repository.Add(newPost);
                _repository.CommitChanges();

                newPost.Owner.LastViewedPostId = newPost.PostId;
                _repository.CommitChanges();

                response.Result = new PostViewModel(newPost);
            }
            catch (Exception ex)
            {
                response.Message = ex.Message;
                response.Error = true;
            }

            return (Json(response));
        }

        public string loginpage()
        {
            var jp = new JsonResponse();

            jp.result = true;
            jp.addData(this, "loginpage");

            return jp.ToString();
        }

 public void Process(ISemanticProcessor proc, IMembrane membrane, JsonResponse resp)
 {
     resp.Context.Response.StatusCode = resp.StatusCode;
     resp.Context.Response.ContentType = "text/json";
     resp.Context.Response.ContentEncoding = Encoding.UTF8;
     resp.Context.Response.ContentLength64 = resp.Json.Length;
     resp.Context.Response.OutputStream.Write(resp.Json.to_Utf8(), 0, resp.Json.Length);
     resp.Context.Response.Close();
 }

        public void Should_create_new_wrapper_from_json_response_if_not_already_present()
        {
            var response = new JsonResponse<Model>(new Model() { Dummy = "Data" });
            var context = new NancyContext() { Response = response };

            var result = context.JsonBody<Model>();

            result.Dummy.ShouldEqual("Data");
        }

        public void Should_fail_to_return_xml_body_on_non_xml_response()
        {
            var response = new JsonResponse<Model>(new Model() { Dummy = "Data" }, new DefaultJsonSerializer());
            var context = new NancyContext() { Response = response };

            var result = Record.Exception(() => context.XmlBody<Model>());

            result.ShouldNotBeNull();
        }

        /// <summary>
        /// Return a Json response to the client app
        /// </summary>
        /// <param name="response">The response object to be stringify and return to client app</param>
        public void ReturnJson(JsonResponse response)
        {
            string output = JsonConvert.SerializeObject(response);

            Response.StatusCode = 200;
            Response.Cache.SetCacheability(HttpCacheability.NoCache);
            Response.ContentType = "application/json";
            Response.Write(output);
        }

        public void Should_create_new_wrapper_from_json_response_if_not_already_present()
        {
            // Given
            var response = new JsonResponse<Model>(new Model() { Dummy = "Data" }, new DefaultJsonSerializer());
            var context = new NancyContext() { Response = response };

            // When
            var result = context.JsonBody<Model>();

            // Then
            result.Dummy.ShouldEqual("Data");
        }

        public string logout()
        {
            var jp = new JsonResponse();

            if (isLogdin)
                FormsAuthentication.SignOut();
            else
                jp.ex = "not Authenticated";

            jp.result = isLogdin;

            return jp.ToString();
        }

        public JsonResponse Execute(CreateLinkInputModel inputModel)
        {
            var response = new JsonResponse { Success = true };
            var link = new Link
                           {
                               DateAdded = DateTime.Now,
                               OriginalUrl = inputModel.OriginalUrl,
                               ShortenedUrl = _urlShortener.Shorten(inputModel.OriginalUrl)
                           };
            _repository.Insert(link);
            _repository.Save();

            return response;
        }