public async Task CreateCallWithMachineDetectionReturnsCreated()
{
var accountId = TestConstants.AccountId;
var to = TestConstants.To;
var from = TestConstants.From;
var applicationId = TestConstants.VoiceApplicationId;
var answerUrl = string.Concat(TestConstants.BaseCallbackUrl, "/callbacks/answer");
var machineDetectionConfiguration = new MachineDetectionConfiguration()
{
CallbackUrl = string.Concat(TestConstants.BaseCallbackUrl, "/callbacks/machine-detection")
};
var request = new CreateCallRequest()
{
ApplicationId = applicationId,
To = to,
From = from,
AnswerUrl = answerUrl,
MachineDetection = machineDetectionConfiguration
};
var createCallResponse = await _client.Voice.APIController.CreateCallAsync(accountId, request);
Assert.Equal(201, createCallResponse.StatusCode);
Assert.Equal(accountId, createCallResponse.Data.AccountId);
Assert.Equal(applicationId, createCallResponse.Data.ApplicationId);
Assert.Equal(to, createCallResponse.Data.To);
Assert.Equal(from, createCallResponse.Data.From);
Assert.True(Uri.IsWellFormedUriString(createCallResponse.Data.CallUrl, UriKind.Absolute));
Assert.Equal(answerUrl, createCallResponse.Data.AnswerUrl);
Assert.Equal(AnswerMethodEnum.POST, createCallResponse.Data.AnswerMethod);
Assert.Equal(DisconnectMethodEnum.POST, createCallResponse.Data.DisconnectMethod);
}
public async Task CreateCallWithPriorityReturnsCreated()
{
var accountId = TestConstants.AccountId;
var to = TestConstants.To;
var from = TestConstants.From;
var applicationId = TestConstants.VoiceApplicationId;
var answerUrl = string.Concat(TestConstants.BaseCallbackUrl, "/callbacks/answer");
var priority = 4;
var request = new CreateCallRequest()
{
ApplicationId = applicationId,
To = to,
From = from,
AnswerUrl = answerUrl,
Priority = priority
};
var createCallResponse = await _client.Voice.APIController.CreateCallAsync(accountId, request);
Assert.Equal(201, createCallResponse.StatusCode);
Assert.Equal(applicationId, createCallResponse.Data.ApplicationId);
Assert.Equal(to, createCallResponse.Data.To);
Assert.Equal(from, createCallResponse.Data.From);
Assert.Equal(priority, createCallResponse.Data.Priority);
}
public void PostCallsTest()
{
// TODO: add unit test for the method 'PostCalls'
CreateCallRequest body = null; // TODO: replace null with proper value
var response = instance.PostCalls(body);
Assert.IsInstanceOf <CreateCallResponse> (response, "response is CreateCallResponse");
}
/// <summary>Snippet for CreateCall</summary>
public void CreateCallRequestObject()
{
// Snippet: CreateCall(CreateCallRequest, CallSettings)
// Create client
CallsClient callsClient = CallsClient.Create();
// Initialize request argument(s)
CreateCallRequest request = new CreateCallRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Call = new Call(),
};
// Make the request
Call response = callsClient.CreateCall(request);
// End snippet
}
public async stt::Task CreateCallRequestObjectAsync()
{
moq::Mock <Calls.CallsClient> mockGrpcClient = new moq::Mock <Calls.CallsClient>(moq::MockBehavior.Strict);
CreateCallRequest request = new CreateCallRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Call = new Call(),
};
Call expectedResponse = new Call
{
CallName = CallName.FromProjectCall("[PROJECT]", "[CALL]"),
To = "to03e2b601",
From = "fromf8078ad9",
IsPrivate = false,
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
Transport = Call.Types.Transport.Sip,
Direction = Call.Types.Direction.Incoming,
ErrorCode = "error_code42bd958e",
ErrorMessage = "error_messaged73952bd",
Price = new gt::Money(),
State = Call.Types.State.Busy,
CreateTime = new wkt::Timestamp(),
StartTime = new wkt::Timestamp(),
RingTime = new wkt::Timestamp(),
AnswerTime = new wkt::Timestamp(),
EndTime = new wkt::Timestamp(),
Bridged = true,
OriginatingCall = "originating_call9e182b53",
CreateMethod = Call.Types.CreateMethod.Api,
Options = new Call.Types.ApiCallOptions(),
};
mockGrpcClient.Setup(x => x.CreateCallAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Call>(stt::Task.FromResult(expectedResponse), null, null, null, null));
CallsClient client = new CallsClientImpl(mockGrpcClient.Object, null);
Call responseCallSettings = await client.CreateCallAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Call responseCancellationToken = await client.CreateCallAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public string CreateCall(string login, string password, string receiver_login)
{
string request = SERVER_DOMAIN + CREATE_CALL + "login="******"&password="******"&receiver_login="******"0");
}
/// <summary>Snippet for CreateCallAsync</summary>
public async Task CreateCallRequestObjectAsync()
{
// Snippet: CreateCallAsync(CreateCallRequest, CallSettings)
// Additional: CreateCallAsync(CreateCallRequest, CancellationToken)
// Create client
CallsClient callsClient = await CallsClient.CreateAsync();
// Initialize request argument(s)
CreateCallRequest request = new CreateCallRequest
{
ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
Call = new Call(),
};
// Make the request
Call response = await callsClient.CreateCallAsync(request);
// End snippet
}
private void CallButton_Click(object sender, EventArgs e)
{
try
{
var api = new ConversationsApi();
CreateCallRequest body = new CreateCallRequest();
body.PhoneNumber = "+6285221675710";
CreateCallResponse result = api.PostConversationsCalls(body);
conversationIdTextBox.Text = result.ToJson();
conversationIdTextBox.Text = result.Id;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task CreateCallInvalidFromPhoneNumberThrows()
{
var accountId = TestConstants.AccountId;
var to = TestConstants.To;
var from = "abc";
var applicationId = TestConstants.VoiceApplicationId;
var answerUrl = string.Concat(TestConstants.BaseCallbackUrl, "/callbacks/answer");
var request = new CreateCallRequest()
{
ApplicationId = applicationId,
To = to,
From = from,
AnswerUrl = answerUrl
};
var ex = await Assert.ThrowsAsync <ApiErrorException>(() => _client.Voice.APIController.CreateCallAsync(accountId, request));
Assert.Equal("Something's not quite right... Your request is invalid. Please fix it before trying again.", ex.Message);
}
partial void Modify_CreateCallRequest(ref CreateCallRequest request, ref gaxgrpc::CallSettings settings);
public void Init()
{
instance = new CreateCallRequest();
}
/// <summary>
/// Creates a call in the state QUEUED. This will cause an outgoing call
/// to be started.
///
/// The caller must have `voice.calls.create` permission on the project.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override stt::Task <Call> CreateCallAsync(CreateCallRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_CreateCallRequest(ref request, ref callSettings);
return(_callCreateCall.Async(request, callSettings));
}
/// <summary>
/// Creates a call in the state QUEUED. This will cause an outgoing call
/// to be started.
///
/// The caller must have `voice.calls.create` permission on the project.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>The RPC response.</returns>
public override Call CreateCall(CreateCallRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_CreateCallRequest(ref request, ref callSettings);
return(_callCreateCall.Sync(request, callSettings));
}
/// <summary> /// Creates a call in the state QUEUED. This will cause an outgoing call /// to be started. /// /// The caller must have `voice.calls.create` permission on the project. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Call> CreateCallAsync(CreateCallRequest request, st::CancellationToken cancellationToken) => CreateCallAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
/// <summary> /// Creates a call in the state QUEUED. This will cause an outgoing call /// to be started. /// /// The caller must have `voice.calls.create` permission on the project. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Call> CreateCallAsync(CreateCallRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Creates a call in the state QUEUED. This will cause an outgoing call /// to be started. /// /// The caller must have `voice.calls.create` permission on the project. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>The RPC response.</returns> public virtual Call CreateCall(CreateCallRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
public async Task GetCallReturnsOk()
{
var accountId = TestConstants.AccountId;
var to = TestConstants.To;
var from = TestConstants.From;
var applicationId = TestConstants.VoiceApplicationId;
var answerUrl = string.Concat(TestConstants.BaseCallbackUrl, "/callbacks/answer");
var request = new CreateCallRequest()
{
ApplicationId = applicationId,
To = to,
From = from,
AnswerUrl = answerUrl
};
var createCallResponse = await _client.Voice.APIController.CreateCallAsync(accountId, request);
var callId = createCallResponse.Data.CallId;
var retries = 5;
do
{
try
{
// Attempt to get the call's state after it has been created.
var getCallStateResponse = await _client.Voice.APIController.GetCallAsync(accountId, callId);
// No need to retry if we've made it this far.
retries = 0;
Assert.Equal(200, getCallStateResponse.StatusCode);
Assert.Equal(callId, getCallStateResponse.Data.CallId);
Assert.Null(getCallStateResponse.Data.ParentCallId);
Assert.Equal(applicationId, getCallStateResponse.Data.ApplicationId);
Assert.Equal(accountId, getCallStateResponse.Data.AccountId);
Assert.Equal(to, getCallStateResponse.Data.To);
Assert.Equal(from, getCallStateResponse.Data.From);
Assert.Equal("outbound", getCallStateResponse.Data.Direction);
Assert.True(getCallStateResponse.Data.State == "initiated" || getCallStateResponse.Data.State == "disconnected");
Assert.Null(getCallStateResponse.Data.Identity);
Assert.Empty(getCallStateResponse.Data.StirShaken);
Assert.IsType <DateTime>(getCallStateResponse.Data.EnqueuedTime);
Assert.IsType <DateTime>(getCallStateResponse.Data.StartTime);
Assert.Null(getCallStateResponse.Data.AnswerTime);
Assert.True(getCallStateResponse.Data.DisconnectCause == null || getCallStateResponse.Data.DisconnectCause == "busy");
const string errorMessage = "Callee is busy";
Assert.True(getCallStateResponse.Data.ErrorMessage == null || getCallStateResponse.Data.ErrorMessage == errorMessage);
// Assert if there's an error id and the error message is unrelated to a busy call.
Assert.True(getCallStateResponse.Data.ErrorId == null || getCallStateResponse.Data.ErrorMessage == errorMessage);
Assert.IsType <DateTime>(getCallStateResponse.Data.LastUpdate);
}
catch (ApiErrorException ex)
{
// There are times when the created call resource is not yet available after creating it.
retries = ex.ResponseCode == 404 ? retries - 1 : 0;
// Pause to give time to contemplate life.
Thread.Sleep(TestConstants.Timeout);
}
}while (retries > 0);
}