public async Task SignUpStudent_CourseCode_Not_Found()
{
ICourseService courseService = Services.GetService <ICourseService>();
IList <Student> students = new List <Student>();
Course course = new Course("HIS", "History", 3, 1)
{
Id = 1,
StudentCount = 0,
MinBirthdate = (DateTime?)null,
MaxBirthdate = (DateTime?)null,
BirthdateTickSum = 0
};
mockCourseRepository
.Setup(r => r.GetCourse(course.Code))
.Returns(Task.FromResult(course));
mockCourseRepository
.Setup(r => r.GetStudents(course.Code))
.Returns(Task.FromResult(students));
SignUpInput signUpInput = new SignUpInput("!@#$xpto123", "José da Silva", new DateTime(1998, 4, 3));
await courseService.SignUpStudent(signUpInput);
}
public async Task SignUpStudent_With_Full_Enrollment()
{
ICourseService courseService = Services.GetService <ICourseService>();
Course course = new Course("HIS", "History", 5, 1)
{
Id = 1
};
IList <Student> students = new List <Student>
{
new Student("Student 1", new DateTime(1990, 01, 01)),
new Student("Student 2", new DateTime(1990, 01, 01)),
new Student("Student 3", new DateTime(1990, 01, 01)),
new Student("Student 4", new DateTime(1990, 01, 01)),
new Student("Student 5", new DateTime(1990, 01, 01))
};
mockCourseRepository
.Setup(r => r.GetCourse(course.Code))
.Returns(Task.FromResult(course));
mockCourseRepository
.Setup(r => r.GetStudents(course.Code))
.Returns(Task.FromResult(students));
SignUpInput signUpInput = new SignUpInput(course.Code, "José da Silva", new DateTime(1990, 1, 1));
await courseService.SignUpStudent(signUpInput);
mockCourseRepository.Verify(x => x.UpdateCourseStats(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <DateTime?>(), It.IsAny <DateTime?>(), It.IsAny <long>()), Times.Never());
mockIEmailService.Verify(x => x.SendSignupEnrollmentFull(course, signUpInput), Times.Once());
}
public async Task <User> SignUpUserAsync(SignUpInput userData)
{
if (await usersRepository.FirstOrDefaultAsync(u => u.Phone == userData.Phone) != null)
{
throw new BadInputException("user already exists");
}
if (!await smsService.CodeIsValidAsync(userData.Phone, userData.SmsCode))
{
throw new BadInputException("code is invalid");
}
// it would be better to move this somewhere
var user = mapper.Map <User>(userData);
user.Roles = new[] { "client", "worker" };
user.DateOfRegistration = DateTime.Now;
user.Profile.Phone = user.Phone;
var worker = new Worker {
StatusId = (int)WorkersStatuses.Offline
};
// linq2db can't save both entities in 1 method call
worker.Id = user.Profile.Id = user.Id = await usersRepository.InsertWithIdAsync(user);
await profilesRepository.InsertAsync(user.Profile);
await workersRepository.InsertAsync(worker);
return(user);
}
public void EnqueueSignUpMessage(SignUpInput input)
{
ConnectionFactory factory = new ConnectionFactory
{
UserName = RABBITMQ_USERNAME,
Password = RABBITMQ_PASSWORD,
VirtualHost = RABBITMQ_VIRTUAL_HOST,
HostName = RABBITMQ_HOSTNAME
};
try
{
IConnection rabbitMQConnection = factory.CreateConnection();
var channel = rabbitMQConnection.CreateModel();
var json = JsonConvert.SerializeObject(input);
byte[] messageBodyBytes = System.Text.Encoding.UTF8.GetBytes(json);
channel.BasicPublish(exchangeName, routingKey, null, messageBodyBytes);
channel.Close();
rabbitMQConnection.Close();
}
catch (Exception exc)
{
logger.LogError(exc.ToString());
throw;
}
}
public async Task SignUpStudent(SignUpInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
Course course = await dbSet.Where(c => c.Code == input.CourseCode).SingleOrDefaultAsync();
if (course == null)
{
throw new ArgumentException("Course code not found.");
}
var student = new Student(input.Name, input.BirthDate);
context.Set <Enrollment>().Add(new Enrollment(course, student));
var saved = false;
while (!saved)
{
try
{
await context.SaveChangesAsync();
saved = true;
}
catch (DbUpdateConcurrencyException ex)
{
foreach (var entry in ex.Entries)
{
if (entry.Entity is Enrollment)
{
var proposedValues = entry.CurrentValues;
var databaseValues = entry.GetDatabaseValues();
foreach (var property in proposedValues.Properties)
{
var proposedValue = proposedValues[property];
var databaseValue = databaseValues[property];
// TODO: decide which value should be written to database
// proposedValues[property] = <value to be saved>;
}
entry.OriginalValues.SetValues(databaseValues);
}
else
{
throw new NotSupportedException(
$"Don't know how to handle exception for '{entry.Metadata.Name}'");
}
}
}
}
}
public async Task <SignInOutput> ExecuteAsync(SignUpInput input)
{
await AssertLoginIsNotBusyAsync(input.Login);
var encryptedPassword = PasswordEncoder.Encrypt(input.Password);
var user = new UserEntity(input.FirstName, input.LastName, input.Login, encryptedPassword, UserRole.Client);
await UserRepository.SaveAndFlushAsync(user);
return(new SignInOutput(user, TokenService.CreateToken(user)));
}
public void ListenToMessages()
{
ConnectionFactory factory = new ConnectionFactory
{
UserName = "******",
Password = "******",
VirtualHost = "/",
HostName = "localhost"
};
IConnection rabbitMQConnection = factory.CreateConnection();
var channel = rabbitMQConnection.CreateModel();
channel.ExchangeDeclare(exchangeName, ExchangeType.Direct);
channel.QueueDeclare(queueName, false, false, false, null);
channel.QueueBind(queueName, exchangeName, routingKey, null);
while (!_cancellationToken.IsCancellationRequested)
{
bool noAck = false;
BasicGetResult result = channel.BasicGet(queueName, noAck);
if (result == null)
{
// No message available at this time.
}
else
{
IBasicProperties props = result.BasicProperties;
byte[] body = result.Body;
var json = System.Text.Encoding.UTF8.GetString(body);
_logger.LogInformation($"*** MESSAGE RECEIVED ***: " + json);
//...
// acknowledge receipt of the message
channel.BasicAck(result.DeliveryTag, false);
SignUpInput signUpInput = null;
try
{
signUpInput = JsonConvert.DeserializeObject <SignUpInput>(json);
// Enqueue a background work item
ProcessInput(signUpInput);
}
catch (Exception exc)
{
_logger.LogError(exc,
$"Error occurred executing 'signUpInput'.");
}
}
}
channel.Close();
_rabbitMQConn.Close();
}
public async Task SignUpStudent(SignUpInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
var course = await courseRepository.GetCourse(input.CourseCode);
if (course == null)
{
throw new CourseCodeNotFoundException();
}
var students = await courseRepository.GetStudents(input.CourseCode);
if (students.Contains(new Student(input.Name, input.BirthDate)))
{
emailService.SendSignupStudentAlreadyEnrolled(course, input);
return;
}
if (students.Count >= course.MaxStudentCount)
{
emailService.SendSignupEnrollmentFull(course, input);
return;
}
await courseRepository.SignUpStudent(input);
int studentCount = course.StudentCount + 1;
DateTime minBirthdate = course.MinBirthdate ?? DateTime.MaxValue;
if (DateTime.Compare(input.BirthDate, minBirthdate) < 0)
{
minBirthdate = input.BirthDate;
}
DateTime maxBirthdate = course.MaxBirthdate ?? DateTime.MinValue;
if (DateTime.Compare(maxBirthdate, input.BirthDate) < 0)
{
maxBirthdate = input.BirthDate;
}
long birthdateTickSum = course.BirthdateTickSum + input.BirthDate.Ticks;
await courseRepository.UpdateCourseStats(input.CourseCode, studentCount, minBirthdate, maxBirthdate, birthdateTickSum);
emailService.SendSignupSuccess(course, input);
}
public async Task <IActionResult> SignUpUser([FromBody] SignUpInput userData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = await authService.SignUpUserAsync(userData);
var tokens = await authService.GenerateAndStoreTokensAsync(user);
var tokenVM = mapper.Map <TokenVM>((tokens, user));
return(Ok(tokenVM));
}
private void ProcessInput(SignUpInput signUpInput)
{
_taskQueue.QueueBackgroundWorkItem(async token =>
{
var guid = Guid.NewGuid().ToString();
_logger.LogInformation(
$"RUNNING: Queued Background Task - CourseCode: {signUpInput.CourseCode}, Name: {signUpInput.Name}, BirthDate: {signUpInput.BirthDate}");
await _courseService.SignUpStudent(signUpInput);
_logger.LogInformation(
$"COMPLETED: Queued Background Task - CourseCode: {signUpInput.CourseCode}, Name: {signUpInput.Name}, BirthDate: {signUpInput.BirthDate}");
});
}
public async Task <IActionResult> SignUpAsync([FromBody] SignUpInput userData)
{
if (!ModelState.IsValid)
{
string errors = JsonConvert.SerializeObject(ModelState.Values
.SelectMany(state => state.Errors)
.Select(error => error.ErrorMessage));
throw new BadInputException(101, errors);
}
await authService.SignUpUserAsync(userData);
return(Ok());
}
public IActionResult SignUp([FromBody] SignUpInput input)
{
ApiResponse response;
var command = new SignUpCommand(input.UserName, input.Password);
var result = RabbitMq.Publish <SignUpCommand, Result <SignUpResult> >(command);
if (!result.IsSucceeded)
{
response = new ApiResponse(result.Error.Code, result.Error.Description);
return(BadRequest(response));
}
response = new ApiResponse("OK", "Success");
return(Ok(response));
}
public async Task SignUpStudent_One_Place_Left()
{
ICourseService courseService = Services.GetService <ICourseService>();
IList <Student> students = new List <Student>
{
new Student("Student 1", new DateTime(1990, 2, 1)),
new Student("Student 2", new DateTime(1995, 3, 2))
};
Course course = new Course("HIS", "History", 3, 1)
{
Id = 1,
StudentCount = students.Count(),
MinBirthdate = students.Min(s => s.BirthDate),
MaxBirthdate = students.Max(s => s.BirthDate),
BirthdateTickSum = students.Sum(s => s.BirthDate.Ticks)
};
mockCourseRepository
.Setup(r => r.GetCourse(course.Code))
.Returns(Task.FromResult(course));
mockCourseRepository
.Setup(r => r.GetStudents(course.Code))
.Returns(Task.FromResult(students));
SignUpInput signUpInput = new SignUpInput(course.Code, "José da Silva", new DateTime(1998, 4, 3));
await courseService.SignUpStudent(signUpInput);
mockCourseRepository.Verify(x => x.GetCourse(course.Code), Times.Once());
mockCourseRepository.Verify(x => x.GetStudents(course.Code), Times.Once());
mockCourseRepository.Verify(x => x.SignUpStudent(signUpInput), Times.Once());
mockCourseRepository.Verify(x =>
x.UpdateCourseStats(
signUpInput.CourseCode,
3,
new DateTime(1990, 2, 1),
new DateTime(1998, 4, 3),
new DateTime(1990, 2, 1).Ticks +
new DateTime(1995, 3, 2).Ticks +
new DateTime(1998, 4, 3).Ticks
)
, Times.Once());
mockIEmailService.Verify(x => x.SendSignupSuccess(course, signUpInput), Times.Once());
}
public async Task SignUpStudent_First_Student()
{
ICourseService courseService = Services.GetService <ICourseService>();
IList <Student> students = new List <Student>();
Course course = new Course("HIS", "History", 3, 1)
{
Id = 1,
StudentCount = 0,
MinBirthdate = (DateTime?)null,
MaxBirthdate = (DateTime?)null,
BirthdateTickSum = 0
};
SignUpInput signUpInput = new SignUpInput(course.Code, "José da Silva", new DateTime(1998, 4, 3));
mockCourseRepository
.Setup(r => r.GetCourse(course.Code))
.Returns(Task.FromResult(course));
mockCourseRepository
.Setup(r => r.GetStudents(course.Code))
.Returns(Task.FromResult(students));
await courseService.SignUpStudent(signUpInput);
mockCourseRepository.Verify(x => x.GetCourse(course.Code), Times.Once());
mockCourseRepository.Verify(x => x.GetStudents(course.Code), Times.Once());
mockCourseRepository.Verify(x => x.SignUpStudent(signUpInput), Times.Once());
mockCourseRepository.Verify(x =>
x.UpdateCourseStats(
signUpInput.CourseCode,
1,
signUpInput.BirthDate,
signUpInput.BirthDate,
signUpInput.BirthDate.Ticks
)
, Times.Once());
mockIEmailService.Verify(x => x.SendSignupSuccess(course, signUpInput), Times.Once());
}
public async Task SignUpUserAsync(SignUpInput userData)
{
using (var db = new DbContext())
{
if (await db.Users.AnyAsync(u => u.Email == userData.EMail))
{
throw new BadInputException(100, "user already exists");
}
}
var user = mapper.Map <User>(userData);
user.Roles = new[] { "client" };
user.Hash = GeneratePassword(userData.EMail, userData.Password);
user.DateOfRegistration = DateTime.Now;
using (var db = new DbContext())
{
await db.InsertAsync(user);
}
}
public object SignUp(SignUpInput input)
{
_account.email = input.Email;
_account.password = input.Password;
if (isAccountValid(_account))
{
return(JObject.Parse(Properties.Resources.AccountValidError));
}
_account.OTP = CreateOTP();
if (_mailService.SendEmail(_account.OTP, _account.email))
{
SaveDatabase(_account);
return(JObject.FromObject(new { email = _account.email, message = Properties.Resources.SentEmailMessage }));
}
else
{
return(JObject.FromObject(new { error = Properties.Resources.SendMailError }));
}
}
public async Task <IActionResult> SignUp([FromBody] SignUpInput input)
{
if (input == null || !ModelState.IsValid)
{
return(BadRequest());
}
var user = new ApplicationUser
{
UserName = input.Email,
Email = input.Email,
Name = input.Name,
PhoneNumber = input.PhoneNo,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, input.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new SignUpOutput
{
Errors = errors, IsRegisterationSuccessful = false
}));
}
var roleResult = await _userManager.AddToRoleAsync(user, SD.Role_Customer);
if (!roleResult.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return(BadRequest(new SignUpOutput
{
Errors = errors, IsRegisterationSuccessful = false
}));
}
return(StatusCode(201));
}
public void SendSignupStudentAlreadyEnrolled(Course course, SignUpInput signUpInput)
{
logger.LogInformation($"STUDENT_ALREADY_ENROLLED email was sent to: {signUpInput.Name}");
}
public void Post([FromBody] SignUpInput input)
{
messageQueueClientService.EnqueueSignUpMessage(input);
}
public async Task <SignInOutput> SignUp([FromServices] SignUpCommand command, [FromBody] SignUpInput input)
{
return(await command.ExecuteAsync(input));
}
public void SendSignupSuccess(Course course, SignUpInput signUpInput)
{
logger.LogInformation($"SUCCESS sign up email was sent to: {signUpInput.Name}");
}
public void SendSignupEnrollmentFull(Course course, SignUpInput signUpInput)
{
logger.LogInformation($"ENROLLMENT_FULL email was sent to: {signUpInput.Name}");
}
public IHttpActionResult CreateAccount([FromBody] SignUpInput input)
{
var result = _signupService.SignUp(input);
return(Ok(result));
}
public async Task <IActionResult> SignUp([FromForm] SignUpInput request)
{
return(await _dispatcher.DispatchAsync(request));
}
public SignUpViewModel()
{
SignUpInput = new SignUpInput();
}
