public UserController(
     SaveUser save,
     GetTolkenUser getTolkenUser)
 {
     _save          = save;
     _getTolkenUser = getTolkenUser;
 }
예제 #2
0
        public async Task <ActionResult> Save()
        {
            string input = null;

            using (StreamReader reader = new StreamReader(Request.Body, Encoding.UTF8))
            {
                input = await reader.ReadToEndAsync();
            }
            b2cUserModel inputClaims = b2cUserModel.Parse(input);

            string apiKey    = "your-apikey";
            string apiSecret = "your-apisecret";
            string id        = inputClaims.objectid;
            string tp        = inputClaims.typingPattern;
            string quality   = "2";
            string base_url  = string.Format("https://api.typingdna.com/save/{0}", id);

            var response = await saveUser(apiKey, apiSecret, base_url, tp);

            SaveUser saveUserResponse = SaveUser.FromJson(response);

            outputModel output = new outputModel(string.Empty, HttpStatusCode.OK)
            {
                status = saveUserResponse.Status
            };

            return(Ok(output));
        }
		public BLResponse<User>  SaveUser(SaveUser user, BLRequest blRequest){

			Client.Execute(proxy=>{

				if(user.Id==default(int)){
					Rules.UserRules.ValidateOnSave(user, Users.Count(proxy));
					Users.Post(proxy,user);
				}
				else{
					Rules.UserRules.ValidateOnSave(user);
					Users.Put(proxy,user);
				}

			});

			var r = new BLResponse<User>();
			if(!IsCayita(blRequest)) 
				r.Result.Add(user);
			else
			{
				var grid = BuildUserGrid(new List<User>());
				var dr =grid.CreateRow(user);
				r.Html= dr.ToString();
			}
			return r;
		
		}
예제 #4
0
        public async Task <IActionResult> ExecuteAsync(SaveUser saveUser, CancellationToken cancellationToken)
        {
            var user = this.saveUserToUserMapper.Map(saveUser);

            user = await this.userRepository.AddAsync(user, cancellationToken).ConfigureAwait(false);

            var userViewModel = this.userToUserMapper.Map(user);

            return(new CreatedAtRouteResult(
                       UsersControllerRoute.GetUser,
                       new { userId = userViewModel.UserId },
                       userViewModel));
        }
예제 #5
0
        public async Task Seed()
        {
            _context.Database.EnsureCreated();
            var user = await _userManager.FindByEmailAsync("*****@*****.**");

            // Checking If user is not created
            if (user == null)
            {
                user = new SaveUser()
                {
                    FirstName = "Chander",
                    LastName  = "Dhall",
                    Email     = "*****@*****.**",
                    UserName  = "******"
                };

                var result = await _userManager.CreateAsync(user, "Password9!");

                if (result != IdentityResult.Success)
                {
                    throw new Exception("Unable to create user");
                }
            }
            if (!_context.Movies.Any())
            {
                // Insert new records
                var path    = Path.Combine(_env.ContentRootPath, "Data/movies.json");
                var content = File.ReadAllText(path);
                var movies  = JsonConvert.DeserializeObject <IEnumerable <Movie> >(content);
                _context.Movies.AddRange(movies);

                var movieOrder = new MovieOrder()
                {
                    OrderDateTime = DateTime.Now,
                    OrderNumber   = "123",
                    User          = user,
                    Items         = new List <MovieItem>()
                    {
                        new MovieItem()
                        {
                            Movie    = movies.Last(),
                            Quantity = 7,
                            Price    = movies.Last().Price
                        }
                    }
                };
                _context.MovieOrders.Add(movieOrder);
                _context.SaveChanges();
            }
        }
예제 #6
0
        public async Task <ActionResult> Createuser([FromBody] SaveUser newUser)
        {
            var mappedUser = this.mapper.Map <SaveUser, User>(newUser);
            var result     = await this.userService.CreateUser(mappedUser);

            if (result.Status == Ardalis.Result.ResultStatus.Ok)
            {
                return(Created($"users/{mappedUser.Id}", this.CreateUserResponse(result.Value)));
            }

            else
            {
                return(BadRequest(result.ValidationErrors));
            }
        }
예제 #7
0
        public async Task <IActionResult> ExecuteAsync(int userId, SaveUser saveUser, CancellationToken cancellationToken)
        {
            var user = await this.userRepository.GetAsync(userId, cancellationToken).ConfigureAwait(false);

            if (user is null)
            {
                return(new NotFoundResult());
            }

            this.saveUserToUserMapper.Map(saveUser, user);
            user = await this.userRepository.UpdateAsync(user, cancellationToken).ConfigureAwait(false);

            var userViewModel = this.userToUserMapper.Map(user);

            return(new OkObjectResult(userViewModel));
        }
예제 #8
0
        public User Handle(SaveUser input)
        {
            var newUser = new User
            {
                FirstName = input.FirstName,
                LastName  = input.LastName,
                Password  = input.Password,
                Email     = input.Email,
                CreatedAt = input.CreatedAt,
                Phones    = input.Phones
            };

            _context.Users.Add(newUser);
            _context.SaveChanges();

            return(newUser);
        }
예제 #9
0
        public JsonResult Signup([FromBody] SignupInput signupInput)
        {
            var listError = ValidateSignupInput(signupInput);

            if (listError.Any())
            {
                return(Json(Utils.Utils.Instance.ResultMessage(string.Join(",", listError), false, 403)));
            }

            var hasEmail = _userService.Handle(new CheckHasEmail {
                Email = signupInput.Email
            });

            if (hasEmail)
            {
                return(Json(Utils.Utils.Instance.ResultMessage("E-mail already exists", false, 403)));
            }

            var saveUser = new SaveUser
            {
                Email     = signupInput.Email,
                CreatedAt = DateTime.Now,
                FirstName = signupInput.FirstName,
                LastName  = signupInput.LastName,
                Password  = signupInput.Password,
                Phones    = signupInput.Phones.Select(s =>
                                                      new UserContact
                {
                    CodeArea    = s.AreaCode.Value,
                    CountryCode = s.CountryCode,
                    Number      = s.Number.Value
                }).ToList()
            };

            var newuser = _userService.Handle(saveUser);

            return(Json(Utils.Utils.Instance.ResultMessage($"User created successfully, userId:{newuser.Id}", true, 201)));
        }
예제 #10
0
		public BLResponse<User> Post(SaveUser request)
		{
			return Controller.SaveUser(request,BLRequest);
		}
예제 #11
0
		public BLResponse<User> Put(SaveUser request)
		{
			return Post(request);
		}
예제 #12
0
 public async Task <ActionResult <SaveUserResult> > SaveAsync([FromBody] SaveUser model)
 {
     return(Ok(await _mediator.Send(model)));
 }
예제 #13
0
 public async Task SaveUser(SaveUser user)
 {
     await _database.InsertOrReplaceAsync(user);
 }
예제 #14
0
 public ActionResult EditUser(SaveUser saveUser)
 {
     return(Send(saveUser, x => RedirectToAction("Users"), () => EditUser(new GetUser {
         Id = saveUser.Id
     })));
 }
예제 #15
0
 public Task <IActionResult> PostAsync(
     [FromServices] IPostUserCommand command,
     [FromBody] SaveUser user,
     CancellationToken cancellationToken) => command.ExecuteAsync(user, cancellationToken);