/// <summary>
/// Validate phone
/// </summary>
/// <param name="countryCode"></param>
/// <param name="phone"></param>
/// <returns></returns>
public virtual async Task <ResultModel <PhoneNumber> > ValidatePhoneAsync(string countryCode, string phone)
{
var response = new ResultModel <PhoneNumber>();
var normalizedPhone = NormalizePhoneNumber(countryCode, phone);
var countryRequestByCallingCode = await _countryService.GetCountriesInfoByCallingCodeAsync(countryCode);
if (!countryRequestByCallingCode.IsSuccess || !countryRequestByCallingCode.Result.Any())
{
response.AddError("Country code invalid");
return(response);
}
var validPhone = false;
var message = string.Empty;
var region = "";
PhoneNumber phoneNumber = null;
foreach (var country in countryRequestByCallingCode.Result.ToList())
{
var checkPhone = PhoneVerificationUtil.Parse(normalizedPhone, country.Alpha2Code);
if (checkPhone.IsSuccess)
{
var isValid = PhoneVerificationUtil.PhoneHelper.IsValidNumber(checkPhone.Result);
if (isValid)
{
validPhone = true;
phoneNumber = checkPhone.Result;
region = country.Alpha2Code;
break;
}
var examplePhone = PhoneVerificationUtil.PhoneHelper.GetExampleNumber(country.Alpha2Code);
message = $"Invalid phone for country code, example of phone: {examplePhone.NationalNumber}";
}
else
{
message = checkPhone.Errors.FirstOrDefault()?.Message;
}
}
if (!validPhone)
{
response.AddError(message);
return(response);
}
var validatedPhone = NormalizePhoneNumber(phoneNumber.CountryCode.ToString(), phoneNumber.NationalNumber.ToString());
if (!validatedPhone.Equals(normalizedPhone))
{
var examplePhone = PhoneVerificationUtil.PhoneHelper.GetExampleNumber(region);
response.AddError($"The format on the phone is not normalized, delete spaces or other symbols, eg: {examplePhone.NationalNumber}");
return(response);
}
response.IsSuccess = true;
response.Result = phoneNumber;
return(response);
}
public async Task <ResultModel <string> > Add(TransactionPostVM model)
{
var result = new ResultModel <string>();
var transaction = new Transaction()
{
AppUserId = model.AppUserId,
DateCreated = DateTime.Now,
NumberOfUnit = model.NumberOfUnit,
OfferId = model.OfferId,
UnitPrice = model.UnitPrice,
};
try
{
_context.Transactions.Add(transaction);
await _context.SaveChangesAsync();
result.Data = "Saved Successfully";
return(result);
}
catch (Exception ex)
{
result.AddError("Error! " + ex.Message);
return(result);
}
}
public async Task <ResultModel <string> > Add(OfferPostVM model)
{
var result = new ResultModel <string>();
//check if Offer Name already exists for vendor
var check = await _context.Offers
.Where(m => m.Name == model.Name.ToUpper() && m.VendorId == model.VendorId)
.FirstOrDefaultAsync();
if (check != null)
{
result.AddError("Vendor already has Offer with this name");
return(result);
}
var offer = new Offer()
{
CanBuyMoreThanOneUnit = model.CanBuyMoreThanOneUnit,
DateCreated = DateTime.Now,
Description = model.Description,
Name = model.Name,
UnitPrice = model.UnitPrice,
VendorId = model.VendorId,
};
_context.Offers.Add(offer);
await _context.SaveChangesAsync();
result.Data = "Saved Successfully";
return(result);
}
/// <summary>
/// Check if phone is used by another user
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
public async Task <ResultModel> CheckIfPhoneIsUsedByAnotherUserAsync(PhoneNumber number)
{
if (number == null)
{
return(new InvalidParametersResultModel());
}
var response = new ResultModel();
var possibleSameUsers = await _identityUserManager.Users
.Where(x => x.PhoneNumber.EndsWith(number.NationalNumber.ToString()) ||
x.UserName.EndsWith(number.NationalNumber.ToString()))
.ToListAsync();
if (!possibleSameUsers.Any())
{
return(new SuccessResultModel <object>().ToBase());
}
var isUsedPhone = possibleSameUsers.Select(user => PhoneVerificationUtil.PhoneHelper
.IsNumberMatch(number, user.PhoneNumber))
.Any(match => match == PhoneNumberUtil.MatchType.EXACT_MATCH);
var isUsedUserName = possibleSameUsers.Select(user => PhoneVerificationUtil.PhoneHelper
.IsNumberMatch(number, user.UserName))
.Any(match => match == PhoneNumberUtil.MatchType.EXACT_MATCH);
var isSame = isUsedUserName || isUsedPhone;
response.IsSuccess = !isSame;
if (isSame)
{
response.AddError("The number is already used by another user");
}
return(response);
}
/// <summary>
/// Send sms
/// </summary>
/// <param name="authyId"></param>
/// <returns></returns>
public virtual async Task <ResultModel <string> > SendSmsAsync(string authyId)
{
if (_twilioSettings.IsTestEnv)
{
return(new SuccessResultModel <string>(PhoneVerificationResources.TEST_ENV_TEXT));
}
var result = await _client.GetAsync($"/protected/json/sms/{authyId}?force=true");
_logger.LogDebug(result.ToString());
if (!result.IsSuccessStatusCode)
{
return(new ApiNotRespondResultModel <string>());
}
var smsResponse = await result.Content.ReadAsStringAsync();
var obj = JObject.Parse(smsResponse);
var isSuccess = obj.SelectToken("success").Value <bool>();
var message = obj.SelectToken("message").Value <string>();
var res = new ResultModel <string>
{
IsSuccess = isSuccess,
Result = message
};
if (!isSuccess)
{
res.AddError(message);
}
return(res);
}
/// <summary>
/// Delete device
/// </summary>
/// <param name="deviceId"></param>
/// <returns></returns>
public virtual async Task <ResultModel> DeleteUserDeviceAsync(Guid deviceId)
{
var deviceGet = await _context.FindByIdAsync <UserDevice, Guid>(deviceId);
if (!deviceGet.IsSuccess)
{
return(deviceGet.ToBase());
}
var userIdGet = _userManager.FindUserIdInClaims();
if (!userIdGet.IsSuccess)
{
return(userIdGet.ToBase());
}
if (deviceGet.Result.UserId != userIdGet.Result)
{
var response = new ResultModel();
response.AddError("This is not your device and can't be removed");
return(response);
}
_context.Devices.Remove(deviceGet.Result);
return(await _context.PushAsync());
}
public async Task <ResultModel <string> > Update(int id, OfferPostVM model)
{
var result = new ResultModel <string>();
//check if Offer already exists
var offer = await _context.Offers
.Where(m => m.Id == id)
.FirstOrDefaultAsync();
if (offer == null)
{
result.AddError("Offer not found.");
return(result);
}
offer.CanBuyMoreThanOneUnit = model.CanBuyMoreThanOneUnit;
offer.Description = model.Description;
offer.Name = model.Name;
offer.UnitPrice = model.UnitPrice;
offer.VendorId = model.VendorId;
await _context.SaveChangesAsync();
result.Data = "Updated Successfully";
return(result);
}
public virtual async Task <ResultModel <T> > SaveAsync(T entity, Owner author)
{
var result = new ResultModel <T>(entity);
if (entity.IsDeleted)
{
result.AddError("Can't update an entity that is deleted");
return(result);
}
if (entity.Id.Equals(Guid.Empty))
{
entity.Owner = author;
entity.CreatedAt = DateTime.UtcNow;
entity.CreatedBy = author.Name;
}
else
{
entity.UpdatedAt = DateTime.UtcNow;
entity.UpdatedBy = author.Name;
}
if (entity.Id.Equals(Guid.Empty))
{
entity.Id = Guid.NewGuid();
InMemoryEntities.Add(entity.Id, entity);
}
else
{
InMemoryEntities[entity.Id] = entity;
}
return(result);
}
public ResultModel <string> ProcessPayment(ProcessPaymentViewModel model)
{
var resultModel = new ResultModel <string>();
var paymentStatusModel = new PaymentStateViewModel
{
PaymentStateEnum = Models.Enum.PaymentStateEnum.Pending,
};
model.PaymentStateViewModel = paymentStatusModel;
try
{
resultModel = SelectPaymentProcessor(model);
var response = (ProcessPayment)model;
response.PaymentState = (PaymentState)model.PaymentStateViewModel;
response.PaymentState.Status = response.PaymentState.PaymentStateEnum.GetDescription();
if (!resultModel.ErrorMessages.Any())
{
_paymentStateRepo.Insert(response.PaymentState);
_processPaymentRepo.Insert(response);
}
_unitOfWork.SaveChanges();
}
catch (Exception ex)
{
resultModel.AddError(ex.Message);
return(resultModel);
}
return(resultModel);
}
public async Task <ResultModel <string> > Add(TestimonyGroupPostVM model)
{
var result = new ResultModel <string>();
//check if Offer Name already exists for vendor
var check = await _context.TestimonyGroups
.Where(m => m.Name == model.Name.ToUpper() && m.Name == model.Name)
.FirstOrDefaultAsync();
if (check != null)
{
result.AddError("TestimonyGroup already has Offer with this name");
return(result);
}
var newObject = new TestimonyGroup()
{
Name = model.Name,
};
_context.TestimonyGroups.Add(newObject);
await _context.SaveChangesAsync();
result.Data = "Saved Successfully";
return(result);
}
public static ResultModel <string> FillDetails(this ModelStateDictionary modelState, ResultModel <string> model)
{
if (modelState == null)
{
throw new ArgumentNullException(nameof(modelState));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (modelState.IsValid)
{
return(model);
}
foreach (var modelStateKey in modelState.Keys)
{
var modelStateVal = modelState[modelStateKey];
foreach (var error in modelStateVal.Errors)
{
var key = modelStateKey;
var errorMessage = error.ErrorMessage;
var exception = error.Exception;
var message = string.IsNullOrWhiteSpace(errorMessage)
? exception?.Message
: errorMessage;
model.AddError(message, key);
}
}
return(model);
}
/// <summary>
/// Is valid email
/// </summary>
/// <param name="emailAddress"></param>
/// <returns></returns>
public async Task <ResultModel> IsValidEmailAsync(string emailAddress)
{
//TODO: Need for all smtp servers
var response = new ResultModel();
response.IsSuccess = true;
return(response);
if (!emailAddress.IsValidEmail())
{
response.AddError("Invalid email");
return(response);
}
var host = emailAddress.Split('@');
var hostname = host[1];
var addresses = ResolveDns($"smtp.{hostname}") ?? ResolveDns(hostname);
if (addresses == null)
{
}
try
{
var endPt = new IPEndPoint(addresses[0], 25);
var s = new Socket(endPt.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
await s.ConnectAsync(endPt);
if (s.Connected)
{
response.IsSuccess = true;
return(response);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
response.AddError("Invalid host for email");
return(response);
}
/// <summary>
/// Confirm device
/// </summary>
/// <param name="deviceId"></param>
/// <param name="code"></param>
/// <returns></returns>
public virtual async Task <ResultModel> ConfirmDeviceAsync(Guid?deviceId, string code)
{
if (deviceId == null || code.IsNullOrEmpty())
{
return(new InvalidParametersResultModel());
}
var device = await _context.Devices.FirstOrDefaultAsync(x => x.Id.Equals(deviceId));
if (device == null)
{
return(new ResultModel()
.AddError("Device not found")
.ToBase());
}
if (device.IsConfirmed)
{
var res = new ResultModel
{
IsSuccess = true
};
res.AddError("Device is already confirmed");
return(res);
}
var user = await _userManager.UserManager.FindByIdAsync(device.UserId.ToString());
var isValid = await _userManager.UserManager.VerifyUserTokenAsync(user, AccountActivityResources.TrackActivityTokenProvider,
AccountActivityResources.ConfirmDevicePurpose, code);
if (!isValid)
{
return(new ResultModel()
.AddError("Invalid token")
.ToBase());
}
device.IsConfirmed = true;
device.ConfirmDate = DateTime.Now;
_context.Devices.Update(device);
var dbResult = await _context.PushAsync();
if (dbResult.IsSuccess)
{
//trigger confirm new device
AccountActivityEvents.Events.DeviceConfirmed(new DeviceConfirmedEventArgs
{
DeviceId = deviceId.Value,
Device = device,
HttpContext = _accessor.HttpContext
});
}
return(dbResult);
}
public async Task <ResultModel <string> > AddVendor(VendorPostVM model)
{
var result = new ResultModel <string>();
//check if vendor already exists
var check = await _context.Vendors
.Where(m => m.Name == model.Name.ToUpper())
.FirstOrDefaultAsync();
if (check != null)
{
result.AddError("Vendor already exists with this name");
return(result);
}
var vendor = new Vendor()
{
ValidPhoneNumber = model.ValidPhoneNumber,
DateCreated = DateTime.Now,
Description = model.Description,
Name = model.Name
};
if (model.ValidPhoneNumber == Enums.Enumerations.ValidPhoneNumberPattern.StartsWith)
{
//check pattern is valid. I.E list of comma separated numbers
if (!CheckPatternIsValid(model.Pattern))
{
result.AddError("Pattern should only contain comma separated numbers.");
return(result);
}
vendor.Pattern = model.Pattern;
}
_context.Vendors.Add(vendor);
await _context.SaveChangesAsync();
result.Data = "Saved Successfully";
return(result);
}
public ResultModel <string> PaymentFor21To500Pounds(ProcessPaymentViewModel model)
{
var resultModel = new ResultModel <string>();
//For test purpose Service Availability is set to false mocking real payment service availability
resultModel.ServiceAvailable = false;
resultModel.AddError("Service unavailable");
model.PaymentStateViewModel.PaymentStateEnum = Models.Enum.PaymentStateEnum.Failed;
_unitOfWork.SaveChanges();
return(resultModel);
}
public static ResultModel <PhoneNumber> Parse(string phoneRaw, string region)
{
var response = new ResultModel <PhoneNumber>();
try
{
// Parse the number to check into a PhoneNumber object.
var phoneNumber = PhoneHelper.Parse(phoneRaw, region);
response.Result = phoneNumber;
response.IsSuccess = true;
}
catch (NumberParseException e)
{
response.AddError(e.ErrorType.ToString(), e.Message);
}
catch (Exception e)
{
response.AddError(e.Message);
}
return(response);
}
private ResultModel <string> SelectPaymentProcessor(ProcessPaymentViewModel model)
{
var resultModel = new ResultModel <string>();
if (model.Amount < 20)
{
resultModel = PaymentForLessThan20Pounds(model);
if (resultModel.ErrorMessages.Any())
{
return(resultModel);
}
return(resultModel);
}
if (model.Amount >= 21 && model.Amount <= 500)
{
resultModel = PaymentFor21To500Pounds(model);
if (!resultModel.ServiceAvailable)
{
for (int i = 0; i < 1; i++)
{
resultModel = PaymentForLessThan20Pounds(model);
if (!resultModel.ErrorMessages.Any())
{
return(resultModel);
}
}
}
return(resultModel);
}
if (model.Amount > 500)
{
resultModel = PaymentGreaterThan500Pounds(model);
if (resultModel.ErrorMessages.Any())
{
for (int i = 0; i < 3; i++)
{
resultModel = PaymentGreaterThan500Pounds(model);
if (!resultModel.ErrorMessages.Any())
{
return(resultModel);
}
}
}
return(resultModel);
}
resultModel.AddError("Could not identify payment category");
return(resultModel);
}
/// <summary>
/// Check password
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> CheckPasswordAsync(LoginViewModel model)
{
var response = new ResultModel();
var user = await _userManager.UserManager.Users.FirstOrDefaultAsync(x => x.UserName == model.UserName);
if (user == null)
{
response.AddError("User not found");
return(response);
}
var checkPassword = await _userManager.UserManager.CheckPasswordAsync(user, model.Password);
response.IsSuccess = checkPassword;
return(response);
}
public async Task <ResultModel <string> > UpdateVendor(int id, VendorPostVM model)
{
var result = new ResultModel <string>();
//check if vendor already exists
var vendor = await _context.Vendors
.Where(m => m.Id == id)
.FirstOrDefaultAsync();
if (vendor == null)
{
result.AddError("Vendor not found.");
return(result);
}
vendor.ValidPhoneNumber = model.ValidPhoneNumber;
vendor.Description = model.Description;
vendor.Name = model.Name;
if (model.ValidPhoneNumber == Enums.Enumerations.ValidPhoneNumberPattern.StartsWith)
{
//check pattern is valid. I.E list of comma separated numbers
if (!CheckPatternIsValid(model.Pattern))
{
result.AddError("Pattern should only contain comma separated numbers.");
return(result);
}
vendor.Pattern = model.Pattern;
}
await _context.SaveChangesAsync();
result.Data = "Updated Successfully";
return(result);
}
/// <summary>
/// Send confirm new device mail
/// </summary>
/// <param name="user"></param>
/// <param name="userDevice"></param>
/// <param name="context"></param>
/// <returns></returns>
public virtual async Task <ResultModel> SendConfirmNewDeviceMailAsync(GearUser user, UserDevice userDevice, HttpContext context = null)
{
var result = new ResultModel();
if (userDevice.IsConfirmed)
{
result.AddError("The device has already been confirmed");
return(result);
}
const string subject = "Confirm new device";
var templateReq = TemplateManager.GetTemplateBody("confirm_new_device");
if (!templateReq.IsSuccess)
{
return(result);
}
var code = await _userManager.UserManager.GenerateUserTokenAsync(user, AccountActivityResources.TrackActivityTokenProvider, AccountActivityResources.ConfirmDevicePurpose);
var url = _urlHelper.ActionLink("ConfirmDevice", "AccountActivity",
new
{
deviceId = userDevice.Id,
code
}, context);
var location = $"({userDevice.IpAddress}) {userDevice.Location}";
var body = templateReq.Result.Inject(new Dictionary <string, string>
{
{ "Link", url },
{ "Location", location },
{ "Device", userDevice.Platform }
});
GearApplication.BackgroundTaskQueue.PushBackgroundWorkItemInQueue(async x =>
{
var emailSender = x.InjectService <IEmailSender>();
await emailSender.SendEmailAsync(user.Email, subject, body);
});
result.IsSuccess = true;
return(result);
}
/// <summary>
/// Get template data
/// </summary>
/// <param name="templateName"></param>
/// <param name="templateType"></param>
/// <returns></returns>
public static ResultModel <string> GetTemplateBody(string templateName, TemplateType templateType = TemplateType.Html)
{
var result = new ResultModel <string>();
if (string.IsNullOrEmpty(templateName))
{
throw new ArgumentNullException($"{nameof(templateName)} is null");
}
var path = $"Templates/{templateName}.{templateType.ToString().ToLower()}_template";
Templates.TryGetValue(path, out var template);
if (!template.IsNullOrEmpty())
{
result.IsSuccess = true;
result.Result = template;
return(result);
}
var filePath = Path.Combine(AppContext.BaseDirectory, path);
if (!File.Exists(filePath))
{
return(result
.AddError("Template not found"));
}
try
{
result.Result = File.ReadAllText(filePath);
result.IsSuccess = true;
Templates.TryAdd(path, result.Result);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(result);
}
public async Task <ResultModel <string> > Update(int id, TestimonyGroupPostVM model)
{
var result = new ResultModel <string>();
//check if TestimonyGroup already exists
var oldObject = await _context.TestimonyGroups
.Where(m => m.Id == id)
.FirstOrDefaultAsync();
if (oldObject is null)
{
result.AddError("Testimony Group not found.");
return(result);
}
oldObject.Name = model.Name;
await _context.SaveChangesAsync();
result.Data = "Updated Successfully";
return(result);
}
/// <summary>
/// Create new user
/// </summary>
/// <param name="user"></param>
/// <param name="password"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateUserAsync(GearUser user, string password)
{
if (user == null)
{
return(new InvalidParametersResultModel <Guid>());
}
if (!user.Email.IsNullOrEmpty())
{
var emailUser = await UserManager.FindByEmailAsync(user.Email);
if (emailUser != null)
{
var emailFailResponse = new ResultModel <Guid>();
emailFailResponse.AddError($"User with {user.Email.ToLowerInvariant()} email already exists");
return(emailFailResponse);
}
}
var createResponse = await UserManager.CreateAsync(user, password);
var response = createResponse.ToResultModel <Guid>();
response.Result = user.Id;
if (response.IsSuccess)
{
await AddDefaultRoles(user);
IdentityEvents.Users.UserCreated(new UserCreatedEventArgs
{
Email = user.Email,
UserId = user.Id,
UserName = user.UserName
});
}
return(response);
}
/// <summary>
/// Update base user profile
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> UpdateBaseUserProfileAsync(UserProfileEditViewModel model)
{
var modelState = ModelValidator.IsValid(model);
if (!modelState.IsSuccess)
{
return(modelState);
}
var resultModel = new ResultModel();
var currentUserRequest = await _userManager.GetCurrentUserAsync();
if (!currentUserRequest.IsSuccess)
{
resultModel.Errors.Add(new ErrorModel(string.Empty, "User not found!"));
return(resultModel);
}
var currentUser = currentUserRequest.Result;
var isUsed = await _userManager.UserManager
.Users.AnyAsync(x => !x.Id.Equals(currentUser.Id) &&
!x.Email.IsNullOrEmpty() &&
x.Email.ToLowerInvariant()
.Equals(model.Email.ToLowerInvariant()));
if (isUsed)
{
resultModel.AddError("Email is used by another user");
return(resultModel);
}
currentUser.FirstName = model.FirstName;
currentUser.LastName = model.LastName;
currentUser.Birthday = model.Birthday;
currentUser.AboutMe = model.AboutMe;
currentUser.PhoneNumber = model.PhoneNumber;
currentUser.EmailConfirmed = currentUser.EmailConfirmed && model.Email.Equals(currentUser.Email);
currentUser.Email = model.Email;
if (!currentUser.EmailConfirmed)
{
EmailEvents.Events.TriggerSendConfirmEmail(new SendConfirmEmailEventArgs
{
HttpContext = _accessor.HttpContext,
Email = model.Email
});
}
var result = await _userManager.UserManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
return(resultModel);
}
resultModel.AppendIdentityErrors(result.Errors);
return(resultModel);
}