// Methods
public void Register(Registration registration)
{
#region Contracts
if (registration == null || registration.IsValid() == false)
{
throw new ArgumentException(nameof(registration));
}
#endregion
// Register
try
{
// Add
_registrationRepository.Add(registration);
// Return
return;
}
catch (DuplicateKeyException)
{
// Update
_registrationRepository.Update(registration);
// Return
return;
}
}
public void Post([FromBody] Registration Registration)
{
if (ModelState.IsValid)
{
RegistrationRepository.Add(Registration);
}
}
public void CanAddRegistration()
{
// ARRANGE
_registration = CreateRegistration();
// ACT
var newRegistration = _subjectUnderTest.Add(_registration);
// ASSERT
Assert.That(newRegistration.Id, Is.Not.EqualTo(Guid.Empty));
}
public void CanAdd()
{
SPWeb web = this.RecordAddReturnSPWeb();
SPListItem item = this.RecordAddSPListItem();
Registration registration = new Registration();
registration.Title = "UnitTest";
registration.CourseId = 1234;
registration.UserId = 100;
registration.RegistrationStatus = "Pending";
MockListItemRepository.SPListItemReturnedByGet = item;
serviceLocator.Register <IListItemRepository>(typeof(MockListItemRepository));
RegistrationRepository repository = new RegistrationRepository();
int id = repository.Add(registration, web);
Assert.AreEqual(1, id);
MockManager.Verify();
}
private static void Main(string[] args)
{
var filter = new LogFilter();
filter.AddNamespace("SipSharp.Transports.*", LogLevel.Debug);
filter.AddStandardRules();
LogFactory.Assign(new ConsoleLogFactory(filter));
var repos = new RegistrationRepository();
repos.Add(new SipUri("*****@*****.**"), "u1000067");
SwitchSharp switchSharp = new SwitchSharp();
switchSharp.RegistrationDatabase = repos;
switchSharp.AddListener(new UdpTransport(new IPEndPoint(IPAddress.Any, 5060), switchSharp.MessageFactory));
switchSharp.Start("mydomain.com");
Thread.Sleep(500000);
}
public Task Execute(params string[] args)
{
if (args.Length != 3)
{
return(Fail("Invalid arguments\r\n" + Usage));
}
var env = args[0];
var partition = args[1];
var serializedData = args[2];
Write("Parsing and validating registration object... ");
var registration = JsonConvert.DeserializeObject <RegistrationEntity>(serializedData);
WriteLine("done.");
WriteLine($"Adding registration row to env:{env} with partition key {partition}.");
var repository = new RegistrationRepository(new EnvironmentClient(env).Options);
registration.PartitionKey = partition;
registration.Timestamp = DateTime.UtcNow;
registration.ConfirmedAt = DateTime.UtcNow;
registration.RowKey = Guid.NewGuid().ToString();
if (string.IsNullOrWhiteSpace(registration.Nickname))
{
registration.Nickname = $"{registration.Lastname} {registration.Firstname}";
}
var result = repository.Add(registration);
Task.WaitAll(result);
var statusCode = result.Result.HttpStatusCode;
return(statusCode == 204 ? Task.FromResult(0) : Fail($"Insert returned HTTP status {statusCode}."));
}
public void Call()
{
var vehicles = _vehicleRepository.GetAllWithExpiredRegistration();
PrintHelpers.PrintVehicles(vehicles);
Console.WriteLine("Type vehicle id to register");
var isRead = ReadHelpers.TryReadNumber(out var vehicleId);
if (!isRead)
{
return;
}
Console.WriteLine("Enter vehicle registration date");
var registrationDate = DateTime.ParseExact(Console.ReadLine(), DateConstants.DateFormat, null);
var result = _registrationRepository.Add(registrationDate, vehicleId);
if (result == ResponseResultType.ValidationError)
{
Console.WriteLine("Registration date cannot be in future");
}
if (result == ResponseResultType.NotFound)
{
Console.WriteLine("Vehicle not found");
}
if (result == ResponseResultType.Success)
{
Console.WriteLine("Vehicle registration successfully saved");
}
Console.ReadLine();
Console.Clear();
}
public async Task <RegistrationResult> Register(RegistrationCommand cmd)
{
void log(string format, params object[] args)
{
logger.LogInformation("Register {0} ({1}): {2}", cmd.Id, cmd.Email, string.Format(format, args));
}
log("Starting registration sequence");
// Duplicate detection based on email (used to be on the queue, now do dummily here)
var all = await repository.All(cmd.Happening);
if (all.Any(r => r.Email.Equals(cmd.Email, StringComparison.OrdinalIgnoreCase)))
{
logger.LogWarning("Register {0} ({1}): Duplicate registration detected", cmd.Id, cmd.Email);
return(RegistrationResult.Duplicate);
}
var registrationEntity = new RegistrationEntity
{
PartitionKey = cmd.Happening,
RowKey = cmd.Id.ToString(),
Email = cmd.Email.ToLower(),
Mobile = cmd.Mobile,
Firstname = cmd.Firstname,
Lastname = cmd.Lastname,
Nickname = cmd.Nickname,
Timestamp = cmd.Time,
BeenThere = cmd.BeenThere,
IsMember = cmd.IsMember,
Info = cmd.Info
};
var result = await repository.Add(registrationEntity);
if (result.HttpStatusCode >= 300)
{
logger.LogError("Register {0} ({1}): Persisting registration to DB failed with status code {2}", cmd.Id, cmd.Email, result.HttpStatusCode);
return(RegistrationResult.InternalError);
}
log("Registration persisted, HTTP Status code is {0}.", result.HttpStatusCode);
// Send verification email - as this is not part of transaction doing this with queues would be pedant, but all of that was removed to reduce complexity.
log("Sending verification email");
logger.LogDebug("Using email API key {0}", options.APIKey);
var msg = MailHelper.CreateSingleEmail(
from: new EmailAddress(options.FromAddress, options.FromDisplayName),
to: new EmailAddress(cmd.Email, cmd.Firstname + " " + cmd.Lastname),
subject: options.ConfirmationSubject,
plainTextContent: string.Format(CultureInfo.CurrentCulture, options.ConfirmationTemplate, cmd.EmailValidationUrl),
htmlContent: null);
var response = await new SendGridClient(options.APIKey).SendEmailAsync(msg);
if (response.StatusCode != System.Net.HttpStatusCode.Accepted)
{
logger.LogError("Register {0} ({1}): Email sending failed, SendGrid status code was {2}.", cmd.Id, cmd.Email, response.StatusCode);
return(RegistrationResult.InternalError);
}
log("Email sent, SendGrid status code was {0}.", response.StatusCode);
return(RegistrationResult.OK);
}
public InterfaceResponse UpdateRegistration(RegisterUpdateRequest request, int accountId)
{
//this function allows the user to send their new rego details
//to update their account
var user = UserRepository.Find(accountId);
//check user is real
if (user == null)
{
return new InterfaceResponse
{
Success = false,
Message = $"User account {accountId} does not exist"
}
}
;
var record = RegistrationRepository.Find(accountId);
if (record == null)
{
//create a new record if no record exists currently
var registration = new Registration
{
AccountID = user.AccountID,
AddressLine1 = request.AddressLine1,
AddressLine2 = request.AddressLine2,
DriversLicenceID = request.LicenceNumber,
DriversLicenceState = request.LicenceState,
PhoneNumber = request.PhoneNumber,
Postcode = request.Postcode,
State = request.State,
Suburb = request.Suburb
};
RegistrationRepository.Add(registration);
}
else
{
//if a record exists override existing values
record.AccountID = user.AccountID;
user.FirstName = request.FirstName;
user.LastName = request.LastName;
//user.Email = request.Email;
record.AddressLine1 = request.AddressLine1;
record.AddressLine2 = request.AddressLine2;
record.DriversLicenceID = request.LicenceNumber;
record.DriversLicenceState = request.LicenceState;
record.PhoneNumber = request.PhoneNumber;
record.Postcode = request.Postcode;
record.State = request.State;
record.Suburb = request.Suburb;
UserRepository.Update(user);
RegistrationRepository.Update(record);
}
return(new InterfaceResponse
{
Success = true,
Message = "Registration record updated"
});
}
/// <summary>
/// Registers a user and their associated registration into the database
/// </summary>
/// <param name="request">The fields used to populate the registration</param>
/// <returns>A response indicating success or failure of the operation</returns>
public RegisterResponse Register(RegisterRequest request)
{
//ensure the user has not been registered already
if (UserRepository.FindByEmail(request.Email) != null)
{
return new RegisterResponse
{
Success = false,
Message = "Unable to register user",
Errors = new[]
{
"User is already registered"
}
}
}
;
//checks if the user is above the acceptable age
var dob = request.DateOfBirth ?? DateTime.Now; //this is because dob could be null
if (dob.Date > DateTime.Now)
{
return new RegisterResponse
{
Success = false,
Message = "You must enter a date before today's date",
Errors = new[]
{
"User does not meet the age requirement"
}
}
}
;
var minAge = DateTime.Now.AddYears(-Constants.UserMinimumAge); //minage is todays date minus 18 years
if (dob.Date > minAge.Date)
{
return new RegisterResponse
{
Success = false,
Message = "Unable to register user. You must be at least " + Constants.UserMinimumAge +
" to register",
Errors = new[]
{
"User does not meet the age requirement"
}
}
}
;
//validaite that the input phone number is within 10 digits
string phoneNo = request.PhoneNumber.Replace(" ", "");
if (phoneNo.Length > 10)
{
return new RegisterResponse
{
Success = false,
Message = "Phone number must be 10 digits long",
Errors = new[]
{
"User's phone number is not valid"
}
}
}
;
//generate a one time password
var otpgenerator = new Random();
var otpRecord = otpgenerator.Next(100000, 999999).ToString();
//register the user first
var user = new User
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Password = Encryption.EncryptString(request.Password),
OTP = otpRecord,
UserGroup = Constants.UserGroupName,
Status = Constants.UserOTPStatus
};
//Mail.SMTPMailer(request.Email, request.FirstName, otpRecord);
UserRepository.Add(user);
//populate the registration table now using the account ID of the registered user
var registration = new Registration
{
AccountID = user.AccountID,
AddressLine1 = request.AddressLine1,
AddressLine2 = request.AddressLine2,
DateOfBirth = request.DateOfBirth.Value,
DriversLicenceID = request.LicenceNumber,
DriversLicenceState = request.LicenceState,
PhoneNumber = phoneNo,
Postcode = request.Postcode,
State = request.State,
Suburb = request.Suburb
};
RegistrationRepository.Add(registration);
var emailTemplate = TemplateRepository.FindAll().FirstOrDefault();
if (emailTemplate == null)
{
return(new RegisterResponse
{
Success = false,
Message = "An error has occurred",
Errors = new[]
{
"User account registered but no email sent. No email template defined."
}
});
}
//convert the email template to replace the keys within the template
string subject = EmailKeyReplacer(emailTemplate.Subject, user);
string title = EmailKeyReplacer(emailTemplate.Title, user);
string body = EmailKeyReplacer(emailTemplate.Body, user);
string footer = EmailKeyReplacer(emailTemplate.Footer, user);
//This will send an email based on the fields passed
EmailProvider.Send(request.Email, subject, title, body, footer);
//return successful operation
return(new RegisterResponse
{
Success = true,
Message =
$"User {user.Email} has been created. An email to validate this email address will be sent shortly."
});
}
