public JToken CreateProof(CreateProofOptions options, JsonLdProcessorOptions processorOptions)
{
if (!(options.VerificationMethod is Bls12381VerificationKey2020 verificationMethod))
{
throw new Exception(
$"Invalid verification method. " +
$"Expected '{nameof(Bls12381VerificationKey2020)}'. " +
$"Found '{options.VerificationMethod?.GetType().Name}'.");
}
// Prepare proof
var compactedProof = JsonLdProcessor.Compact(
input: new BbsBlsSignature2020
{
Context = Constants.SECURITY_CONTEXT_V2_URL,
TypeName = "https://w3c-ccg.github.io/ldp-bbs2020/context/v1#BbsBlsSignature2020"
},
context: Constants.SECURITY_CONTEXT_V2_URL,
options: processorOptions);
var proof = new BbsBlsSignature2020(compactedProof)
{
Context = Constants.SECURITY_CONTEXT_V2_URL,
VerificationMethod = options.VerificationMethod switch
{
VerificationMethodReference reference => (string)reference,
VerificationMethod method => method.Id,
_ => throw new Exception("Unknown VerificationMethod type")
},
/// <summary>
/// Constructs the arguments for a Verify transaction.
/// </summary>
/// <param name="verificationMethod">The method of verification (sms or call).</param>
/// <param name="phoneNumber">The phone number to send verification to.</param>
/// <param name="verifyCode">The code to be sent to the user. If null - a code will be generated.</param>
/// <param name="messageTemplate">An optional template for the message. Ignored if not SMS.</param>
/// <param name="language">The language for the message. Ignored for SMS when a template is provided.</param>
/// <param name="validityPeriod"></param>
/// <param name="useCaseId"></param>
/// <returns>A dictionary of arguments for a Verify transaction.</returns>
private static Dictionary <string, string> ConstructVerifyArgs(
VerificationMethod verificationMethod,
string phoneNumber,
string verifyCode,
string messageTemplate,
string language,
string validityPeriod = null,
string useCaseId = RawVerifyService.DefaultUseCaseId)
{
// TODO: Review code generation rules.
if (!string.IsNullOrEmpty(verifyCode))
{
if (verificationMethod == VerificationMethod.TwoWaySms)
{
throw new ArgumentException("Verify Code cannot be specified for Two-Way SMS", "verifyCode");
}
}
// TODO: Check code validity here?
var args = new Dictionary <string, string>
{
{ "phone_number", phoneNumber }
};
if (verificationMethod == VerificationMethod.Push)
{
if (!string.IsNullOrEmpty(verifyCode))
{
args.Add("notification_value", verifyCode);
}
}
else if (verificationMethod == VerificationMethod.TwoWaySms)
{
// Two way sms doesn't take a verify code. So nothing here.
}
else if (!string.IsNullOrEmpty(verifyCode))
{
args.Add("verify_code", verifyCode);
}
if (!string.IsNullOrEmpty(language))
{
args.Add("language", language);
}
if (verificationMethod == VerificationMethod.Sms || verificationMethod == VerificationMethod.Push)
{
args.Add("template", messageTemplate);
}
if (verificationMethod == VerificationMethod.TwoWaySms)
{
args.Add("message", messageTemplate);
args.Add("validity_period", validityPeriod);
args.Add("ucid", useCaseId);
}
return(args);
}
public SitesEntry VerifySite(string url, SitesEntry entry = null)
{
if (entry == null)
{
entry = GetSite(url);
}
VerificationMethod method = new VerificationMethod("metatag", "true");
var siteid = CreateSiteID(url);
entry.VerificationMethod = method;
var category = new AtomCategory("http://schemas.google.com/webmasters/tools/2007#site-info",
"http://schemas.google.com/g/2005#kind");
entry.Categories.Add(category);
entry.Id = new AtomId(string.Concat(SiteQueryUrl, siteid));
entry.Content.Type = "";
try
{
return(service.Update(entry));
}
catch (Exception ex)
{
Syslog.Write(ex);
}
return(null);
}
/// <summary>
/// Constructs the arguments for a Verify transaction.
/// </summary>
/// <param name="verificationMethod">The method of verification (sms or call).</param>
/// <param name="phoneNumber">The phone number to send verification to.</param>
/// <param name="verifyCode">The code to be sent to the user. If null - a code will be generated.</param>
/// <param name="messageTemplate">An optional template for the message. Ignored if not SMS.</param>
/// <param name="language">The language for the message. Ignored for SMS when a template is provided.</param>
/// <returns>A dictionary of arguments for a Verify transaction.</returns>
private static Dictionary <string, string> ConstructVerifyArgs(
VerificationMethod verificationMethod,
string phoneNumber,
string verifyCode,
string messageTemplate,
string language)
{
// TODO: Review code generation rules.
if (verifyCode == null)
{
Random r = new Random();
verifyCode = r.Next(100, 99999).ToString();
}
// TODO: Check code validity here?
Dictionary <string, string> args = new Dictionary <string, string>();
args.Add("phone_number", phoneNumber);
args.Add("verify_code", verifyCode.ToString());
args.Add("language", language);
if (verificationMethod == VerificationMethod.Sms)
{
args.Add("template", messageTemplate);
}
return(args);
}
/// <summary>
/// Returns true if the given verification method is a invoker or is
/// controlled by an invoker of the given capability.
/// </summary>
/// <param name="capability"></param>
/// <param name="verificationMethod"></param>
/// <returns></returns>
public static bool HasInvoker(this CapabilityDelegation capability, VerificationMethod verificationMethod)
{
var invokers = capability.GetInvokers();
return(invokers.Count() > 0 &&
(invokers.Contains(verificationMethod.Id) ||
(verificationMethod.Controller != null && invokers.Contains(verificationMethod.Controller))));
}
/// <summary>
/// Returns true if the given verification method is a delegator or is
/// controlled by a delegator of the given capability.
/// </summary>
/// <param name="capability"></param>
/// <param name="verificationMethod"></param>
/// <returns></returns>
public static bool HasDelegator(this CapabilityDelegation capability, VerificationMethod verificationMethod)
{
var delegators = capability.GetDelegators();
return(delegators.Count() > 0 &&
(delegators.Contains(verificationMethod.Id) ||
(verificationMethod.Controller != null && delegators.Contains(verificationMethod.Controller))));
}
public async Task <IInitiateVerificationResponse> Initiate(VerificationMethod method)
{
ValidateIdentity();
var request = new InitiateVerificationRequest
{
Identity = _identity,
Method = ToString(method),
Reference = _reference,
Custom = _custom,
};
return(new InitiateVerificationResponseAdapter(await _api.InitiateVerification(request).ConfigureAwait(false)));
}
private string ToString(VerificationMethod method)
{
switch (method)
{
case VerificationMethod.FlashCall:
return("flashCall");
case VerificationMethod.Sms:
return("sms");
case VerificationMethod.Callout:
return("callout");
}
throw new ArgumentException("Unsupported verification method: " + method);
}
public void ConstructVerificationMethod()
{
var method = new VerificationMethod();
Assert.Null(method.Id);
Assert.Null(method.TypeName);
Assert.Null(method.Controller);
method.Id = "did:123#key-1";
method.TypeName = "MockVerificationMethod";
method.Controller = "did:123";
Assert.Equal("did:123#key-1", method.Id);
Assert.Equal("MockVerificationMethod", method.TypeName);
Assert.Equal("did:123", method.Controller);
}
public void SerializeDeserializeVerificationMethod()
{
var method = new VerificationMethod();
method.TypeName = "MockMethod";
method.Id = "1";
method.Controller = "a";
var json = JsonConvert.SerializeObject(method);
Assert.NotNull(json);
var method1 = JsonConvert.DeserializeObject <IVerificationMethod>(json);
Assert.NotNull(method1);
Assert.IsType <VerificationMethod>(method1);
}
/// <summary>
/// Common method for Verify SMS and call requests.
/// </summary>
/// <param name="verificationMethod">The verification method (call or sms).</param>
/// <param name="phoneNumber">The phone number to send verification to.</param>
/// <param name="verifyCode">
/// The code to send to the user. When null a code will
/// be generated for you.
/// </param>
/// <param name="messageTemplate">
/// A template for the message to be sent to the user. This is ignored for voice calls.
/// </param>
/// <param name="language">
/// The language that the message should be in. This parameter is ignored for
/// SMS if you supplied a message template.
/// </param>
/// <returns>The raw JSON response for a verify REST API call.</returns>
private string InternalVerify(
VerificationMethod verificationMethod,
string phoneNumber,
string verifyCode = null,
string messageTemplate = null,
string language = null)
{
this.CleanupPhoneNumber(phoneNumber);
if (messageTemplate == null)
{
messageTemplate = string.Empty;
}
if (string.IsNullOrEmpty(language))
{
language = "en";
}
Dictionary <string, string> args = ConstructVerifyArgs(
verificationMethod,
phoneNumber,
verifyCode,
messageTemplate,
language);
string resourceName = string.Format(
RawVerifyService.VerifyResourceFormatString,
verificationMethod.ToString().ToLowerInvariant());
WebRequest request = this.ConstructWebRequest(
resourceName,
"POST",
args);
return(this.WebRequester.ReadResponseAsString(request));
}
public async Task <IReportVerificationResponse> Report(VerificationMethod method)
{
ValidateIdentity();
var request = new ReportVerificationRequest {
Method = ToString(method)
};
switch (method)
{
case VerificationMethod.FlashCall:
case VerificationMethod.Callout:
if (string.IsNullOrWhiteSpace(_cli))
{
throw new BadRequestException("Cli cannot be empty");
}
request.FlashCall = new FlashCallVerificationReportData {
Cli = _cli
};
break;
case VerificationMethod.Sms:
if (string.IsNullOrWhiteSpace(_code))
{
throw new BadRequestException("Code cannot be empty");
}
request.Sms = new SmsVerificationReportData {
Code = _code, Cli = _cli
};
break;
}
return(await _api.ReportVerification(_identity, request).ConfigureAwait(false));
}
public VerificationMethodReference(VerificationMethod verificationMethod) : this(verificationMethod.Id)
{
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 2:
if (field.Type == TType.String) {
SessionId = iprot.ReadString();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I32) {
Method = (VerificationMethod)iprot.ReadI32();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void send_changeVerificationMethod(string sessionId, VerificationMethod method)
#endif
{
oprot_.WriteMessageBegin(new TMessage("changeVerificationMethod", TMessageType.Call, seqid_));
changeVerificationMethod_args args = new changeVerificationMethod_args();
args.SessionId = sessionId;
args.Method = method;
args.Write(oprot_);
oprot_.WriteMessageEnd();
#if SILVERLIGHT
return oprot_.Transport.BeginFlush(callback, state);
#else
oprot_.Transport.Flush();
#endif
}
public IAsyncResult send_changeVerificationMethod(AsyncCallback callback, object state, string sessionId, VerificationMethod method)
public VerificationSessionData changeVerificationMethod(string sessionId, VerificationMethod method)
{
#if !SILVERLIGHT
send_changeVerificationMethod(sessionId, method);
return recv_changeVerificationMethod();
#else
var asyncResult = Begin_changeVerificationMethod(null, null, sessionId, method);
return End_changeVerificationMethod(asyncResult);
#endif
}
public IAsyncResult Begin_changeVerificationMethod(AsyncCallback callback, object state, string sessionId, VerificationMethod method)
{
return send_changeVerificationMethod(callback, state, sessionId, method);
}
/// <summary>
/// Common method for Verify SMS and call requests.
/// </summary>
/// <param name="verificationMethod">The verification method (call or sms).</param>
/// <param name="phoneNumber">The phone number to send verification to.</param>
/// <param name="verifyCode">
/// The code to send to the user. When null a code will
/// be generated for you.
/// </param>
/// <param name="messageTemplate">
/// A template for the message to be sent to the user. This is ignored for voice calls.
/// </param>
/// <param name="language">
/// The language that the message should be in. This parameter is ignored for
/// SMS if you supplied a message template.
/// </param>
/// <returns>The raw JSON response for a verify REST API call.</returns>
private string InternalVerify(
VerificationMethod verificationMethod,
string phoneNumber,
string verifyCode = null,
string messageTemplate = null,
string language = null)
{
this.CleanupPhoneNumber(phoneNumber);
if (messageTemplate == null)
{
messageTemplate = string.Empty;
}
if (string.IsNullOrEmpty(language))
{
language = "en";
}
Dictionary<string, string> args = ConstructVerifyArgs(
verificationMethod,
phoneNumber,
verifyCode,
messageTemplate,
language);
string resourceName = string.Format(
RawVerifyService.VerifyResourceFormatString,
verificationMethod.ToString().ToLowerInvariant());
WebRequest request = this.ConstructWebRequest(
resourceName,
"POST",
args);
return this.WebRequester.ReadResponseAsString(request);
}
public void Insert(int VerificationMethodKey,string VerificationMethodName,int Points,bool? Ismandatory,bool? Requiresmanualapproval)
{
VerificationMethod item = new VerificationMethod();
item.VerificationMethodKey = VerificationMethodKey;
item.VerificationMethodName = VerificationMethodName;
item.Points = Points;
item.Ismandatory = Ismandatory;
item.Requiresmanualapproval = Requiresmanualapproval;
item.Save(UserName);
}
public KeyAgreementMethod(VerificationMethod embeddedVerification) : base(embeddedVerification)
{
}
public AuthenticationMethod(VerificationMethod embeddedVerification) : base(embeddedVerification)
{
}
private static void PerformVerify(string[] args, VerificationMethod method)
{
CheckArgument.ArrayLengthAtLeast(args, 1, "args");
string phoneNumber = args[0];
string code = null;
if (args.Length >= 2)
{
code = args[1];
}
string language = "en";
if (args.Length >= 3)
{
language = args[2];
}
VerifyService verify = new VerifyService(GetConfiguration());
VerifyResponse verifyResponse = null;
if (method == VerificationMethod.Sms)
{
verifyResponse = verify.SendSms(phoneNumber, code, string.Empty, language);
}
else if (method == VerificationMethod.Call)
{
verifyResponse = verify.InitiateCall(phoneNumber, code, language);
}
else if (method == VerificationMethod.Push)
{
verifyResponse = verify.InitiatePush(phoneNumber, code);
}
else if (method == VerificationMethod.TwoWaySms)
{
verifyResponse = verify.SendTwoWaySms(phoneNumber);
}
else
{
throw new NotImplementedException("Invalid verification method");
}
foreach (TeleSignApiError e in verifyResponse.Errors)
{
Console.WriteLine(
"ERROR: [{0}] - {1}",
e.Code,
e.Description);
}
while (true)
{
Console.Write("Enter the code sent to phone [Just <enter> checks status. 'quit' to exit]: ");
string enteredCode = Console.ReadLine();
if (enteredCode.Equals("quit", StringComparison.InvariantCultureIgnoreCase))
{
break;
}
Console.WriteLine(string.IsNullOrEmpty(enteredCode) ? "Checking status..." : "Validating code...");
VerifyResponse statusResponse = verify.ValidateCode(
verifyResponse.ReferenceId,
enteredCode);
Console.WriteLine(
"Transaction Status: {0} -- {1}\r\nCode State: {2}",
statusResponse.Status.Code,
statusResponse.Status.Description,
(statusResponse.VerifyInfo != null)
? statusResponse.VerifyInfo.CodeState.ToString()
: "Not Sent");
if ((statusResponse.VerifyInfo != null) && (statusResponse.VerifyInfo.CodeState == CodeState.Valid))
{
Console.WriteLine("Code was valid. Exiting.");
break;
}
}
}
private static void PerformVerify(string[] args, VerificationMethod method)
{
CheckArgument.ArrayLengthAtLeast(args, 1, "args");
string phoneNumber = args[0];
string code = null;
if (args.Length >= 2)
{
code = args[1];
}
string language = "en";
if (args.Length >= 3)
{
language = args[2];
}
VerifyService verify = new VerifyService(GetConfiguration());
VerifyResponse verifyResponse = null;
if (method == VerificationMethod.Sms)
{
verifyResponse = verify.SendSms(phoneNumber, code, string.Empty, language);
}
else if (method == VerificationMethod.Call)
{
verifyResponse = verify.InitiateCall(phoneNumber, code, language);
}
else
{
throw new NotImplementedException("Invalid verification method");
}
foreach (TeleSignApiError e in verifyResponse.Errors)
{
Console.WriteLine(
"ERROR: [{0}] - {1}",
e.Code,
e.Description);
}
while (true)
{
Console.Write("Enter the code sent to phone [Just <enter> checks status. 'quit' to exit]: ");
string enteredCode = Console.ReadLine();
if (enteredCode.Equals("quit", StringComparison.InvariantCultureIgnoreCase))
{
break;
}
Console.WriteLine(string.IsNullOrEmpty(enteredCode) ? "Checking status..." : "Validating code...");
VerifyResponse statusResponse = verify.ValidateCode(
verifyResponse.ReferenceId,
enteredCode);
Console.WriteLine(
"Transaction Status: {0} -- {1}\r\nCode State: {2}",
statusResponse.Status.Code,
statusResponse.Status.Description,
statusResponse.VerifyInfo.CodeState);
if (statusResponse.VerifyInfo.CodeState == CodeState.Valid)
{
Console.WriteLine("Code was valid. Exiting.");
break;
}
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
SessionId = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.I32)
{
Method = (VerificationMethod)iprot.ReadI32();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.String)
{
Callback = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.String)
{
NormalizedPhone = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
CountryCode = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.String)
{
NationalSignificantNumber = iprot.ReadString();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.List)
{
{
AvailableVerificationMethods = new List <VerificationMethod>();
TList _list85 = iprot.ReadListBegin();
for (int _i86 = 0; _i86 < _list85.Count; ++_i86)
{
VerificationMethod _elem87 = (VerificationMethod)0;
_elem87 = (VerificationMethod)iprot.ReadI32();
AvailableVerificationMethods.Add(_elem87);
}
iprot.ReadListEnd();
}
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public VerifyDomainsPOST(VerificationMethod validationMethod)
{
validation_method = validationMethod;
}
public AssertionMethod(VerificationMethod embeddedVerification) : base(embeddedVerification)
{
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
return(obj is CardPaymentDetails other &&
((Status == null && other.Status == null) || (Status?.Equals(other.Status) == true)) &&
((Card == null && other.Card == null) || (Card?.Equals(other.Card) == true)) &&
((EntryMethod == null && other.EntryMethod == null) || (EntryMethod?.Equals(other.EntryMethod) == true)) &&
((CvvStatus == null && other.CvvStatus == null) || (CvvStatus?.Equals(other.CvvStatus) == true)) &&
((AvsStatus == null && other.AvsStatus == null) || (AvsStatus?.Equals(other.AvsStatus) == true)) &&
((AuthResultCode == null && other.AuthResultCode == null) || (AuthResultCode?.Equals(other.AuthResultCode) == true)) &&
((ApplicationIdentifier == null && other.ApplicationIdentifier == null) || (ApplicationIdentifier?.Equals(other.ApplicationIdentifier) == true)) &&
((ApplicationName == null && other.ApplicationName == null) || (ApplicationName?.Equals(other.ApplicationName) == true)) &&
((ApplicationCryptogram == null && other.ApplicationCryptogram == null) || (ApplicationCryptogram?.Equals(other.ApplicationCryptogram) == true)) &&
((VerificationMethod == null && other.VerificationMethod == null) || (VerificationMethod?.Equals(other.VerificationMethod) == true)) &&
((VerificationResults == null && other.VerificationResults == null) || (VerificationResults?.Equals(other.VerificationResults) == true)) &&
((StatementDescription == null && other.StatementDescription == null) || (StatementDescription?.Equals(other.StatementDescription) == true)) &&
((DeviceDetails == null && other.DeviceDetails == null) || (DeviceDetails?.Equals(other.DeviceDetails) == true)) &&
((CardPaymentTimeline == null && other.CardPaymentTimeline == null) || (CardPaymentTimeline?.Equals(other.CardPaymentTimeline) == true)) &&
((RefundRequiresCardPresence == null && other.RefundRequiresCardPresence == null) || (RefundRequiresCardPresence?.Equals(other.RefundRequiresCardPresence) == true)) &&
((Errors == null && other.Errors == null) || (Errors?.Equals(other.Errors) == true)));
}
public CapabilityInvocationMethod(VerificationMethod embeddedVerification) : base(embeddedVerification)
{
}
public override int GetHashCode()
{
int hashCode = 1465447186;
if (Status != null)
{
hashCode += Status.GetHashCode();
}
if (Card != null)
{
hashCode += Card.GetHashCode();
}
if (EntryMethod != null)
{
hashCode += EntryMethod.GetHashCode();
}
if (CvvStatus != null)
{
hashCode += CvvStatus.GetHashCode();
}
if (AvsStatus != null)
{
hashCode += AvsStatus.GetHashCode();
}
if (AuthResultCode != null)
{
hashCode += AuthResultCode.GetHashCode();
}
if (ApplicationIdentifier != null)
{
hashCode += ApplicationIdentifier.GetHashCode();
}
if (ApplicationName != null)
{
hashCode += ApplicationName.GetHashCode();
}
if (ApplicationCryptogram != null)
{
hashCode += ApplicationCryptogram.GetHashCode();
}
if (VerificationMethod != null)
{
hashCode += VerificationMethod.GetHashCode();
}
if (VerificationResults != null)
{
hashCode += VerificationResults.GetHashCode();
}
if (StatementDescription != null)
{
hashCode += StatementDescription.GetHashCode();
}
if (DeviceDetails != null)
{
hashCode += DeviceDetails.GetHashCode();
}
if (CardPaymentTimeline != null)
{
hashCode += CardPaymentTimeline.GetHashCode();
}
if (RefundRequiresCardPresence != null)
{
hashCode += RefundRequiresCardPresence.GetHashCode();
}
if (Errors != null)
{
hashCode += Errors.GetHashCode();
}
return(hashCode);
}
/// <summary>
/// Constructs the arguments for a Verify transaction.
/// </summary>
/// <param name="verificationMethod">The method of verification (sms or call).</param>
/// <param name="phoneNumber">The phone number to send verification to.</param>
/// <param name="verifyCode">The code to be sent to the user. If null - a code will be generated.</param>
/// <param name="messageTemplate">An optional template for the message. Ignored if not SMS.</param>
/// <param name="language">The language for the message. Ignored for SMS when a template is provided.</param>
/// <returns>A dictionary of arguments for a Verify transaction.</returns>
private static Dictionary<string, string> ConstructVerifyArgs(
VerificationMethod verificationMethod,
string phoneNumber,
string verifyCode,
string messageTemplate,
string language,
string validityPeriod = null,
string useCaseId = RawVerifyService.DefaultUseCaseId)
{
// TODO: Review code generation rules.
if (verifyCode == null)
{
Random r = new Random();
verifyCode = r.Next(100, 99999).ToString();
}
else
{
if (verificationMethod == VerificationMethod.TwoWaySms)
{
throw new ArgumentException("Verify Code cannot be specified for Two-Way SMS", "verifyCode");
}
}
// TODO: Check code validity here?
Dictionary<string, string> args = new Dictionary<string, string>();
args.Add("phone_number", phoneNumber);
if (verificationMethod == VerificationMethod.Push)
{
if (!string.IsNullOrEmpty(verifyCode))
{
args.Add("notification_value", verifyCode.ToString());
}
}
else if (verificationMethod == VerificationMethod.TwoWaySms)
{
// Two way sms doesn't take a verify code. So nothing here.
}
else
{
args.Add("verify_code", verifyCode.ToString());
}
if (!string.IsNullOrEmpty(language))
{
args.Add("language", language);
}
if (verificationMethod == VerificationMethod.Sms || verificationMethod == VerificationMethod.Push)
{
args.Add("template", messageTemplate);
}
if (verificationMethod == VerificationMethod.TwoWaySms)
{
args.Add("message", messageTemplate);
args.Add("validity_period", validityPeriod);
args.Add("ucid", useCaseId);
}
return args;
}
/// <summary>
/// Phone verification request
/// </summary>
/// <param name="countryCode"></param>
/// <param name="phoneNumber"></param>
/// <param name="method"></param>
/// <returns></returns>
public virtual async Task <ResultModel <object> > PhoneVerificationRequestAsync(string countryCode, string phoneNumber, VerificationMethod method = VerificationMethod.Sms)
{
if (_twilioSettings.IsTestEnv)
{
return(new SuccessResultModel <object>(new
{
Message = PhoneVerificationResources.TEST_ENV_TEXT
}));
}
var response = new ResultModel <object>();
var result = await _client.PostAsync(
$"/protected/json/phones/verification/start?via={method.ToString().ToLower()}&country_code={countryCode}&phone_number={phoneNumber}",
null
);
if (!result.IsSuccessStatusCode)
{
return(new ApiNotRespondResultModel <object>());
}
var content = await result.Content.ReadAsStringAsync();
_logger.LogDebug(result.ToString());
_logger.LogDebug(content);
var obj = JObject.Parse(content);
var isSuccess = obj.SelectToken("success").Value <bool>();
response.IsSuccess = isSuccess;
response.Result = content.Deserialize <object>();
return(response);
}
