public HttpResponseMessage Register(HttpRequestMessage request, RegistrationViewModel user)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest, new {success = false});
                }
                else
                {
                    var _user = _membershipService.CreateUser(user.Username, user.Email, user.Password, new[] {1});

                    if (_user != null)
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new {success = true});
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new {success = false});
                    }
                }

                return response;
            });
        }
        public HttpResponseMessage Register(HttpRequestMessage request, ClientModel _clientModel)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                                                        ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                                                            .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Client newClient = new Client();
                    newClient.AsClient(_clientModel);

                    _clientRepository.Add(newClient);
                    _unitOfWork.Commit();

                    _clientModel = Mapper.Map<Client, ClientModel>(newClient);
                    response = request.CreateResponse<ClientModel>(HttpStatusCode.Created, _clientModel);
                }

                return response;
            });
        }
Exemplo n.º 3
0
        // POST: api/Entry/URL
        public async Task<HttpResponseMessage> Post(HttpRequestMessage request) 
        {
            string data = await request.Content.ReadAsStringAsync();

            string url = string.Empty;

            if (!string.IsNullOrEmpty(data))
            {
                url = HttpUtility.HtmlEncode(data.Trim());
            }

            IValidationContext context = await _validationService.UrlValid(url);

            if (!context.IsValid)
            {
                StringBuilder sb = new StringBuilder();

                foreach (string error in context.ErrorMessages)
                {
                    sb.Append(error).Append(" ");
                }

                return request.CreateResponse(HttpStatusCode.BadRequest, sb.ToString().Trim());
            }

            return request.CreateResponse(HttpStatusCode.Accepted,
                await
                    _entryService.AddEntry(new HomeModel()
                    {
                        Url = HttpUtility.HtmlEncode(url),
                        Host = request.RequestUri.Host
                    }));
        }
Exemplo n.º 4
0
        public User GetUser(HttpRequestMessage request, string userId, string sessionKey)
        {
            var users = MongoDBHelper.database.GetCollection<User>("users");
            var user = users.FindOne(Query.EQ("_id", userId));

            if (user == null)
            {
                throw new HttpResponseException(request.CreateResponse(HttpStatusCode.NotFound, new APIError("invalidUserId", "Invalid or non-existant user id")));
            }

            var key = from k in user.SessionKeys
                      where k.Key == sessionKey && k.Expires > DateTime.Now
                      select k;

            if (key.Count() == 0)
            {
                throw new HttpResponseException(request.CreateResponse(HttpStatusCode.BadRequest, new APIError("invalidSessionKey", "Invalid, expired or non-existant session key")));
            }

            user.SessionKey = key.First();

            var channels = MongoDBHelper.database.GetCollection<Channel>("channels");
            user.Channels = (
                                from c in channels.Find(Query.EQ("Users._id", user.Id))
                                select new ChannelUserAccess() { Id = c.Name, Access = c.Users.First(x => x.Id == user.Id).Access }
                            ).ToList();

            return user;
        }
Exemplo n.º 5
0
        public HttpResponseMessage Login(HttpRequestMessage request, LoginViewModel user)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (ModelState.IsValid)
                {
                    MembershipContext _userContext = _membershipService.ValidateUser(user.Username, user.Password);

                    if (_userContext.user != null)
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = false });
                    }
                }
                else
                    response = request.CreateResponse(HttpStatusCode.OK, new { success = false });

                return response;
            });
        }
        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var authenticationHeader = request.Headers.Authorization;
            HttpResponseMessage response = request.CreateResponse(HttpStatusCode.OK);

            if (authenticationHeader != null)
            {
                var scheme = authenticationHeader.Scheme;
                var token = authenticationHeader.Parameter;

                var validToken = _service.GetToken("CloudNotes", token);

                if (scheme != "Bearer" || validToken == null)
                {
                    response = request.CreateResponse(HttpStatusCode.Unauthorized);
                }
            }
            else
            {
                response = request.CreateResponse(HttpStatusCode.Unauthorized);
            }

            var tcs = new TaskCompletionSource<HttpResponseMessage>();
            tcs.SetResult(response);

            return tcs.Task;
        }
Exemplo n.º 7
0
        public HttpResponseMessage Get(HttpRequestMessage request, long id)
        {
            //this is facebook id
            if (id > int.MaxValue)
            {

                User user = this.dataService.GetUserByFacebookId(id);
                if (user == null)
                {
                    return request.CreateResponse(HttpStatusCode.NotFound);
                }
                else
                {
                    return request.CreateResponse<User>(HttpStatusCode.OK, user);
                }
            }
            else
            {
                int userId = (int) id;
                User user = this.dataService.GetUserById(userId);
                if (user == null)
                {
                    return request.CreateResponse(HttpStatusCode.NotFound);
                }
                else
                {
                    return request.CreateResponse<User>(HttpStatusCode.OK, user);
                }
            }
        }
        public HttpResponseMessage Login(HttpRequestMessage request, LoginViewModel user)
        {
            return this.CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response;

                // call fluent validator
                var validateUser = user.Validate(new ValidationContext(user, null, null));

                // if no errors returned by fluent validator, continue with the login process
                if (!validateUser.Any())
                {
                    MembershipContext _userContext = _membershipService.ValidateUser(user.Username, user.Password);

                    if (_userContext.User != null)
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = false });
                    }
                }
                else // LoginViewModel did not pass fluent validation, return unsuccessful
                    response = request.CreateResponse(HttpStatusCode.OK, new { success = false });

                return response;
            });
        }
Exemplo n.º 9
0
        public HttpResponseMessage Put(HttpRequestMessage request, int id, [FromBody]Bet bet)
        {
            if (!ModelState.IsValid)
            {
                return request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
            }
            if (id != bet.Id)
            {
                return request.CreateResponse(HttpStatusCode.BadRequest);
            }

            try
            {
                this.dataService.UpdateBet(bet);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (dataService.GetBet(id) != null)
                {
                    return request.CreateResponse(HttpStatusCode.NotFound);
                }
                else
                {
                    throw;
                }
            }
            return request.CreateResponse<Bet>(HttpStatusCode.OK, bet);
        }
        public HttpResponseMessage Login(HttpRequestMessage request, LoginViewModel model)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;
                if (ModelState.IsValid)
                {
                    var context = membershipService.ValidateUser(model.UserName, model.Password);
                    if (context.User != null)
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = true });
                    }
                    else
                    {
                        response = request.CreateResponse(HttpStatusCode.OK, new { success = false });
                    }

                }
                else
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest, new { success = false });
                }
                return response;
            });
        }
Exemplo n.º 11
0
 protected HttpResponseMessage CreateHttpRespone(HttpRequestMessage requestMessage, Func<HttpResponseMessage> function)
 {
     HttpResponseMessage response = null;
     try
     {
         response = function.Invoke();
     }
     catch (DbEntityValidationException Ex)
     {
         foreach (var eve in Ex.EntityValidationErrors)
         {
             Trace.WriteLine($"Entity of type \"{eve.Entry.Entity.GetType().Name}\"in state\"{eve.Entry.State}\"");
             foreach (var ev in eve.ValidationErrors)
             {
                 Trace.WriteLine($"-Property \"{ev.PropertyName}\", Error:\"{ev.ErrorMessage}\"");
             }
         }
         LogError(Ex);
         response = requestMessage.CreateResponse(HttpStatusCode.BadRequest, Ex.Message);
     }
     catch (DbUpdateException dbEx)
     {
         LogError(dbEx);
         response = requestMessage.CreateResponse(HttpStatusCode.BadRequest, dbEx.InnerException.Message);
     }
     catch (Exception ex)
     {
         LogError(ex);
         response = requestMessage.CreateResponse(HttpStatusCode.BadRequest, ex.Message);
     }
     return response;
 }
        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            IHttpRouteData routeData = request.GetRouteData();
            int key;
            if(!int.TryParse(routeData.Values["customerkey"].ToString(), out key)) {

                return Task.FromResult(
                    request.CreateResponse(HttpStatusCode.NotFound)
                );
            }

            var dependecyScope = request.GetDependencyScope();
            var customerRepo = (IEntityRepository<Customer>)dependecyScope.GetService(typeof(IEntityRepository<Customer>));
            var customer = customerRepo.GetSingle(key);
            if (customer == null) {

                return Task.FromResult(
                    request.CreateResponse(HttpStatusCode.NotFound)
                );
            }

            return base.SendAsync(request, cancellationToken);
        }
        protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
           CancellationToken cancellationToken)
        {
            bool isCsrf = true;
            CookieHeaderValue cookie = request.Headers
                                          .GetCookies(AntiForgeryConfig.CookieName)
                                          .FirstOrDefault();
            if (cookie != null)
            {
                Stream requestBufferedStream = request.Content.ReadAsStreamAsync().Result;
                requestBufferedStream.Position = 0;
                NameValueCollection myform = request.Content.ReadAsFormDataAsync().Result;
                requestBufferedStream.Position = 0;
                try
                {
                    AntiForgery.Validate(cookie[AntiForgeryConfig.CookieName].Value,
                     myform[AntiForgeryConfig.CookieName]);
                    isCsrf = false;
                }
                catch (Exception ex)
                {
                    return request.CreateResponse(HttpStatusCode.Forbidden);
                }
            }
            if (isCsrf)
            {
                return request.CreateResponse(HttpStatusCode.Forbidden);
            }

            return await base.SendAsync(request, cancellationToken);
        }
Exemplo n.º 14
0
 protected HttpResponseMessage GetHttpResponse(HttpRequestMessage request, Func<HttpResponseMessage> codeToExecute)
 {
     HttpResponseMessage response = null;
     try
     {
         response = codeToExecute.Invoke();
     }
     catch (SecurityException ex)
     {
         response = request.CreateResponse(HttpStatusCode.Unauthorized, ex.Message);
     }
     catch(FaultException<AuthorizationValidationException> ex)
     {
         response = request.CreateResponse(HttpStatusCode.Unauthorized, ex.Message);
     }
     catch(FaultException ex)
     {
         response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
     }
     catch(Exception ex)
     {
         response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
     }
     return response;
 }
Exemplo n.º 15
0
        // POST api/values
        public HttpResponseMessage Post(HttpRequestMessage request, TwilioRequest trequest)
        {
            Response tresp = null;
            var kuser = _session.QueryOver<KUser>().Where(x => x.Mobile == trequest.From).List().FirstOrDefault();

            //New acccount flow
            if (kuser == null)
            {
                if (_bodyParser.CommandExists("register", trequest.Body))
                    tresp = _kService.ProcessCommand("register", trequest);
                else
                {
                    tresp = _kService.ProcessCommand("newaccount", trequest);
                }
                var responsec = request.CreateResponse(HttpStatusCode.OK, tresp, new XmlMediaTypeFormatter());
                //response.Headers.Add("Location", '/api/users');
                return responsec;
            }

            tresp = _kService.ProcessCommands(trequest);

            //
            var response = request.CreateResponse(HttpStatusCode.OK, tresp, new XmlMediaTypeFormatter());
            //response.Headers.Add("Location", '/api/users');
            return response;
        }
Exemplo n.º 16
0
        protected HttpResponseMessage GetHttpResponse(HttpRequestMessage request, Func<HttpResponseMessage> codeToExecute)
        {
            HttpResponseMessage response = null;

            try
            {
                response = codeToExecute.Invoke();
            }
            catch (FluentValidation.ValidationException ex)
            {
                var result = ex.Errors.Select(item => new System.ComponentModel.DataAnnotations.ValidationResult(item.ErrorMessage, new List<string> { item.PropertyName }));
                response = request.CreateResponse(HttpStatusCode.BadRequest, result);
            }
            //catch (SecurityException ex)
            //{
            //    response = request.CreateResponse(HttpStatusCode.Unauthorized, ex.Message);
            //}
            //catch (FaultException<AuthorizationValidationException> ex)
            //{
            //    response = request.CreateResponse(HttpStatusCode.Unauthorized, ex.Message);
            //}
            //catch (FaultException ex)
            //{
            //    response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
            //}
            catch (Exception ex)
            {
                response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
            }

            return response;
        }
Exemplo n.º 17
0
        public HttpResponseMessage ValidateRegistrationStep1(HttpRequestMessage request, [FromBody]AccountRegisterModel accountModel)
        {
            return GetHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                List<string> errors = new List<string>();

                // TODO: validate other fields here in case smart-ass user tries to access this API outside of the site

                #region Commented code
                //List<State> states = UIHelper.GetStates();
                //State state = states.Where(item => item.Abbrev.ToUpper() == accountModel.State.ToUpper()).FirstOrDefault();
                //if (state == null)
                //    errors.Add("Invalid state.");

                //Match matchZipCode = Regex.Match(accountModel.ZipCode, @"^\d{5}(?:[-\s]\d{4})?$");
                //if (!matchZipCode.Success)
                //    errors.Add("Zip code is in an invalid format.");
                #endregion

                if (errors.Count == 0)
                    response = request.CreateResponse(HttpStatusCode.OK);
                else
                    response = request.CreateResponse<string[]>(HttpStatusCode.BadRequest, errors.ToArray());

                return response;
            });
        }
 public HttpResponseMessage GetMyUsers(HttpRequestMessage request)
 {
     try
     {
         var results = Repository().Query<User>().ToList();
         var users = results.Select(u => new UserModel
         {
             Id = u.Id,
             FullName = u.FirstName + ", " + u.LastName,
             UserName = u.UserName,
             Email = u.Email,
             Address1 = u.Address1,
             PhoneNumber = u.PhoneNumber,
             Status = u.UserStatus.Name,
             FirstName = u.FirstName,
             LastName = u.LastName,
             Address2 = u.Address2
         }).ToList();
         return request.CreateResponse(HttpStatusCode.OK, users.ToArray());
     }
     catch (Exception)
     {
         return request.CreateResponse(HttpStatusCode.InternalServerError, "error getting users info from db");
     }
 }
Exemplo n.º 19
0
        public HttpResponseMessage UpdateCustomerAccountInfo(HttpRequestMessage request, Account accountModel)
        {
            return GetHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                ValidateAuthorizedUser(accountModel.LoginEmail);

                List<string> errors = new List<string>();

                List<State> states = UIHelper.GetStates();
                State state = states.Where(item => item.Abbrev.ToUpper() == accountModel.State.ToUpper()).FirstOrDefault();

                if (state == null)
                    errors.Add("Invalid state.");

                // trim out the / in the exp date
                accountModel.ExpDate = accountModel.ExpDate.Substring(0, 2) + accountModel.ExpDate.Substring(3, 2);

                if (errors.Count == 0)
                {
                    _AccountService.UpdateCustomerAccountInfo(accountModel);
                    response = request.CreateResponse(HttpStatusCode.OK);
                } else
                {
                    response = request.CreateResponse<string[]>(HttpStatusCode.BadRequest, errors.ToArray());
                }

                return response;
            });
        }
        public HttpResponseMessage PrepareResponse(HttpRequestMessage request)
        {
            try
            {
                StringBuilder acknowledgement = new StringBuilder();

                acknowledgement.Append("<?xml version = \"1.0\" encoding = \"utf-8\"?>");
                acknowledgement.Append("<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">");
                acknowledgement.Append("<soapenv:Body>");
                acknowledgement.Append("<notifications xmlns=\"http://soap.sforce.com/2005/09/outbound\">");
                acknowledgement.Append("<Ack>true</Ack>");
                acknowledgement.Append("</notifications>");
                acknowledgement.Append("</soapenv:Body>");
                acknowledgement.Append("</soapenv:Envelope>");

                HttpResponseMessage response = request.CreateResponse();
                response.Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(acknowledgement.ToString())));
                response.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml");
                response.StatusCode = HttpStatusCode.OK;

                return response;
            }
            catch (Exception)
            {
                //TODO: log exception
            }

            return request.CreateResponse();

        }
        public HttpResponseMessage Add(HttpRequestMessage request, HRMFileDto hrmFileDto)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response;

                var athlete = _athleteRepository.GetSingle(hrmFileDto.AthleteId);

                if (athlete == null)
                {
                    response = request.CreateErrorResponse(HttpStatusCode.NotFound, "Invalid Athlete");
                }
                else
                {
                    try
                    {
                        _sessionRepository.Add(hrmFileDto);
                        response = request.CreateResponse(HttpStatusCode.Created);
                    }
                    catch (Exception)
                    {
                        response = request.CreateResponse(HttpStatusCode.BadRequest);
                    }
                }

                return response;
            });
        }
Exemplo n.º 22
0
        public HttpResponseMessage Create(HttpRequestMessage request, FamilyViewModel family)
        {
            return CreateHttpResponse(request, () =>
            {
                HttpResponseMessage response = null;

                if (!ModelState.IsValid)
                {
                    response = request.CreateResponse(HttpStatusCode.BadRequest,
                        ModelState.Keys.SelectMany(k => ModelState[k].Errors)
                              .Select(m => m.ErrorMessage).ToArray());
                }
                else
                {
                    Family newFamily = new Family();
                    newFamily.UpdateFamily(family);
                    _familyRepository.Add(newFamily);

                    _unitOfWork.Commit();

                    // Update view model
                    family = Mapper.Map<Family, FamilyViewModel>(newFamily);
                    response = request.CreateResponse<FamilyViewModel>(HttpStatusCode.Created, family);
                }

                return response;
            });
        }
Exemplo n.º 23
0
        public HttpResponseMessage Get(HttpRequestMessage request, ProjectListType type)
        {
            UserProfile theUser = _service.GetUserProfile(_security.GetUserId(User.Identity.Name));
            IEnumerable<ProjectListViewModel> list;

            switch (type)
            {
                case ProjectListType.IamArchitect:
                    list = _service.GetEnumerable(s => s.ArchitectId == theUser.CompanyId)
                         .Select(s => new ProjectListViewModel
                         {
                             Architect = s.Architect.CompanyName,
                             Id = s.Id,
                             Title = s.Title,
                             Number = s.Number
                         });
                    return request.CreateResponse(HttpStatusCode.OK, list);

                case ProjectListType.MyCreated:
                    list = _service.GetEnumerable(s => s.CreatedById == theUser.UserId)
                         .Select(s => new ProjectListViewModel
                         {
                             Architect = s.Architect.CompanyName,
                             Id = s.Id,
                             Title = s.Title,
                             Number = s.Number
                         });
                    return request.CreateResponse(HttpStatusCode.OK, list);

                case ProjectListType.InvitedTo:
                    // get invitations to project
                    IEnumerable<Invitation> invites = _service.GetInvitations(theUser.CompanyId);
                    // get the projects
                    var projects = invites.Select(i => i.BidPackage.Project).Distinct();
                    // convert to view model
                    list = projects.Select(p => new ProjectListViewModel
                    {
                        Id = p.Id,
                        Title = p.Title,
                        Architect = p.Architect.CompanyName,
                        Number = p.Number
                    });
                    return request.CreateResponse(HttpStatusCode.OK, list);

                case ProjectListType.Open:
                    list = _service.GetActivePublicSearchable()
                        .Select(s => new ProjectListViewModel
                        {
                            Architect = s.Architect.CompanyName,
                            Id = s.Id,
                            Title = s.Title,
                            Number = s.Number
                        });
                    return request.CreateResponse(HttpStatusCode.OK, list);

                default:
                    return request.CreateResponse(HttpStatusCode.BadRequest);
            }
        }
Exemplo n.º 24
0
 //GET: api/Rooms/5
 public HttpResponseMessage Get(HttpRequestMessage request, int id)
 {
     var room = _RoomRepo.GetAllRooms().Where(r => r.Id == id).FirstOrDefault();
     if (room != null)
         return request.CreateResponse(System.Net.HttpStatusCode.OK, room);
     else
         return request.CreateResponse(System.Net.HttpStatusCode.NoContent, room);
 }
 public HttpResponseMessage Post(HttpRequestMessage request, [FromBody]Event value)
 {
     if (ModelState.IsValid)
     {
         _eventRepository.Add(value);
         var msg = string.Format("Событие {0} успешно добавленно!", value.Title);
         return request.CreateResponse(HttpStatusCode.OK, msg);
     }
     return request.CreateResponse(HttpStatusCode.BadRequest, GetErrorMessages());
 }
        public HttpResponseMessage Get(HttpRequestMessage request, int id)
        {
            WinningItem winningItem = dataService.GetWinningItem(id);

            if (winningItem == null)
            {
                return request.CreateResponse(HttpStatusCode.NotFound);
            }
            return request.CreateResponse<WinningItem>(HttpStatusCode.OK, winningItem);
        }
 public HttpResponseMessage Delete(HttpRequestMessage request, int userId, int betId)
 {
     BetUser betUser = this.dataService.RemoveBetUser(betId, userId);
     if (betUser == null)
     {
         return request.CreateResponse(HttpStatusCode.NotFound);
     }
     string json = JsonConvert.SerializeObject(betUser);
     return request.CreateResponse<BetUser>(HttpStatusCode.OK, betUser);
 }
        public HttpResponseMessage Post(HttpRequestMessage request, [FromBody]WinningItem winningItem)
        {
            if (!ModelState.IsValid)
            {
                return request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
            }

            dataService.AddWinningItem(winningItem);
            string json = JsonConvert.SerializeObject(winningItem);
            return request.CreateResponse<WinningItem>(HttpStatusCode.OK, winningItem);
        }
Exemplo n.º 29
0
        protected HttpResponseMessage CreateHttpResponse(System.Net.Http.HttpRequestMessage request, List <Type> repos, Func <HttpResponseMessage> function)
        {
            HttpResponseMessage response = null;

            try
            {
                RequestMessage = request;
                InitRepositories(repos);
                response = function.Invoke();
            }
            catch (DbUpdateException ex)
            {
                LogError(ex);
                response = request.CreateResponse(HttpStatusCode.BadRequest, ex.InnerException.Message);
            }
            catch (Exception ex)
            {
                LogError(ex);
                response = request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
            }

            return(response);
        }
Exemplo n.º 30
0
        public static void EvalMockingErrorModeActive(JObject json, System.Net.Http.HttpRequestMessage request) {
            if (ApplicationConfiguration.IsProd()) {
                return;
            }

            var mockerror = json.Property(MockingErrorKey);
            if (mockerror == null || mockerror.Value.ToString().EqualsIc("false")) {
                return;
            }
            try {
                object a = new { };
                var b = (string)a;
            } catch (Exception e) {
                var errorResponse = request.CreateResponse(HttpStatusCode.InternalServerError, new ErrorDto(e.Message, e.StackTrace, e.StackTrace));
                throw new HttpResponseException(errorResponse);
            }
        }
Exemplo n.º 31
0
        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));
            }
        }
Exemplo n.º 32
0
        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));
            }
        }
Exemplo n.º 33
0
        protected override Task <HttpResponseMessage> SendAsync(
            System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
        {
            if (request.Method == System.Net.Http.HttpMethod.Options)
            {
                var apiExplorer = GlobalConfiguration.Configuration.Services.GetApiExplorer();

                var controllerRequested = request.GetRouteData().Values["controller"] as string;

                var supportedMethods = apiExplorer.ApiDescriptions
                                       .Where(d =>
                {
                    var controller = d.ActionDescriptor.ControllerDescriptor.ControllerName;
                    return(string.Equals(
                               controller, controllerRequested, StringComparison.OrdinalIgnoreCase));
                })
                                       .Select(d => d.HttpMethod.Method)
                                       .Distinct();

                if (supportedMethods != null && supportedMethods.Any() || (controllerRequested ?? "").Equals("ServicesV1", StringComparison.InvariantCultureIgnoreCase))
                {
                    return(Task.Factory.StartNew(() =>
                    {
                        var resp = new HttpResponseMessage(HttpStatusCode.OK);
                        resp.Headers.Add("Access-Control-Allow-Methods", string.Join(",", supportedMethods.Concat(new[] { "ServicesV1", "ValidateSettings" })));
                        resp.Headers.Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");

                        return resp;
                    }));
                }
                else
                {
                    return(Task.Factory.StartNew(() => request.CreateResponse(HttpStatusCode.NotFound)));
                }
            }

            return(base.SendAsync(request, cancellationToken));
        }
Exemplo n.º 34
0
        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 creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/> and the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="formatter">The formatter to use.</param>
        /// <param name="mediaType">The media type override to set on the response's content. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeFormatter formatter, string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeader = mediaType != null ? new MediaTypeHeaderValue(mediaType) : null;

            return(request.CreateResponse(statusCode, value, formatter, mediaTypeHeader));
        }
 /// <summary>
 /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
 /// <paramref name="value"/> and the given <paramref name="formatter"/>.
 /// </summary>
 /// <typeparam name="T">The type of the value.</typeparam>
 /// <param name="request">The request.</param>
 /// <param name="statusCode">The status code of the created response.</param>
 /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
 /// <param name="formatter">The formatter to use.</param>
 /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
 public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeFormatter formatter)
 {
     return(request.CreateResponse(statusCode, value, formatter, (MediaTypeHeaderValue)null));
 }
 /// <summary>
 /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
 /// <paramref name="value"/>. The given <paramref name="mediaType"/> is used to find an instance of <see cref="MediaTypeFormatter"/>.
 /// </summary>
 /// <typeparam name="T">The type of the value.</typeparam>
 /// <param name="request">The request.</param>
 /// <param name="statusCode">The status code of the created response.</param>
 /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
 /// <param name="mediaType">The media type used to look up an instance of <see cref="MediaTypeFormatter"/>.</param>
 /// <exception cref="InvalidOperationException">Thrown if the <paramref name="request"/> does not have an associated
 /// <see cref="HttpConfiguration"/> instance or if the configuration does not have a formatter matching <paramref name="mediaType"/>.</exception>
 /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
 public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, string mediaType)
 {
     return(request.CreateResponse(statusCode, value, new MediaTypeHeaderValue(mediaType)));
 }
 /// <summary>
 /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
 /// of <see cref="ObjectContent{T}"/> as the content if a formatter can be found. If no formatter is found, this
 /// method returns a response with status 406 NotAcceptable. This forwards the call to
 /// <see cref="CreateResponse{T}(HttpRequestMessage, HttpStatusCode, T, HttpConfiguration)"/> with a <c>null</c>
 /// configuration.
 /// </summary>
 /// <remarks>
 /// This method requires that <paramref name="request"/> has been associated with an instance of
 /// <see cref="HttpConfiguration"/>.
 /// </remarks>
 /// <typeparam name="T">The type of the value.</typeparam>
 /// <param name="request">The request.</param>
 /// <param name="statusCode">The status code of the created response.</param>
 /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
 /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
 public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value)
 {
     return(request.CreateResponse <T>(statusCode, value, configuration: null));
 }
Exemplo n.º 39
0
 /// <summary>
 /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
 /// of <see cref="ObjectContent{T}"/> as the content and <see cref="System.Net.HttpStatusCode.OK"/> as the status code
 /// if a formatter can be found. 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="HttpContext"/>.
 /// </remarks>
 /// <typeparam name="T">The type of the value.</typeparam>
 /// <param name="request">The request.</param>
 /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
 /// <returns>A response wrapping <paramref name="value"/> with <see cref="System.Net.HttpStatusCode.OK"/> status code.</returns>
 public static HttpResponseMessage CreateResponse <T>([NotNull] this HttpRequestMessage request, T value)
 {
     return(request.CreateResponse <T>(HttpStatusCode.OK, value, formatters: null));
 }
Exemplo n.º 40
0
 /// <summary>
 /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
 /// of <see cref="ObjectContent{T}"/> as the content if a formatter can be found. If no formatter is found, this
 /// method returns a response with status 406 NotAcceptable.
 /// configuration.
 /// </summary>
 /// <remarks>
 /// This method requires that <paramref name="request"/> has been associated with an instance of
 /// <see cref="HttpContext"/>.
 /// </remarks>
 /// <typeparam name="T">The type of the value.</typeparam>
 /// <param name="request">The request.</param>
 /// <param name="statusCode">The status code of the created response.</param>
 /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
 /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
 public static HttpResponseMessage CreateResponse <T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value)
 {
     return(request.CreateResponse <T>(statusCode, value, formatters: null));
 }
Exemplo n.º 41
-1
        public HttpResponseMessage Delete(HttpRequestMessage request, int projectId)
        {
            Project theProject = _service.GetProject(projectId);

            if (theProject == null)
            {
                return request.CreateResponse(HttpStatusCode.NotFound, "project not found");
            }

            int companyId = _service.GetUserProfile(_security.GetUserId(User.Identity.Name)).CompanyId;

            // get master bp because that is what gc's bid to.
            BidPackage bidPackage = theProject.BidPackages.Where(x => x.IsMaster).SingleOrDefault();

            Invitation selfInvite = _service.Get(bidPackage.Id, companyId);

            if (selfInvite == null)
            {
                return request.CreateResponse(HttpStatusCode.NotFound, "you have not proffered to join this project");
            }

            selfInvite.RejectedDate = DateTime.Now;
            selfInvite.AcceptedDate = default(DateTime?);

            if (_service.Update(selfInvite))
            {
                _notice.SendInviteResponse(bidPackage.Id);
                return request.CreateResponse(HttpStatusCode.OK, new { date = selfInvite.RejectedDate.Value.ToShortDateString() });
            }
            else
            {
                return request.CreateResponse(HttpStatusCode.InternalServerError);
            }
        }
Exemplo n.º 42
-1
        public HttpResponseMessage ChangePassword(HttpRequestMessage request, int operationResult)
        {
            Result res = new Result();
            res.result = "修改密码失败";

            var resp = request.CreateResponse(HttpStatusCode.InternalServerError, res);

            switch (operationResult)
            {
                case 1:
                    res.result = "修改密码成功";
                    resp = request.CreateResponse(HttpStatusCode.OK, res);
                    break;
                case 2:
                    res.result = "修改密码失败";
                    resp = request.CreateResponse(HttpStatusCode.InternalServerError, res);
                    break;
                case 3:
                    res.result = "旧密码错误,请输入正确的旧密码";
                    resp = request.CreateResponse(HttpStatusCode.BadRequest, res);
                    break;
                case 4:
                    res.result = "密码已过期,请联系管理员重置密码";
                    resp = request.CreateResponse(HttpStatusCode.BadRequest, res);
                    break;
                default:
                    break;
            }
            return resp;
        }