public async Task UpdateUser_ValidUser_Success()
{
// Arrange
var userRequestDtos = new UserRequestDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test Full Name",
UserName = "******",
Password = "******"
};
var userResponseDtos = new UserResponseDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test Full Name",
UserName = "******"
};
_userServiceMock.Setup(c => c.UpdateAsync(userRequestDtos.Id, userRequestDtos)).ReturnsAsync(userResponseDtos);
_usersApiController = new UsersApiController(_userServiceMock.Object, _httpContextAccessorMock.Object);
// Act
var result = await _usersApiController.Put(userRequestDtos.Id, userRequestDtos);
// Assert
var resultStatusCode = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).StatusCode;
var resultValue = (UserResponseDto)((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
Assert.Equal((int)HttpStatusCode.Accepted, resultStatusCode);
Assert.Equal(userRequestDtos.Email, resultValue.Email);
}
public async Task <IActionResult> UpdateUser([FromBody] UserResponseDto loginDto)
{
if (loginDto.Id == 0)
{
return(BadRequest(new
{
Response = new JsonResponseHandler {
ErrorMessage = AppStrings.UserIdisInvalid, IsSuccess = false,
}
}));
}
var user = await _service.GetUserById(loginDto.Id);
user.ActiveShowTime = loginDto.ActiveShowTime;
user.Contacts = loginDto.Contacts;
user.OneSignalUserId = loginDto.OneSignalUserId;
user.TwilioUserId = loginDto.TwilioUserId;
user.Status = loginDto.Status;
user.PhoneNumber = loginDto.PhoneNumber;
return(Ok(new
{
Response = new JsonResponseHandler
{
IsSuccess = true,
}
}));
}
private void Authorize()
{
UserResponseDto user = null;
try
{
user = _restApiClient.Authorize(new UserAuthorizeRequestDto
{
Login = Login.Text,
Password = Password.Password
});
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error durring login process", MessageBoxButton.OK, MessageBoxImage.Error);
}
if (user == null)
{
MessageBox.Show("Invalid User name or Password", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
UserContext.SetUser(user);
this.Hide();
MainWindow mainWindow = NinjectContainer.Container.Get <MainWindow>();
mainWindow.Owner = this.Owner;
mainWindow.ShowDialog();
this.Close();
}
public void Register_ValidUser_ReturnCreatedUser()
{
var user = new User {
Username = "******", Password = BCrypt.Net.BCrypt.GenerateSalt(12)
};
var userToReturn = new UserResponseDto {
Id = Guid.Parse("e4ce0161-4adc-46be-88b8-ea38de2274f0"), Username = "******"
};
var authServiceMock = new Mock <IAuthService>();
var userToRegister = new UserForRegisterDto {
Username = "******", Password = "******", ConfirmPassword = "******"
};
authServiceMock.Setup(u => u.Register(userToRegister)).Returns(userToReturn);
var controller = new AuthController(authServiceMock.Object);
var result = controller.Register(userToRegister);
var statusCode = ((CreatedAtActionResult)result).StatusCode;
Assert.True(statusCode == 201);
authServiceMock.VerifyAll();
}
public async Task GetMyProfile_ValidToken_NoContent()
{
// Arrange
var userId = "1";
var userResponseDtos = new UserResponseDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test Full Name",
UserName = "******"
};
IEnumerable <Claim> claims = new List <Claim>
{
new Claim(type: JwtRegisteredClaimNames.Jti, value: "2"),
new Claim(type: JwtRegisteredClaimNames.Aud, value: "testAud")
};
Mock <HttpContext> httpContextMock = new Mock <HttpContext>();
Mock <ClaimsPrincipal> userMock = new Mock <ClaimsPrincipal>();
_httpContextAccessorMock.Setup(c => c.HttpContext).Returns(httpContextMock.Object);
httpContextMock.Setup(c => c.User).Returns(userMock.Object);
userMock.Setup(c => c.Claims).Returns(claims);
_userServiceMock.Setup(c => c.GetByIdAsync(userId)).ReturnsAsync(userResponseDtos);
_usersApiController = new UsersApiController(_userServiceMock.Object, _httpContextAccessorMock.Object);
// Act
var result = await _usersApiController.Get();
// Assert
var resultStatusCode = ((Microsoft.AspNetCore.Mvc.StatusCodeResult)result).StatusCode;
Assert.Equal((int)HttpStatusCode.NoContent, resultStatusCode);
}
/// <summary>
/// Authenticates the user.
/// </summary>
/// <param name="loginDto">The login dto.</param>
/// <returns>user and password or null</returns>
public async Task <(UserResponseDto, string)> AuthenticateUser(string email)
{
UserResponseDto user = null;
string password = null;
SqlConnection _conn = _dBContext.GetConnection();
SqlCommand command = new SqlCommand("sp_users_getByEmail", _conn)
{
CommandType = System.Data.CommandType.StoredProcedure
};
command.Parameters.AddWithValue("@email", email);
await _conn.OpenAsync();
using (SqlDataReader reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
user = MapUserFromReader(reader);
password = (string)reader["password"];
}
}
await _conn.CloseAsync();
return(user, password);
}
public IDataResult <UserResponseDto> Register(UserRegisterDto userRegisterDto)
{
HashingHelper.CreatePasswordHash(userRegisterDto.Password, out byte[] passwordHash, out byte[] passwordSalt);
var user = new User
{
FirstName = userRegisterDto.FirstName,
LastName = userRegisterDto.LastName,
EMail = userRegisterDto.EMail,
PasswordHash = passwordHash,
PasswordSalt = passwordSalt
};
var result = _userService.Add(user);
var userResponse = new UserResponseDto
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
EMail = user.EMail,
};
if (!result.Success)
{
userResponse.AccessToken = null;
return(new ErrorDataResult <UserResponseDto>(userResponse));
}
userResponse.AccessToken = CreateAccessTokenMine(user);
return(new SuccessDataResult <UserResponseDto>(Messages.UserRegistered, userResponse));
}
public IDataResult <UserResponseDto> Login(UserLoginDto userLoginDto)
{
var result = _userService.GetUserByEMail(userLoginDto.EMail);
var userToCheck = result.Data;
if (!result.Success)
{
return(new ErrorDataResult <UserResponseDto>(result.Message));
}
var userResponse = new UserResponseDto
{
Id = userToCheck.Id,
FirstName = userToCheck.FirstName,
LastName = userToCheck.LastName,
EMail = userToCheck.EMail,
};
if (!HashingHelper.VerifyPasswordHash(userLoginDto.Password, userToCheck.PasswordHash, userToCheck.PasswordSalt))
{
userResponse.AccessToken = null;
return(new ErrorDataResult <UserResponseDto>(Messages.PasswordNotTrue, userResponse));
}
userResponse.AccessToken = CreateAccessTokenMine(userToCheck);
return(new SuccessDataResult <UserResponseDto>(Messages.UserLoggedIn, userResponse));
}
public async Task GetBrandAsync_Return_Ok_Result(Mock <IUserService> userService,
UserResponseDto expected)
{
// Arrange
var sut = new AccountController(userService.Object);
sut.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext()
};
userService.Setup(setup => setup.GetUserInformationAsync(userId)).Returns(Task.FromResult(expected));
// Act
var result = sut.GetUserInformationAsync(userId);
var apiResult = result.Result.Should().BeOfType <OkObjectResult>().Subject;
var model = Assert.IsType <ApiResult>(apiResult.Value);
UserResponseDto response = model.Data as UserResponseDto;
// Assert
Assert.IsType <OkObjectResult>(result.Result);
Assert.IsNotType <CreatedAtActionResult>(result.Result);
Assert.IsNotType <BadRequestObjectResult>(result.Result);
Assert.IsNotType <AcceptedAtActionResult>(result.Result);
Assert.NotNull(result.Result);
Assert.NotNull(expected);
Assert.IsAssignableFrom <UserResponseDto>(expected);
}
private IEnumerable <Claim> BuildClaims(UserResponseDto dto)
{
return(new List <Claim>
{
new Claim(Constants.UserId, dto.Id.ToString()),
new Claim(Constants.RoleId, dto.Role.ToString()),
});
}
public static void SetUser(UserResponseDto user)
{
if (_user != null)
{
throw new Exception("User already set");
}
_user = user;
}
public void Check_Dtos_UserAdd_implements_DataTransferObject()
{
var usertDto = new UserDto();
var userRequestDto = new UserRequestDto();
var userResponseDto = new UserResponseDto();
_ = Assert.IsAssignableFrom <DataTransferObject>(usertDto);
_ = Assert.IsAssignableFrom <UserDto>(userRequestDto);
_ = Assert.IsAssignableFrom <DataTransferObject>(userResponseDto);
}
public async Task <IActionResult> AddUser(UserRequestDto requestDto)
{
UserResponseDto user = await _service.AddUser(requestDto);
return(Ok(new Response <UserResponseDto>
{
StatusCode = (int)HttpStatusCode.Created,
Message = ResponseMessage.USER_ADDED,
Data = user
}));
}
public UserResponseDto Put(int id, [FromBody] UserRequestDto user)
{
UserResponseDto userResponse = new UserResponseDto()
{
id = rnd.Next(0, 10000),
FirstName = user.FirstName,
LastName = user.LastName,
};
return(userResponse);
}
public string GenerateToken(UserResponseDto dto)
{
var securityToken = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(BuildClaims(dto)),
Expires = DateTime.UtcNow.AddHours(24),
SigningCredentials = new SigningCredentials(_securityKey, SecurityAlgorithms.HmacSha256Signature)
};
var token = _tokenHandler.CreateToken(securityToken);
return(_tokenHandler.WriteToken(token));
}
public void SendEmail(string password, UserResponseDto responseDto)
{
var message = new MailMessage();
message.To.Add(responseDto.Email);
message.Subject = $"Je {Constants.ApplicationName} account is aangemaakt";
message.Body = $"Beste {responseDto.FirstName}" + ",\n\n" +
$"Er is een account voor je aangemaakt op {Constants.ApplicationName}.\n\n" +
$"Je kan de volgende gegevens gebruiken om in te loggen: \n" +
$"E-mailadres: {responseDto.Email} \n" +
$"Wachtwoord: {password} \n\n" +
$"Ga snel naar {Constants.Authentication.BaseUrl} en start met het leren programmeren!\n\n" +
"Heel veel succes!\n\n" +
$"Het {Constants.ApplicationName} team";
SendMessage(message);
}
public async Task <IActionResult> GetHealthInformationAsync(string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
userId = UserID;
}
GetUserHealthInformationResponseDto respon = new GetUserHealthInformationResponseDto();
//删除用户改变的所有基础信息数据
var resultModelList = await new HealthInformationBiz().DeleteUserHealthInformation(userId);
var result = await new HealthInformationBiz().GetHealthInformationList(userId);
var userBiz = new UserBiz();
var model = userBiz.GetUser(userId);
if (model != null)
{
UserResponseDto userInfo = new UserResponseDto
{
UserName = model.UserName,
Birthday = model.Birthday,
Gender = model.Gender,
IdentityNumber = model.IdentityNumber
};
respon.UserInfo = userInfo;
}
if (result == null)
{
return(Success(respon));
}
foreach (var item in result)
{
if (item.InformationType != HealthInformationEnum.Decimal.ToString() && item.InformationType != HealthInformationEnum.String.ToString())
{
//查询选项数据
item.OptionList = (await new HealthInformationOptionBiz().GetHealthInformationOptionAsync(item.InformationGuid)).Select(s => new HealthInformationOptionResponse
{
OptionGuid = s.OptionGuid,
OptionLabel = s.OptionLabel,
IsDefault = s.IsDefault,
Sort = s.Sort
}).OrderBy(s => s.Sort).ToList();
item.OptionValue = (await new ConsumerHealthInfoBiz().GetConsumerHealthInfoAsync(item.InformationGuid, userId))?.OptionGuids;
}
}
respon.HealthInformationList = result;
return(Success(respon));
}
/// <summary>
/// Generates jwt with custom parameters.
/// </summary>
/// <param name="account">The account.</param>
/// <param name="ExpiryTimeInMinutes">The expiry time in minutes.</param>
/// <param name="secret">The secret.</param>
/// <returns>Token</returns>
public string Encode(UserResponseDto account, int ExpiryTimeInMinutes, byte[] secret = null)
{
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.UserData, account.Id.ToString()),
new Claim(ClaimTypes.Email, account.Email),
new Claim(ClaimTypes.Role, account.Role)
}),
Expires = DateTime.UtcNow.AddMinutes(ExpiryTimeInMinutes),
SigningCredentials = new SigningCredentials(
new SymmetricSecurityKey(secret ?? secretKey),
SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
public IDataResult <UserResponseDto> GetUserResponseByEMail(string eMail)
{
var result = _userDal.Get(user => user.EMail == eMail);
if (result == null)
{
return(new ErrorDataResult <UserResponseDto>(Messages.UserNotFound));
}
var userResponse = new UserResponseDto
{
Id = result.Id,
FirstName = result.FirstName,
LastName = result.LastName,
EMail = result.EMail
};
return(new SuccessDataResult <UserResponseDto>(userResponse));
}
public async Task GetUser_ById_BadRequest()
{
var userResponseDtos = new UserResponseDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test 1",
UserName = "******"
};
_userServiceMock.Setup(c => c.GetByIdAsync(userResponseDtos.Id)).ReturnsAsync(userResponseDtos);
_usersApiController = new UsersApiController(_userServiceMock.Object, _httpContextAccessorMock.Object);
// Act
var result = await _usersApiController.Get(string.Empty);
// Assert
var resultStatusCode = ((Microsoft.AspNetCore.Mvc.StatusCodeResult)result).StatusCode;
Assert.Equal((int)HttpStatusCode.BadRequest, resultStatusCode);
}
public async Task GetUser_ById_Success()
{
var userResponseDtos = new UserResponseDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test 1",
UserName = "******"
};
_userServiceMock.Setup(c => c.GetByIdAsync(userResponseDtos.Id)).ReturnsAsync(userResponseDtos);
_usersApiController = new UsersApiController(_userServiceMock.Object, _httpContextAccessorMock.Object);
// Act
var result = await _usersApiController.Get(userResponseDtos.Id);
// Assert
var resultValue = ((Microsoft.AspNetCore.Mvc.ObjectResult)result).Value;
Assert.NotNull(result);
Assert.Equal(userResponseDtos, resultValue);
}
public static string GenerateJSONWebToken(IConfiguration config, UserResponseDto user)
{
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config["Jwt:Key"]));
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
var claims = new[]
{
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.GivenName, string.Format("{0} {1}", user.FirstName, user.LastName)),
new Claim(ClaimTypes.Role, user.RoleCode)
};
var token = new JwtSecurityToken(
config["Jwt:Issuer"],
config["Jwt:Issuer"],
claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: credentials);
return(new JwtSecurityTokenHandler().WriteToken(token));
}
/// <summary>
/// Resets the password.
/// </summary>
/// <param name="user">The user object.</param>
/// <param name="password">The password .</param>
/// <returns></returns>
public async Task <int> ResetPassword(UserResponseDto user, string password)
{
SqlConnection _conn = _dBContext.GetConnection();
SqlCommand command = new SqlCommand("sp_users_update", _conn)
{
CommandType = System.Data.CommandType.StoredProcedure
};
command.Parameters.AddWithValue("@FirstName", user.FirstName);
command.Parameters.AddWithValue("@LastName", user.LastName);
command.Parameters.AddWithValue("@email", user.Email);
command.Parameters.AddWithValue("@PhoneNumber", user.PhoneNumber);
command.Parameters.AddWithValue("@Role", user.Role);
command.Parameters.AddWithValue("@password", password);
await _conn.OpenAsync();
int result = await command.ExecuteNonQueryAsync();
await _conn.CloseAsync();
return(result);
}
public async Task <IActionResult> GetClientRequest([FromBody] UserRequestDto req)
{
var currentUser = HttpContext.GetUserId();
var CanViewDetails = identityService.IsAuthorizeTo(currentUser, Roles.ViewClientsAccounts);
var data = await identityService.GetClientAsync(req);
if (data == null)
{
return(NotFound(new BaseResponse(false, 404, "Previous request data was not found")));
}
UserResponseDto response = new UserResponseDto()
{
Data = mapper.Map <IEnumerable <ApplicationUser>, IEnumerable <ApplicationUserDto> >(data),
IsSuccess = true,
StatusCode = (int)HttpStatusCode.OK,
TotalRecord = data.Count(),
CanViewDetails = CanViewDetails,
ResponseMessage = "Request has been complited successfully"
};
return(Ok(response));
}
public void Login_ValidUser_ReturnToken()
{
var authServiceMock = new Mock <IAuthService>();
Guid userId = Guid.NewGuid();
var userToLogin = new UserForLoginDto {
Username = "******", Password = "******"
};
var user = new UserResponseDto()
{
Username = userToLogin.Username, Id = userId
};
var tokenToReturn = "D4569KRTeKj_kqdAVrAiPbpRloAfE1fqp0eVAJ-IChQcV-kv3gW-gBAzWztBEdGGY";
var loginResponseDto = new LoginResponseDto()
{
token = tokenToReturn, user = user
};
authServiceMock.Setup(u => u.Login(userToLogin.Username, userToLogin.Password)).Returns(loginResponseDto);
var controller = new AuthController(authServiceMock.Object);
var result = controller.Login(userToLogin);
var statusCode = ((OkObjectResult)result).StatusCode;
var jsonValue = JsonConvert.SerializeObject(((OkObjectResult)result).Value);
var dictionary = JsonConvert.DeserializeObject <Dictionary <object, object> >(jsonValue);
Assert.True(statusCode == 200);
Assert.Equal("D4569KRTeKj_kqdAVrAiPbpRloAfE1fqp0eVAJ-IChQcV-kv3gW-gBAzWztBEdGGY", dictionary["token"]);
authServiceMock.VerifyAll();
}
/// <summary>
/// Adds the user.
/// </summary>
/// <param name="requestDto">The request dto.</param>
/// <returns>Added user information</returns>
/// <exception cref="BookstoreException">
/// </exception>
public async Task <UserResponseDto> AddUser(UserRequestDto requestDto)
{
try
{
UserResponseDto response = null;
requestDto.Password = BCrypt.Net.BCrypt.HashPassword(requestDto.Password);
int id = await _repository.Insert(requestDto);
if (id > 0)
{
response = _mapper.Map <UserResponseDto>(requestDto);
}
response.Id = id;
return(response);
}catch (SqlException e) when(e.Number == SqlErrorNumbers.CONSTRAINT_VOILATION)
{
throw new BookstoreException(ExceptionMessages.INVALID_DATA, (int)HttpStatusCode.BadRequest);
}
catch (SqlException e) when(e.Number == SqlErrorNumbers.DUPLICATEKEY)
{
throw new BookstoreException(ExceptionMessages.ACCOUNT_ALREADY_EXISTS, (int)HttpStatusCode.BadRequest);
}
}
// [Fact]
public async Task CreateUser_ValidUser_Success()
{
// Arrange
var userRequestDtos = new UserRequestDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test Full Name",
UserName = "******",
Password = "******"
};
var userResponseDtos = new UserResponseDto
{
Id = "1",
Email = "*****@*****.**",
FullName = "Test Full Name",
UserName = "******"
};
var appUser = new ApplicationUser
{
Email = userRequestDtos.Email,
FullName = userRequestDtos.FullName,
PhoneNumber = userRequestDtos.PhoneNumber,
UserName = userRequestDtos.UserName
};
var userManagerMock = MockUserManager(new List <ApplicationUser> {
appUser
});
_userService = new UserService(userManagerMock.Object, _context);
// Act
var result = await _userService.CreateAsync(userRequestDtos);
// Assert
Assert.Equal(userResponseDtos, result);
}
/// <summary>
/// 处理授权
/// </summary>
/// <param name="context"></param>
/// <param name="requirement"></param>
/// <returns></returns>
protected override async Task HandleRequirementAsync(AuthorizationHandlerContext context, JwtAuthorizationRequirement requirement)
{
var httpContext = (context.Resource as AuthorizationFilterContext).HttpContext;
//获取授权方式
var defaultAuthenticate = await _provider.GetDefaultAuthenticateSchemeAsync();
if (defaultAuthenticate != null)
{
//验证签发的用户信息
var result = await httpContext.AuthenticateAsync(defaultAuthenticate.Name);
if (result.Succeeded)
{
httpContext.User = result.Principal;
UserResponseDto user = await new CacheHelper(_cache).GetObjectAsync <UserResponseDto>(result.Principal.Claims.FirstOrDefault(item => item.Type == "UserId").Value + 1);
context.Succeed(requirement);
string newToken = JwtHelper.RefreshTokenExpTime(_configuration, result.Principal.Claims.ToList());
//Response返回最新jwt token
httpContext.Response.Headers.Add("Authorization", newToken);
return;
}
}
context.Fail();
}
public async Task <IActionResult> Login([FromBody] UserLoginDto userLoginDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(new
{
LoginResponse =
new JsonLoginResponseHandler
{
Token = null,
Response = new JsonResponseHandler {
IsSuccess = false
}
}
}));
}
// Service Method To Check if User Exists
var userExists = await _service.UserExists(userLoginDto.Email.ToLower());
if (!userExists)
{
return(BadRequest(new
{
Token = (string)null,
Response = new JsonResponseHandler
{
ErrorMessage = AppStrings.UserDoesntExist,
IsSuccess = false,
}
}
));
}
// Service Method To Login User
var userInDb = await _service.Login(userLoginDto.Email.ToLower(), userLoginDto.Password);
if (userInDb == null)
{
return(BadRequest(new
{
Token = (string)null,
Response = new JsonResponseHandler
{
ErrorMessage = AppStrings.EmailOrPasswordInvalid,
IsSuccess = false,
}
}));
}
// Change User Status
var status = await _service.ChangeUserActiveStatusInDb(userInDb.Id, DateTime.UtcNow);
var changeContactStatusResponse = await _service.ChangeStatusForAllContactsWhereUserIsSaved(userInDb.PhoneNumber);
var notificationSendResponse = await _service.SendPushNotificationToAllActiveContactsOnStatusActive(userInDb.Id);
var userDto = new UserResponseDto
{
Id = userInDb.Id,
Email = userInDb.Email,
Password = userInDb.Password,
Name = userInDb.Name,
PhoneNumber = userInDb.PhoneNumber,
UserName = userInDb.UserName,
Token = userInDb.Token,
CreatedDate = userInDb.CreatedDate,
ActiveShowTime = userInDb.ActiveShowTime,
Contacts = userInDb.Contacts,
Status = status,
OneSignalUserId = userInDb.OneSignalUserId,
TwilioUserId = userInDb.TwilioUserId,
};
var jwtTokenHelper = new JwtTokenHelper();
var jwtToken = jwtTokenHelper.GenerateToken(userInDb);
//Add Or Retrieve Token against specific User
await _service.SaveTokenInDb(userInDb.Id, jwtToken);
return(Ok(new
{
User = userDto,
Token = jwtToken,
Response = new JsonResponseHandler
{
IsSuccess = true,
}
}
));
}
public SendChallengeCommand(long id, UserResponseDto by, UserResponseDto to, bool accepted) : base(id)
{
By = by;
To = to;
Accepted = accepted;
}
