static PhoneNumberUtils()
{
PhoneNumberUtil = PhoneNumberUtil.GetInstance();
RegionName = System.Globalization.RegionInfo
.CurrentRegion
.TwoLetterISORegionName;
}
/// <summary>
/// GetUserCodeWithExternalSystem method implementation for Azure MFA
/// </summary>
public int GetUserCodeWithExternalSystem(string upn, string phonenumber, string smstext, ExternalOTPProvider externalsys, CultureInfo culture)
{
ResourcesLocale Resources = new ResourcesLocale(culture.LCID);
String NumberStr = phonenumber;
int CountryCode = 0;
ulong NationalNumber = 0;
string extension = string.Empty;
PhoneNumberUtil phoneUtil = PhoneNumberUtil.GetInstance();
PhoneNumber NumberProto = phoneUtil.Parse(NumberStr, culture.TwoLetterISOLanguageName.ToUpper());
CountryCode = NumberProto.CountryCode;
NationalNumber = NumberProto.NationalNumber;
if (NumberProto.HasExtension)
{
extension = NumberProto.Extension;
}
PhoneFactor.Initialize(externalsys);
PhoneFactorParams Params = new PhoneFactorParams();
Params.Username = upn;
Params.CountryCode = CountryCode.ToString();
Params.Phone = NationalNumber.ToString();
Params.Extension = extension;
Params.ApplicationName = "IdentityServer";
Params.Sha1Salt = externalsys.Sha1Salt;
if (externalsys.IsTwoWay)
{
Params.SmsText = string.Format(Resources.GetString(ResourcesLocaleKind.Azure, "SMSTwoWayMessage"), externalsys.Company);
Params.Mode = PhoneFactor.MODE_SMS_TWO_WAY_OTP;
}
else
{
Params.SmsText = string.Format(Resources.GetString(ResourcesLocaleKind.Azure, "SMSMessage"), externalsys.Company);
Params.Mode = PhoneFactor.MODE_SMS_ONE_WAY_OTP;
}
int callStatus;
int errorId;
string otp = string.Empty;
if (PhoneFactor.Authenticate(Params, out otp, out callStatus, out errorId, externalsys.Timeout))
{
if (externalsys.IsTwoWay)
{
return((int)AuthenticationResponseKind.SmsTwoWayOTP);
}
else
{
return(Convert.ToInt32(otp));
}
}
else
{
return((int)AuthenticationResponseKind.Error);
}
}
private void YapperSignupButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty((string)NameTextBox.Text))
{
MessageBox.Show(Strings.EnterValidNameText);
return;
}
if (YapperSignupButton.Content != null && !string.IsNullOrEmpty((string)YapperSignupButton.Content))
{
try
{
string countryCode = NewUserRegistration.CountryNameToCode[(string)CountryCodeListPicker.SelectedItem];
PhoneNumberUtil pn = PhoneNumberUtil.GetInstance();
PhoneNumber phone = pn.Parse((string)PhoneNumberTextBox.Text, countryCode);
if (pn.IsValidNumber(phone))
{
((NewUserRegistrationViewModel)this.DataContext).PhoneNumberEntered = true;
PhoneNumberTextBox.Text = PhoneNumberUtil.GetInstance().Format(phone, PhoneNumberFormat.INTERNATIONAL);
}
else
{
MessageBox.Show(Strings.InvalidPhoneNumberText);
}
}
catch (Exception)
{
MessageBox.Show(Strings.InvalidPhoneNumberText);
}
}
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var model = (Register)validationContext.ObjectInstance;
if (model == null || String.IsNullOrEmpty(model.PhoneNumber))
{
return(new ValidationResult(ErrorMessage));
}
if (model == null || String.IsNullOrEmpty(model.Country))
{
return(new ValidationResult("Please provide a valid country"));
}
//phone nnumber formating addopted from
//https://stackoverflow.com/questions/30434836/how-to-convert-mobile-number-to-international-format-in-c-sharp
Country country = Countries.GetCountry(model.Country);
var util = PhoneNumberUtil.GetInstance();
PhoneNumbers.PhoneNumber pn = util.Parse(model.PhoneNumber, country.ShortName.ToUpper());
if (util.IsValidNumberForRegion(pn, country.Code.ToLower()))
{
return(ValidationResult.Success);
}
return(new ValidationResult(ErrorMessage + " For the country " + model.Country));
}
string HidePhoneNumber(string phoneNumber, int hideLimit = 5)
{
PhoneNumberUtil numberUtil = PhoneNumberUtil.GetInstance();
PhoneNumber number = numberUtil.Parse(phoneNumber, "NG");
phoneNumber = numberUtil.Format(number, PhoneNumberFormat.INTERNATIONAL);
string resultNumber = "";
int limit = phoneNumber.Length - 1;
int hiddenCount = 0;
for (int i = limit; i >= 0; i--)
{
// display the last two characters in the phone number
if (i > limit - 2)
{
resultNumber = phoneNumber[i] + resultNumber;
}
// hide the next set of numbers till the limit is reached
else if (char.IsNumber(phoneNumber[i]) && hiddenCount < hideLimit)
{
hiddenCount++;
resultNumber = "*" + resultNumber;
}
// Add everything else
else
{
resultNumber = phoneNumber[i] + resultNumber;
}
}
return(resultNumber);
}
private void VerifyPhoneForCountry()
{
PhoneNumberUtil phoneUtil = PhoneNumberUtil.GetInstance();
if (_config.Country == "SE")
{
var t = phoneUtil.Parse(mobile_no, "SE");
if (phoneUtil.IsValidNumberForRegion(t, "SE"))
{
return;
}
}
else if (_config.Country == "FI")
{
var t = phoneUtil.Parse(mobile_no, "FI");
if (phoneUtil.IsValidNumberForRegion(t, "FI"))
{
return;
}
}
else if (_config.Country == "NO")
{
var t = phoneUtil.Parse(mobile_no, "NO");
if (phoneUtil.IsValidNumberForRegion(t, "NO"))
{
return;
}
}
else
{
throw new ArgumentException("Country not supported");
}
throw new ArgumentException("Phone number incorrect");
}
public static string formatE164(string countryCode, string number)
{
if (countryCode == string.Empty || number == string.Empty)
{
return(string.Empty);
}
try
{
PhoneNumberUtil util = PhoneNumberUtil.GetInstance();
int parsedCountryCode = Convert.ToInt32(countryCode);
PhoneNumber parsedNumber = util.Parse(number,
util.GetRegionCodeForCountryCode(parsedCountryCode));
return(util.Format(parsedNumber, PhoneNumberFormat.E164));
}
catch (NumberParseException npe) {
return(string.Empty);
} catch (Exception npe)
{
return(string.Empty);
}
return("+" +
countryCode.ReplaceAll("[^0-9]", "").ReplaceAll("^0*", "") +
number.ReplaceAll("[^0-9]", ""));
}
public TestExampleNumbers()
{
invalidCases.Clear();
wrongTypeCases.Clear();
PhoneNumberUtil.ResetInstance();
phoneNumberUtil = PhoneNumberUtil.GetInstance();
}
public static string FormatPhoneNumber(string phoneNumber)
{
var phoneNumberUtil = PhoneNumberUtil.GetInstance();
var pn = phoneNumberUtil.Parse(phoneNumber, Region);
return(phoneNumberUtil.Format(pn, PhoneNumberFormat.NATIONAL));
}
public void ConfigureContainer(IUnityContainer container)
{
container.AddNewExtension <UnityFallbackProviderExtension>();
container.AddNewExtension <AutomaticBuildExtension>();
container.AddNewExtension <DeepDependencyExtension>();
container.AddNewExtension <DeepMethodExtension>();
container.RegisterInstance(new LoggerFactory().AddNLog());
container.RegisterSingleton(typeof(ILogger <>), typeof(LoggingAdapter <>));
container.RegisterType <IUserStore <User>, MongoUserStore <User, UserRole, MongoDataContext, Guid> >();
container.RegisterType <IRoleStore <UserRole>, MongoRoleStore <UserRole, MongoDataContext, Guid> >();
container.RegisterFactory <IPayStackApi>(c => new PayStackApi(c.Resolve <IOptions <PaystackOptions> >().Value.SecretKey));
container.RegisterTransient <IPaymentService, PaymentService>();
//container.RegisterType<IUserStore<User>, MongoStores.UserStore<User, UserRole>>();
//container.RegisterType<IRoleStore<UserRole>, MongoStores.RoleStore<UserRole>>();
//container.RegisterTransient<UserDataContext>();
container.RegisterFactory <MongoDataContext>(s => new MongoDataContext(ConnectionString, DatabaseName));
container.RegisterScoped <ISieveProcessor, SieveProcessor>();
container.RegisterControllers();
Core.ConfigureCoreServices(container);
container.RegisterScoped <IAuthService, AuthService>();
container.RegisterScoped <IJwtFactory, JwtFactory>();
container.RegisterScoped <IEmailService, GoogleMailService>();
container.RegisterScoped <ISmsService, SmsService>();
container.RegisterFactory <PhoneNumberUtil>(c => PhoneNumberUtil.GetInstance());
}
static Boolean parse([MarshalAs(UnmanagedType.BStr)] String number,
[MarshalAs(UnmanagedType.BStr)] String country,
[MarshalAs(UnmanagedType.BStr)] out String formatetNumber)
{
PhoneNumberUtil phoneUtil = PhoneNumberUtil.GetInstance();
try
{
PhoneNumber phonenumber = phoneUtil.Parse(number, country);
formatetNumber = phoneUtil.Format(phonenumber, PhoneNumberFormat.INTERNATIONAL);
return(true);
}
catch (Exception e)
{
formatetNumber = e.Message;
return(false);
}
// Produces "+41 44 668 18 00"
//System.out.println(phoneUtil.format(swissNumberProto, PhoneNumberFormat.INTERNATIONAL));
// Produces "044 668 18 00"
//System.out.println(phoneUtil.format(swissNumberProto, PhoneNumberFormat.NATIONAL));
// Produces "+41446681800"
//System.out.println(phoneUtil.format(swissNumberProto, PhoneNumberFormat.E164));
}
static PhoneNumberUtil InitializePhoneUtilForTesting()
{
PhoneNumberUtil.ResetInstance();
return(PhoneNumberUtil.GetInstance(
TEST_META_DATA_FILE_PREFIX,
CountryCodeToRegionCodeMapForTesting.GetCountryCodeToRegionCodeMap()));
}
public static string ToE164(this string number)
{
var util = PhoneNumberUtil.GetInstance();
var pn = util.Parse(number, "US");
return(util.Format(pn, PhoneNumberFormat.E164));
}
public static string FormatInternational(string phoneNumber, string regionCode)
{
if (string.IsNullOrEmpty(phoneNumber))
{
return(string.Empty);
}
PhoneNumber number = null;
var util = PhoneNumberUtil.GetInstance();
if (phoneNumber.StartsWith("+") || phoneNumber.StartsWith("00"))
{
if (phoneNumber.StartsWith("00"))
{
phoneNumber = "+" + phoneNumber.Remove(0, 2);
}
number = util.Parse(phoneNumber, "");
return(util.Format(number, PhoneNumberFormat.INTERNATIONAL));
}
else if (!string.IsNullOrEmpty(regionCode))
{
number = util.Parse(phoneNumber, regionCode);
return(util.Format(number, PhoneNumberFormat.INTERNATIONAL));
}
return(string.Empty);
}
public IHttpActionResult Get(string value)
{
value = System.Web.HttpContext.Current.Server.UrlDecode(value);
var util = PhoneNumberUtil.GetInstance();
if (string.IsNullOrEmpty(value))
{
return(BadRequest());
}
try
{
var number = util.Parse(value, "CA");
if (util.IsValidNumber(number))
{
return(Ok(util.FormatInOriginalFormat(number, "CA")));
}
else
{
return(BadRequest());
}
}
catch (NumberParseException)
{
return(BadRequest());
}
}
static PhoneNumberUtil InitializePhoneUtilForTesting()
{
PhoneNumberUtil.ResetInstance();
return(PhoneNumberUtil.GetInstance(
TestMetaDataFilePrefix,
CountryCodeToRegionCodeMapForTesting.GetCountryCodeToRegionCodeMap()));
}
// POST: api/libPhone
public IHttpActionResult Post([FromBody] string value)
{
var util = PhoneNumberUtil.GetInstance();
if (string.IsNullOrEmpty(value))
{
return(BadRequest());
}
try
{
var number = util.Parse(value, "CA");
if (util.IsValidNumber(number))
{
return(Ok(util.FormatInOriginalFormat(number, "CA")));
}
else
{
return(BadRequest());
}
}
catch (NumberParseException)
{
return(BadRequest());
}
}
public static async Task <string> GetPhoneHash(string phone)
{
PhoneNumber number = PhoneNumberUtil.GetInstance().Parse(phone, "US");
phone = PhoneNumberUtil.GetInstance().Format(number, PhoneNumberFormat.E164);
return(Convert.ToBase64String(await GetKey(phone, System.Text.Encoding.UTF8.GetBytes("Chadder Phone Salt"), 2000)));
}
//phonelib calls
public ParsedPhoneNumber IsPhoneNumberValid(string phoneNumber, string defaultIsoCode)
{
var parsedNumber = new ParsedPhoneNumber();
if (!string.IsNullOrEmpty(phoneNumber))
{
var phoneNumberUtil = PhoneNumberUtil.GetInstance();
parsedNumber.IsViablePhoneNumber = PhoneNumberUtil.IsViablePhoneNumber(phoneNumber);
parsedNumber.ExtractPossibleNumber = PhoneNumberUtil.ExtractPossibleNumber(phoneNumber);
parsedNumber.NormalizedNumber = PhoneNumberUtil.Normalize(phoneNumber);
parsedNumber.NormalizedDigitsOnly = PhoneNumberUtil.NormalizeDigitsOnly(phoneNumber);
if (parsedNumber.IsViablePhoneNumber.Value)
{
var numberObject = phoneNumberUtil.Parse(phoneNumber, defaultIsoCode);
parsedNumber.E164Format = phoneNumberUtil.Format(numberObject, PhoneNumberFormat.E164);
parsedNumber.IntFormat = phoneNumberUtil.Format(numberObject, PhoneNumberFormat.INTERNATIONAL);
parsedNumber.IsValidNumber = phoneNumberUtil.IsValidNumber(numberObject);
parsedNumber.CountryCode = numberObject.CountryCode;
parsedNumber.HasCountryCode = numberObject.HasCountryCode;
parsedNumber.PreferredDomesticCarrierCode = numberObject.PreferredDomesticCarrierCode;
var geocoder = PhoneNumbers.PhoneNumberOfflineGeocoder.GetInstance();
parsedNumber.GeoCoderDescription = geocoder.GetDescriptionForNumber(numberObject, PhoneNumbers.Locale.English);
parsedNumber.NumberType = phoneNumberUtil.GetNumberType(numberObject).ToString();
}
}
return(parsedNumber);
}
public void Test_SA_Number()
{
var phoneNumbersToValidate = new List <string>()
{
"+270833077082", "0833077089", "+27833077084", "+270112781905", "0117681906", "+27112781907",
"00270833077082", "(012)7681907", "99270833077082", " (012) 7681908"
};
phoneNumbersToValidate.Reverse();
foreach (string phoneNumber in phoneNumbersToValidate)
{
var numberToCheck = phoneNumber;
if (phoneNumber.StartsWith("00"))
{
numberToCheck = "+" + phoneNumber.Remove(0, 2);
}
if (phoneNumber.StartsWith("99"))
{
numberToCheck = "+" + phoneNumber.Remove(0, 2);
}
var libPhoneNumber = PhoneNumberUtil.GetInstance().Parse(numberToCheck, "ZA");
Assert.True(PhoneNumberUtil.GetInstance().IsValidNumberForRegion(libPhoneNumber, "ZA"));
}
}
void OnEntryTextChanged(object sender, TextChangedEventArgs args)
{
if (args.NewTextValue.Length == 0)
{
formatter.Clear();
((Entry)sender).Text = args.NewTextValue;
}
else
{
formatter.Clear();
string formattedNumber = "";
foreach (char digit in args.NewTextValue.Replace(" ", "").Replace("(", "").Replace(")", "").Replace("-", "").Replace("+", ""))
{
formattedNumber = formatter.InputDigit(digit);
}
PhoneNumber phoneNumber = new PhoneNumber.Builder()
.SetCountryCode(1)
.SetNationalNumber(ulong.Parse(formattedNumber.Replace(" ", "").Replace("(", "").Replace(")", "").Replace("-", "").Replace("+", "")))
.Build();
bool isValid = PhoneNumberUtil.GetInstance().IsValidNumber(phoneNumber);
((Entry)sender).TextColor = isValid ? Color.Green : Color.DarkRed;
((Entry)sender).Text = formattedNumber;
}
}
public static PhoneNumber Parse(string mobile, bool throwException)
{
try
{
var iso3166s = GetRegionInfos().Select(p => p.Name).ToList();
PhoneNumber number = null;
foreach (var iso3166 in iso3166s)
{
PhoneNumber _number = PhoneNumberUtil.GetInstance().Parse(mobile, iso3166);
if (PhoneNumberUtil.GetInstance().IsPossibleNumber(_number))
{
number = _number;
break;
}
}
return(number);
}
catch
{
if (throwException)
{
throw;
}
return(null);
}
}
public async Task <PhoneNumberViewModel> Handle(CreatePhoneNumberCommand request, CancellationToken cancellationToken = default)
{
var contact = await _db.Contacts.SingleOrDefaultAsync(c => c.Id == request.ContactId, cancellationToken);
if (contact == null)
{
throw new RequestException(nameof(request.ContactId), "Contact with specified Id not found");
}
var lib = PhoneNumberUtil.GetInstance();
var parsed = lib.Parse(request.Number, "HR");
var number = new Domain.PhoneNumber
{
ContactId = request.ContactId,
Number = lib.Format(parsed, PhoneNumberFormat.E164)
};
_db.PhoneNumbers.Add(number);
await _db.SaveChangesAsync(cancellationToken);
var result = new PhoneNumberViewModel(number);
_logger.LogDebug("Phone number {@PhoneNumber} added to contact {ContactName} with id {ContactId}", number, contact.Name, contact.Id);
var notification = new PhoneNumberAddedNotification(new ContactViewModel(contact), result);
await _mediator.Publish(notification);
return(result);
}
public static PhoneNumber ParseAndValidate(string input)
{
try
{
var phoneNumberUtil = PhoneNumberUtil.GetInstance();
var originalResult = phoneNumberUtil.Parse(input, NationalLocaleSymbol);
if (phoneNumberUtil.IsValidNumber(originalResult))
{
return(originalResult);
}
var prefixedResult = phoneNumberUtil.Parse(DefaultCityPrefix + input, NationalLocaleSymbol);
if (phoneNumberUtil.IsValidNumber(prefixedResult))
{
return(prefixedResult);
}
return(null);
}
catch (NumberParseException)
{
return(null);
}
}
public static bool IsValidPhone(string phone, string countryCode, string countryCodeName)
{
try
{
if (IsValidEmpty(phone) == false && IsValidIntgerNumber(phone) == true)
{
PhoneNumberUtil phoneUtil = PhoneNumberUtil.GetInstance();
PhoneNumber queryPhoneNumber = phoneUtil.Parse(phone, countryCodeName);
if (IsValidPhoneGoogle(phone, countryCode) == false)
{
return(false);
}
//Valid
return(phoneUtil.IsValidNumber(queryPhoneNumber));
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
/// <summary>
/// Checks if the input is an external number.
/// </summary>
/// <param name="input"></param>
/// <returns>Information about the type of number the input is</returns>
private static NumberStringType IsValidExternalNumber(string input)
{
PhoneNumberUtil util = PhoneNumberUtil.GetInstance();
NumberStringType result = NumberStringType.NOT_POSSIBLE;
if (PHONE_NUMBER_EX.Match(input).ToString() == input)
{
string numberString = FormatNumberString(input);
try {
PhoneNumber numberProto = util.Parse(numberString, Config.Instance.DefaultRegion);
if (util.IsPossibleNumber(numberProto))
{
if (util.IsValidNumber(numberProto))
{
result = NumberStringType.EXTERNAL;
}
else
{
result = NumberStringType.NOT_VALID;
}
}
} catch (Exception e) {
ClassLogger.Error(LogMessages.ErrorPhoneNumberValid, e.ToString());
result = NumberStringType.NOT_POSSIBLE;
}
}
return(result);
}
public async Task <CommandHandlingResult> Handle(ProcessSmsCommand command, IEventPublisher eventPublisher)
{
_log.WriteInfo(nameof(ProcessSmsCommand), new { Phone = command.Phone.SanitizePhone() }, "Processing sms");
var phone = command.Phone.GetValidPhone();
if (phone != null)
{
var phoneUtils = PhoneNumberUtil.GetInstance();
string countryCode = phoneUtils.GetRegionCodeForCountryCode(phone.CountryCode);
var provider = await _settingsService.GetProviderByCountryAsync(countryCode);
string id = await _smsRepository.AddAsync(new SmsMessage
{
CountryCode = countryCode,
Message = command.Message,
Phone = command.Phone,
Provider = provider
});
eventPublisher.PublishEvent(new SmsProviderProcessed
{
Phone = command.Phone,
Message = command.Message,
Provider = provider,
CountryCode = countryCode,
Id = id
});
}
return(CommandHandlingResult.Ok());
}
private static void EnsurePhoneUtil()
{
if (_phoneUtil == null)
{
_phoneUtil = PhoneNumberUtil.GetInstance();
}
}
public static bool TryParseInternational(string value, out PhoneNo res)
{
var k = PhoneNumberUtil.GetInstance();
res = null;
try
{
var p = k.Parse(value, null);
var numberType = k.GetNumberType(p);
if (numberType != PhoneNumberType.FIXED_LINE_OR_MOBILE && numberType != PhoneNumberType.MOBILE)
{
return(false);
}
res = new PhoneNo
{
InternationalValue = k.Format(p, PhoneNumberFormat.INTERNATIONAL).Replace(" ", string.Empty),
NationalValue = k.Format(p, PhoneNumberFormat.NATIONAL).Replace(" ", string.Empty),
E164Value = k.Format(p, PhoneNumberFormat.E164).Replace(" ", string.Empty),
Type = numberType,
PhoneCode = p.CountryCode,
CountryCode = k.GetRegionCodeForCountryCode(p.CountryCode)
};
return(true);
}
catch
{
return(false);
}
}
public void TestPhoneNumber_HasCharacters()
{
var phonenumberUtil = PhoneNumberUtil.GetInstance();
var example = phonenumberUtil.GetExampleNumber(Data.PhoneNumber.US_PHONE_NUMBER_REGION_KEY);
var formattedExample = phonenumberUtil.Format(example, PhoneNumberFormat.INTERNATIONAL);
var validator = new BiographicalTestClassValidator();
var instance = GetValidBiographical(() => true);
var result = validator.Validate(instance);
Assert.IsTrue(result.IsValid);
instance.PhoneNumber = "abc";
result = validator.Validate(instance);
Assert.IsFalse(result.IsValid);
Assert.AreEqual(1, result.Errors.Count);
Assert.AreEqual(
String.Format(BiographicalTestClassValidator.PHONE_NUMBER_ERROR_MESSAGE,
Data.PhoneNumberType.Visiting.Value,
instance.PhoneNumber,
validator.GetPersonType(instance),
validator.GetNameDelegate()(instance),
formattedExample),
result.Errors.First().ErrorMessage);
Assert.IsInstanceOfType(result.Errors.First().CustomState, typeof(PhoneNumberErrorPath));
}
