Exemple #1
0
        public async Task <IActionResult> AddCountry([FromBody] CountryDto country)
        {
            var existingCountry = _countryMapperRepo.GetAll().FirstOrDefault(m => m.Name == country.Name);

            if (existingCountry != null)
            {
                return(BadRequest("Country already exists"));
            }

            try
            {
                await _countryMapperRepo.Add(country);

                return(Ok(country));
            }
            catch
            {
                return(BadRequest("country cannot be added"));
            }
        }
        public async Task <IActionResult> SignUp([FromBody] UserPostDto model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (await _userManager.FindByEmailAsync(model.Email) != null)
            {
                return(BadRequest($"Account with email {model.Email} already exists"));
            }

            var user = new ApplicationUser()
            {
                UserName    = model.Email,
                PhoneNumber = model.PhoneNumber,
                Email       = model.Email
            };

            if (model.UserType == UserType.Company)
            {
                user.UserName = model.Name;
            }

            var result = await _userManager.CreateAsync(user, model.Password);

            if (!result.Succeeded)
            {
                return(BadRequest("User could not be created"));
            }

            var roleName   = model.UserType.ToString();
            var roleResult = await _userManager.AddToRoleAsync(user, roleName);

            if (!roleResult.Succeeded)
            {
                return(BadRequest($"User could not be added to role {model.UserType.ToString()}"));
            }

            UserDto dtoToReturn;

            switch (model.UserType)
            {
            case UserType.Customer:
                var dto = new CustomerDto()
                {
                    Id        = user.Id,
                    FirstName = model.FirstName,
                    LastName  = model.LastName,
                    UserType  = model.UserType,
                    Addresses = new List <AddressDto>()
                };

                dtoToReturn = await _customerRepository.Add(dto);

                break;

            case UserType.Company:
                await _addressRepository.Add(new AddressDto()
                {
                    Id           = Guid.NewGuid().ToString(),
                    AddressLine1 = model.Address.AddressLine1,
                    AddressLine2 = model.Address.AddressLine2,
                    PostalCode   = model.Address.PostalCode,
                    City         = model.Address.City,
                    UserId       = user.Id
                });

                var companyDto = new CompanyDto()
                {
                    Id       = user.Id,
                    Name     = model.Name,
                    Drivers  = new List <DriverDto>(),
                    Orders   = new List <OrderDto>(),
                    UserType = model.UserType
                };

                dtoToReturn = await _companyRepository.Add(companyDto);

                break;

            case UserType.Driver:
                var driverDto = new DriverDto()
                {
                    Id        = user.Id,
                    UserType  = model.UserType,
                    FirstName = model.FirstName,
                    LastName  = model.LastName,
                    CompanyId = model.CompanyId,
                    Latitude  = 0,
                    Longitude = 0
                };

                dtoToReturn = await _driverRepository.Add(driverDto);

                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            dtoToReturn.Email       = user.Email;
            dtoToReturn.PhoneNumber = user.PhoneNumber;

            return(Ok(dtoToReturn));
        }