public async Task OnConfiguredAsync(App app, string id, ConfiguredIntegration configured, ConfiguredIntegration?previous,
CancellationToken ct)
{
var accountSid = AccountSidProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(accountSid))
{
return;
}
var authToken = AuthTokenProperty.GetString(configured);
if (string.IsNullOrWhiteSpace(authToken))
{
return;
}
var phoneNumber = PhoneNumberProperty.GetNumber(configured);
if (phoneNumber == 0)
{
return;
}
try
{
var client = clientPool.GetServer(accountSid, authToken);
await PhoneNumberResource.FetchAsync(ConvertPhoneNumber(phoneNumber), client : client);
}
catch
{
throw new ValidationException(Texts.Twilio_ErrorInvalidConfig);
}
}
/// <summary>
/// Validate a Phone Number Async using Twilio API.
/// </summary>
/// <param name="configuration"> The Configuration which will be provided to the twilio api. Ex.(Sid, AuthorizationToken)</param>
/// <param name="phoneNumber">The phone number who will be Validated</param>
/// <param name="messageBody"> The Content of the message body</param>
/// <returns>True if the send operation succeed false otherwise</returns>
public async Task ValidatePhoneNumberAsync(ISmsRequestConfiguration configuration, string phoneNumber)
{
try
{
TwilioClient.Init(configuration.AccountSid, configuration.AuthorizationToken);
var result = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new PhoneNumber(phoneNumber)
);
}
catch (ApiException ex)
{
Log.Error(ex, ex.Message, ex);
}
catch (CertificateValidationException ex)
{
Log.Error(ex, ex.Message, ex);
}
catch (RestException ex)
{
Log.Error(ex, ex.Message, ex);
}
catch (TwilioException ex)
{
Log.Error(ex, ex.Message, ex);
}
catch (Exception ex)
{
Log.Error(ex, ex.Message, ex);
}
}
public async Task <PhoneNrInfo> GetPhoneNrInfo(string phoneNr)
{
// https://www.twilio.com/docs/lookup/quickstart
PhoneNumberResource phoneNumber = null;
var isValid = false;
try
{
phoneNumber = await PhoneNumberResource.FetchAsync(
client : lookUpClient,
pathPhoneNumber : new Twilio.Types.PhoneNumber(phoneNr),
type : new List <string> {
"carrier"
}
);
isValid = true;
}
catch (ApiException ex)
{
isValid = false;
}
var r = new PhoneNrInfo
{
IsValid = isValid,
CountryCode = phoneNumber?.CountryCode,
NationalFormat = phoneNumber?.NationalFormat,
PhoneNr = phoneNumber?.PhoneNumber.ToString(),
TypeOfNumber = getTypeOfNr(phoneNumber)
};
PhoneNrInfo.TypeOfNumberEnum getTypeOfNr(PhoneNumberResource phNrResource)
{
if (phNrResource?.Carrier == null)
{
return(PhoneNrInfo.TypeOfNumberEnum.Unknown);
}
else if (phNrResource.Carrier.TryGetValue("type", out var type))
{
if (type == "mobile")
{
return(PhoneNrInfo.TypeOfNumberEnum.Mobile);
}
else
{
return(PhoneNrInfo.TypeOfNumberEnum.Other);
}
}
else
{
return(PhoneNrInfo.TypeOfNumberEnum.Unknown);
}
};
return(r);
}
public async static Task <bool> VerifyPhoneNumberAsync(PhoneNumber phoneNumber)
{
try
{
// Verify phone number
await PhoneNumberResource.FetchAsync(
countryCode : "US",
pathPhoneNumber : phoneNumber
);
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task SendWhatsapp(string body, List <string> recipients)
{
TwilioClient.Init(_options.AccountSID, _options.AuthToken);
foreach (var item in recipients)
{
var phoneResult = await PhoneNumberResource.FetchAsync(
countryCode : "KH",
pathPhoneNumber : new Twilio.Types.PhoneNumber(item)
);
var result = await MessageResource.CreateAsync(
body : body,
from : new Twilio.Types.PhoneNumber("whatsapp:" + _options.PhoneNumber),
to : new Twilio.Types.PhoneNumber("whatsapp:" + phoneResult.PhoneNumber)
);
}
}
public async Task <(string phoneNumber, string country)> ValidateNumberAsync(string phoneNumber, string countryCode, CancellationToken token)
{
phoneNumber = BuildPhoneNumber(phoneNumber, countryCode);
try
{
var result = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : phoneNumber,
type : new List <string>()
{
"carrier"
}
);
if (result == null)
{
return(null, null);
}
var carrier = result.Carrier;
if (carrier.TryGetValue("type", out var carrierType))
{
if (!string.Equals(carrierType, "mobile", StringComparison.OrdinalIgnoreCase))
{
return(null, null);
}
}
if (carrier.TryGetValue("name", out var carrierName))
{
if (_badProviders.Contains(carrierName, StringComparer.OrdinalIgnoreCase))
{
return(null, null);
}
}
return(result.PhoneNumber.ToString(), result.CountryCode);
}
catch (Twilio.Exceptions.ApiException)
{
return(null, null);
}
}
private static async Task <string> ParseNumberAsync(string number)
{
number = new string(number.Where(c => char.IsDigit(c)).ToArray());
if (number.Length == 10 && number.Substring(0, 2) == "15")
{
number = "11" + number.Substring(2, 8);
}
var phoneNumber = await PhoneNumberResource.FetchAsync(
countryCode : "AR",
pathPhoneNumber : new PhoneNumber(number));
var result = phoneNumber.PhoneNumber.ToString();
if (result.Length >= 5 && result.Substring(0, 5) == "+5411")
{
result = "+54911" + result.Substring(5, result.Length - 5);
}
return(result);
}
private static async Task <bool> IsTwilioVerified(string num)
{
bool IsValid = false;
var config = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();
// Find your Account Sid and Token at twilio.com/console. See http://twil.io/secure for more info
string accountSid = config["AppSettings:accountSid"];
string authToken = config["AppSettings:authToken"];
try
{
// Find your Account Sid and Token at twilio.com/console. See http://twil.io/secure for more info
TwilioClient.Init(accountSid, authToken);
// Reference: https://www.twilio.com/docs/lookup/tutorials/validation-and-formatting
var phoneNum = new Twilio.Types.PhoneNumber(num);
var numInfo = await PhoneNumberResource.FetchAsync(countryCode : "US",
pathPhoneNumber : phoneNum);
Console.WriteLine($"Twilio Verified Phone Number: { numInfo.PhoneNumber }");
if (numInfo.PhoneNumber.ToString().Length >= 1)
{
IsValid = true;
}
}
catch (ApiException e)
{
Console.WriteLine($"Twilio Error {e.Code} - {e.MoreInfo}");
}
catch (Exception ex)
{
Console.WriteLine("Error:" + ex.Message);
throw;
}
return(IsValid);
}
/// <summary>
/// Invokes Twilio client to test string provided as argument. Checks for errors or problem responses, only returning values that are validated.
/// </summary>
/// <param name="numberToTest"></param>
/// <returns></returns>
private async Task <string> VerifyWithTwilioAsync(string numberToTest)
{
try
{
var twilioPhoneNumberResource = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(numberToTest)
);
if (twilioPhoneNumberResource == null || twilioPhoneNumberResource.PhoneNumber == null)
{
Console.WriteLine($"TwilioHelperService : Using number '{numberToTest}', Twilio Api response was null");
return(String.Empty);
}
Console.WriteLine($"TwilioHelperService : Using number '{numberToTest}', Twilio Api returned valid object: National Format : '{twilioPhoneNumberResource.NationalFormat}' . Carrier : '{twilioPhoneNumberResource.Carrier}' . Phone Number : {twilioPhoneNumberResource.PhoneNumber}");
return(twilioPhoneNumberResource.PhoneNumber.ToString());
}
catch (Exception ex)
{
Console.WriteLine($"TwilioHelperService : Exception : {ex.Message}");
return(String.Empty);
}
}
public static async Task <PhoneNumberResource> LookupPhoneNumber(ITwilioRestClient client, string number, CountryCode?countryCode, bool includeCallerName, bool includeCarrier, List <string> addOns, Dictionary <string, object> addOnsData)
{
var phoneNumber = new Twilio.Types.PhoneNumber(number);
var type = new List <string>();
if (includeCallerName)
{
type.Add("caller_name");
}
if (includeCarrier)
{
type.Add("carrier");
}
var options = new FetchPhoneNumberOptions(phoneNumber)
{
CountryCode = countryCode != null ? $"{countryCode:G}" : null,
Type = type,
AddOns = addOns,
AddOnsData = addOnsData
};
return(await PhoneNumberResource.FetchAsync(options, client));
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
if (!String.IsNullOrWhiteSpace(txtPhoneRaw.Text))
{
try
{
lblStatus.Content = "Verifying with Twilio";
var phoneNumber = await PhoneNumberResource.FetchAsync(
countryCode : txtCountryCode.Text,
pathPhoneNumber : new Twilio.Types.PhoneNumber(txtPhoneRaw.Text));
txtPhoneVerified.Text = phoneNumber.PhoneNumber.ToString();
if (!String.IsNullOrEmpty(txtPhoneVerified.Text))
{
lblStatus.Content = "Verified by Twilio";
}
}
catch (ApiException apiex)
{
Debug.WriteLine($"Twilio API Error {apiex.Code} - {apiex.MoreInfo}");
lblStatus.Content = $"{apiex.Message}";
}
}
}
public async Task <IActionResult> AddOns()
{
TwilioClient.Init(_settings.AccountSid, _settings.AuthToken);
var addOns = new List <string>
{
"payfone_tcpa_compliance"
};
var addOnsData = new Dictionary <string, object>
{
{ "payfone_tcpa_compliance.right_party_contacted_date", 20160101 }
};
var phoneNumber = await PhoneNumberResource.FetchAsync(
addOns : addOns,
addOnsData : addOnsData,
pathPhoneNumber : new PhoneNumber(_settings.MyNumber)
);
Debug.WriteLine(phoneNumber.CallerName);
return(Ok());
}
public async Task <IActionResult> RegisterUser(UtilisateurViewModel model, string returnUrl)
{
ViewData["countries"] = AvailableCountries;
model.ExternalLogins = (await signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
model.ReturnUrl = returnUrl;
if (ModelState.IsValid)
{
try
{
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(model.Telephone),
countryCode : model.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null && numberDetails.Carrier.GetType().Equals(""))
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le format du numero ne convient pas à votre pays");
return(View());
}
var numberToSave = numberDetails.PhoneNumber.ToString();
var user = new Utilisateur
{
BirthDate = model.BirthDate,
Country = model.PhoneNumberCountryCode,
UserName = model.Email,
Email = model.Email,
Nom = model.Nom,
Prenom = model.Prenom,
PhoneNumber = numberToSave
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action("ConfirmEmail", "Account",
new { userId = user.Id, token = token }, Request.Scheme, Request.Host.ToString());
//sending email
var mailMessage = new MimeMessage();
mailMessage.From.Add(new MailboxAddress("from TourME", "*****@*****.**"));
mailMessage.To.Add(new MailboxAddress("Client", model.Email));
mailMessage.Subject = "Email Confirmation";
mailMessage.Body = new TextPart("plain")
{
Text = $"{confirmationLink}"
};
using (var smtpClient = new SmtpClient())
{
smtpClient.CheckCertificateRevocation = false;
smtpClient.Connect("smtp.gmail.com", 587, SecureSocketOptions.Auto);
smtpClient.Authenticate("*****@*****.**", "wiss20/20");
smtpClient.Send(mailMessage);
smtpClient.Disconnect(true);
}
//
//await emailService.SendAsync(model.Email,"Email Verification", $"<a href=\"{confirmationLink}\">Verify Email</a>" ,true);
logger.Log(LogLevel.Warning, confirmationLink);
if (await roleManager.RoleExistsAsync("Utilisateur"))
{
await userManager.AddToRoleAsync(user, "Utilisateur");
}
else
{
IdentityRole identityrole = new IdentityRole
{
Name = "Utilisateur"
};
await roleManager.CreateAsync(identityrole);
await userManager.AddToRoleAsync(user, "Utilisateur");
}
//await signInManager.SignInAsync(user, isPersistent: false);
//return RedirectToAction("index", "home");
ViewBag.ErrorTitle = "Registration successful";
ViewBag.ErrorMessage = "Before you can Login, please confirm your " +
"email, by clicking on the confirmation link we have emailed you";
return(View("Error"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"The number you entered was not valid (Twilio code {ex.Code}), please check it and try again");
return(View());
}
}
return(View(model));
}
public async Task <IActionResult> RegisterCommercant(CommercentViewModel model)
{
ViewData["countries"] = AvailableCountries;
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.FileP != null)
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "Files");
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.FileP.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
model.FileP.CopyTo(new FileStream(filePath, FileMode.Create));
}
//phone
try
{
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(model.Telephone),
countryCode : model.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null && numberDetails.Carrier.GetType().Equals(""))
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le format du numero ne convient pas à votre pays");
return(View());
}
var numberToSave = numberDetails.PhoneNumber.ToString();
var user = new Commerçant
{
UserName = model.Email,
PhoneNumber = numberToSave,
PersAContact = model.PersAContact,
Email = model.Email,
FormeJuridique = model.Forme,
Secteur = model.Secteur,
DomainActivite = model.Domaine,
SituationEntreprise = model.SituationEntreprise,
EffectFemme = model.EffectFemme,
EffectHomme = model.EffectHomme,
Type = model.Type,
Patente = uniqueFileName,
Country = model.PhoneNumberCountryCode
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
System.Diagnostics.Debug.WriteLine("Country is" + model.PhoneNumberCountryCode);
if (await roleManager.RoleExistsAsync("Commercant"))
{
await userManager.AddToRoleAsync(user, "Commercant");
}
else
{
IdentityRole identityrole = new IdentityRole
{
Name = "Commercant"
};
await roleManager.CreateAsync(identityrole);
await userManager.AddToRoleAsync(user, "Commercant");
}
var token = await userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = Url.Action("ConfirmEmail", "Account",
new { userId = user.Id, token = token }, Request.Scheme, Request.Host.ToString());
//sending email
var mailMessage = new MimeMessage();
mailMessage.From.Add(new MailboxAddress("from TourME", "*****@*****.**"));
mailMessage.To.Add(new MailboxAddress("Client", model.Email));
mailMessage.Subject = "Email Confirmation";
mailMessage.Body = new TextPart("plain")
{
Text = $"{confirmationLink}"
};
using (var smtpClient = new SmtpClient())
{
smtpClient.CheckCertificateRevocation = false;
smtpClient.Connect("smtp.gmail.com", 587, SecureSocketOptions.Auto);
smtpClient.Authenticate("*****@*****.**", "wiss20/20");
smtpClient.Send(mailMessage);
smtpClient.Disconnect(true);
}
//
ViewBag.ErrorTitle = "Registration successful";
ViewBag.ErrorMessage = "Before you can Login, please confirm your " +
"email, by clicking on the confirmation link we have emailed you";
return(View("Error"));
//await signInManager.SignInAsync(user, isPersistent: false);
// return RedirectToAction("CreateExperience", "Experience");
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le numéro entré n'est pas valide (Code d'erreur {ex.Code})");
return(View());
}
}
return(View());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
//var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
//if (Input.PhoneNumber != phoneNumber)
//{
// var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
// if (!setPhoneResult.Succeeded)
// {
// StatusMessage = "Unexpected error when trying to set phone number.";
// return RedirectToPage();
// }
//}
if (Input.FirstName != user.FirstName)
{
user.FirstName = Input.FirstName;
}
if (Input.LastName != user.LastName)
{
user.LastName = Input.LastName;
}
if (Input.Address != user.Address)
{
user.Address = Input.Address;
}
// twilio
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != null && Input.PhoneNumber != phoneNumber)
{
try
{
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(Input.PhoneNumber),
countryCode : Input.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null &&
numberDetails.Carrier.TryGetValue("type", out var phoneNumberType) &&
phoneNumberType == "landline")
{
ModelState.AddModelError($"{nameof(Input)}.{nameof(Input.PhoneNumber)}",
$"The number you entered does not appear to be capable of receiving SMS ({phoneNumberType}). Please enter a different value and try again");
return(Page());
}
var numberToSave = numberDetails.PhoneNumber.ToString();
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, numberToSave);
if (!setPhoneResult.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"Unexpected error occurred setting phone number for user with ID '{userId}'.");
}
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(Input)}.{nameof(Input.PhoneNumber)}",
$"The number you entered was not valid (Twilio code {ex.Code}), please check it and try again");
return(Page());
}
}
await _userManager.UpdateAsync(user);
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task <IActionResult> BecomeCommercant(CommercentViewModel model, string jobb)
{
ViewData["countries"] = AvailableCountries;
string idx = userManager.GetUserId(User);
if (ModelState.IsValid)
{
Debug.WriteLine("valid" + ModelState.IsValid.ToString());
string uniqueFileName = null;
List <EmployeDocuments> emp = new List <EmployeDocuments>();
if (model.Documents != null && model.Documents.Count > 0)
{
// Loop thru each selected file
foreach (IFormFile photo in model.Documents)
{
EmployeDocuments employe = new EmployeDocuments();
// The file must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the injected
// IHostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "Files");
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
photo.CopyTo(new FileStream(filePath, FileMode.Create));
employe.Filepath = uniqueFileName;
emp.Add(employe);
}
}
if (model.FileP != null)
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.FileP.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
model.FileP.CopyTo(new FileStream(filePath, FileMode.Create));
}
//phone
try
{
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(model.Telephone),
countryCode : model.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null && numberDetails.Carrier.GetType().Equals(""))
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le format du numero ne convient pas à votre pays");
return(View());
}
var numberToSave = numberDetails.PhoneNumber.ToString();
var user = new Fournisseur
{
UserName = model.Email,
PhoneNumber = numberToSave,
PersAContact = model.PersAContact,
Email = model.Email,
Secteur = model.Secteur,
NomGerant = model.NomGerant,
DomainActivite = model.Domaine,
Identifiant_fiscale = model.Identifiant_fiscale,
Titre = model.Titre,
EffectFemme = model.EffectFemme,
EffectHomme = model.EffectHomme,
//Type = model.Type,
ProfilePhoto = uniqueFileName,
TypeService = (TypeService)Enum.Parse(typeof(TypeService), jobb),
Adresse = model.Adresse,
EmployeDocuments = emp
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (await roleManager.RoleExistsAsync("Commercant"))
{
await userManager.AddToRoleAsync(user, "Commercant");
}
else
{
IdentityRole identityrole = new IdentityRole
{
Name = "Commercant"
};
await roleManager.CreateAsync(identityrole);
await userManager.AddToRoleAsync(user, "Commercant");
}
await signInManager.SignInAsync(user, isPersistent : false);
}
if (user.TypeService.ToString().ToLower() == "transport")
{
return(RedirectToAction("AjouterTransport", "Service"));
}
else if (user.TypeService.ToString().ToLower() == "logement")
{
return(RedirectToAction("AddLogement", "Service"));
}
else if (user.TypeService.ToString().ToLower() == "nourriture")
{
return(RedirectToAction("AddRestaurant", "Service"));
}
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le numéro entré n'est pas valide (Code d'erreur {ex.Code})");
return(View());
}
}
return(View(model));
}
public async Task <IActionResult> DevnirFournisseurLogement(CommercentViewModel model)
{
ViewData["countries"] = AvailableCountries;
if (ModelState.IsValid)
{
Debug.WriteLine("valid" + ModelState.IsValid.ToString());
string uniqueFileName = null;
if (model.FileP != null)
{
// The image must be uploaded to the images folder in wwwroot
// To get the path of the wwwroot folder we are using the inject
// HostingEnvironment service provided by ASP.NET Core
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "Files");
// To make sure the file name is unique we are appending a new
// GUID value and and an underscore to the file name
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.FileP.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
// Use CopyTo() method provided by IFormFile interface to
// copy the file to wwwroot/images folder
model.FileP.CopyTo(new FileStream(filePath, FileMode.Create));
}
//phone
try
{
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(model.Telephone),
countryCode : model.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null && numberDetails.Carrier.GetType().Equals(""))
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le format du numero ne convient pas à votre pays");
return(View());
}
var numberToSave = numberDetails.PhoneNumber.ToString();
var user = new Fournisseur
{
UserName = model.Email,
PhoneNumber = numberToSave,
PersAContact = model.PersAContact,
Email = model.Email,
FormeJuridique = model.Forme,
Secteur = model.Secteur,
DomainActivite = model.Domaine,
SituationEntreprise = model.SituationEntreprise,
EffectFemme = model.EffectFemme,
EffectHomme = model.EffectHomme,
Type = model.Type,
Patente = uniqueFileName,
TypeService = (TypeService)Enum.Parse(typeof(TypeService), model.TypseService)
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
System.Diagnostics.Debug.WriteLine("Country is" + model.PhoneNumberCountryCode);
if (await roleManager.RoleExistsAsync("Commercant"))
{
await userManager.AddToRoleAsync(user, "Commercant");
}
else
{
IdentityRole identityrole = new IdentityRole
{
Name = "Commercant"
};
await roleManager.CreateAsync(identityrole);
await userManager.AddToRoleAsync(user, "Commercant");
}
await signInManager.SignInAsync(user, isPersistent : false);
if (user.TypeService.ToString() == "Logement")
{
return(RedirectToAction("AjouterLogement", "Service"));
}
if (user.TypeService.ToString() == "Nourriture")
{
return(RedirectToAction("AjouterNourriture", "Service"));
}
if (user.TypeService.ToString() == "Transport")
{
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(model.Telephone)}.{nameof(model.Telephone)}",
$"Le numéro entré n'est pas valide (Code d'erreur {ex.Code})");
return(View());
}
}
Debug.WriteLine("ma5dmtch" + ModelState.IsValid.ToString());
return(View("New"));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName, Professional_Skill = Input.Professional_Skill, PhoneNumber = Input.PhoneNumber
};
try
{
TwilioClient.Init(_twilioSMS.accountSid, _twilioSMS.authToken);
var numberDetails = await PhoneNumberResource.FetchAsync(
pathPhoneNumber : new Twilio.Types.PhoneNumber(Input.PhoneNumber),
countryCode : Input.PhoneNumberCountryCode,
type : new List <string> {
"carrier"
});
// only allow user to set phone number if capable of receiving SMS
if (numberDetails?.Carrier != null &&
numberDetails.Carrier.TryGetValue("type", out var phoneNumberType) &&
phoneNumberType == "landline")
{
ModelState.AddModelError($"{nameof(Input)}.{nameof(Input.PhoneNumber)}",
$"The number you entered does not appear to be capable of receiving SMS ({phoneNumberType}). Please enter a different value and try again");
return(Page());
}
}
catch (ApiException ex)
{
ModelState.AddModelError($"{nameof(Input)}.{nameof(Input.PhoneNumber)}",
$"The number you entered was not valid (Twilio code {ex.Code}), please check it and try again");
return(Page());
}
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
// var message = new Message(new string[] { Input.Email }, "Confirmation email link", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.", null);
// await _emailSenderCustom.SendEmailAsync(message);
// GmailServiceSend gs = new GmailServiceSend();
// gs.GenerateEmail(Input.Email,"*****@*****.**" , "Confirmation email link", "Test");
// await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
// $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
if (_twilioSMS.Active == "true")
{
try
{
string phonevalidator = RandomString();
var to = new PhoneNumber("+38762912141");
var SMSmessage = MessageResource.Create(
to,
from: new PhoneNumber(_twilioSMS.TwilioNumber),
body: $"New User: {user} has been registered!");
var to2 = new PhoneNumber(Input.PhoneNumber);
var SMSmessage2 = MessageResource.Create(
to2,
from: new PhoneNumber(_twilioSMS.TwilioNumber),
body: $"Hello {user}, please enter this code {phonevalidator} to confirm your registration!");
var PhoneCode = _context.Users.Single(p => p.Email == Input.Email);
PhoneCode.PhoneCodeValidator = phonevalidator;
_context.SaveChanges();
}
catch (Exception ex)
{
Console.WriteLine($" Registration Failure to send sms: {ex.Message} ");
}
}
return(LocalRedirect("/Identity/Account/Login"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task Index()
{
string from = Request.Form["From"];
string body = Request.Form["Body"].ToString().ToLower();
if (currentGame != null)
{
if (from != currentGame.RedPlayerNumber && from != currentGame.BluePlayerNumber)
{
await HelperMethods.SendSms(from, "A game is already in progress");
return;
}
if (!currentGame.CanDraw)
{
if (from != currentGame.OutputChannel)
{
await HelperMethods.SendSms(from, "It's not your turn yet.");
return;
}
}
else
{
if (body.Trim() != "draw")
{
if (from != currentGame.OutputChannel)
{
await HelperMethods.SendSms(from, "It's not your turn yet.");
return;
}
}
else
{
await SendGameInstructions(currentGame.AttemptDraw(from));
if (currentGame.GameIsOver)
{
currentGame = null;
}
return;
}
}
if (currentGame.WaitingForDieResponse)
{
if (body == "yes")
{
currentGame.WaitingForDieResponse = false;
currentGame.PlayersHaveDie = true;
}
else if (body == "no")
{
currentGame.WaitingForDieResponse = false;
currentGame.PlayersHaveDie = false;
}
await SendGameInstructions(currentGame.StartYear());
}
else if (currentGame.WaitingForDieRollResponse)
{
await SendGameInstructions(currentGame.ProcessDieRoll(body));
}
else if (currentGame.WaitingForRoundResponse)
{
var i = currentGame.ContinueRound(body.ToUpper());
if (!currentGame.GameIsOver)
{
await SendGameInstructions(i);
}
if (currentGame.GameIsOver)
{
currentGame = null;
}
}
}
if (currentlyAwaitingOtherPlayer)
{
if (from == awaitingOtherPlayer.PhoneNumber.ToString())
{
if (body == "yes" || body == "y")
{
await HelperMethods.SendSms(requestingPlayer.PhoneNumber.ToString(), "Your request has been accepted. Starting game.");
currentGame = new TwilioGameManager(requestingPlayer, awaitingOtherPlayer);
currentGame.WaitingForDieResponse = false;
currentGame.PlayersHaveDie = false;
await SendGameInstructions(currentGame.StartYear());
ResetPlayers();
}
else
{
await HelperMethods.SendSms(awaitingOtherPlayer.PhoneNumber.ToString(), "OK, rejecting request.");
await HelperMethods.SendSms(requestingPlayer.PhoneNumber.ToString(), "The other player has rejected the request.");
ResetPlayers();
}
}
else
{
await HelperMethods.SendSms(from, "Currently waiting for another player to join a game.");
}
}
if (body.StartsWith("start game") && body.Length > 11)
{
PhoneNumber potentialNumber = new PhoneNumber(body.Substring(11));
PhoneNumberResource otherResult = null;
try
{
otherResult = await PhoneNumberResource.FetchAsync(potentialNumber);
}
catch (Exception ex)
{
Debug.WriteLine("");
await HelperMethods.SendSms(from, "That doesn't appear to be a valid number. Try again");
return;
}
PhoneNumberResource result = await PhoneNumberResource.FetchAsync(new PhoneNumber(from));
requestingPlayer = result;
awaitingOtherPlayer = otherResult;
currentlyAwaitingOtherPlayer = true;
await HelperMethods.SendSms(otherResult.PhoneNumber.ToString(), $"{result.NationalFormat} has sent you a game request. Text back yes or y to accept. Text back no or n to reject.");
}
}
public async Task <PhoneNumberResource> FetchPhoneNumberResource(FetchPhoneNumberOptions fetchOptions, ITwilioRestClient twilioClient)
{
return(await PhoneNumberResource.FetchAsync(fetchOptions, twilioClient));
}
