/// <summary>
/// Deletes the contact.
/// </summary>
/// <param name="request">The request.</param>
/// <exception cref="System.ArgumentException">delete contact request</exception>
/// <exception cref="System.Exception"></exception>
public void DeleteContact(DeleteContactRequest request)
{
try
{
#region pre-processing
if (request == null)
{
throw new ArgumentException("delete contact request");
}
if (string.IsNullOrWhiteSpace(request.ContactIden))
{
throw new Exception(PushbulletConstants.DeleteContactErrorMessages.ErrorContactIdenProperty);
}
#endregion pre-processing
#region processing
string jsonResult = DeleteRequest(string.Format("{0}{1}/{2}", PushbulletConstants.BaseUrl, PushbulletConstants.ContactsUrls.Contacts, request.ContactIden));
#endregion processing
}
catch (Exception)
{
throw;
}
}
public async Task <DeleteContactResponse> DeleteContact(DeleteContactRequest deleteContactRequest)
{
this.logger.LogInfoMessage(this.GetType(), "Begin DeleteContact");
DeleteContactResponse deleteContactResponse = new DeleteContactResponse();
try
{
ContactData cd = this.ConvertContactMessageToObject(deleteContactRequest);
BaseResponse response = await this.contact.DeleteContact(cd);
deleteContactResponse.Build(response.ReturnValueInt,
response.ReturnValueString,
response.ReturnValueCustomString);
}
catch (Exception ex)
{
deleteContactResponse.RunTimeException(ex, "Exception while Deleting contact.");
this.logger.LogErrorMessage(this.GetType(), "Exception in DeleteContact", ex);
}
this.logger.LogInfoMessage(this.GetType(),
String.Format("End DeleteContact:{0}", deleteContactResponse.ReturnValueInt));
return(deleteContactResponse);
}
public Task <DeleteContactResponse> DeleteContact(DeleteContactRequest deleteContactRequest)
{
return(Task.Run(() =>
{
DeleteContactResponse response = new DeleteContactResponse();
ContactData editContactData =
this.contactDataList.Find(c => c.ContactID == deleteContactRequest.ContactID && c.Status == 1);
if (editContactData != null)
{
editContactData.Status = 0;
response.ReturnValueInt = 0;
response.ReturnValueString = "";
response.ReturnValueCustomString = "Contact Edited Successfully.";
}
else
{
response.ReturnValueInt = -13;
response.ReturnValueString = "Row not found";
response.ReturnValueCustomString = "Exception in Delete";
}
response.HTTPReturnCode = (Int16)HttpStatusCode.OK;
response.APIVersion = "1.0.0.0";
response.ReturnValueCustomObject = null;
return response;
}));
}
public IActionResult DeleteContact(DeleteContactRequest request)
{
if (request == null)
{
return(BadRequest(new { message = "Please check the input" }));
}
return(Ok(contactRepository.DeleteContact(request)));
}
private ContactData ConvertContactMessageToObject(DeleteContactRequest deleteContactRequest)
{
ContactData c = new ContactData();
c.ContactID = deleteContactRequest.ContactID;
return(c);
}
public async Task <DeleteContactResponse> DeleteContact(int contactId)
{
var request = new DeleteContactRequest {
ContactId = contactId
};
return(await Client.Execute <DeleteContactRequest, DeleteContactResponse>(request));
}
public async Task <JsonResult> Delete(Guid guid)
{
var request = new DeleteContactRequest()
{
Guid = guid
};
var result = await _identityServiceWrapper.DeleteContact(request);
return(new JsonResult(result));
}
internal async Task DeleteContact()
{
DeleteContactRequest deleteRequest = new DeleteContactRequest();
Console.WriteLine();
Console.WriteLine("Enter contact ID: ");
deleteRequest.ContactID = UIHelper.EnterInteger();
try
{
Console.WriteLine($"Looking up contact with ID={deleteRequest.ContactID} on the server");
ContactModel contact = await phoneBookClient.GetContactAsync(new GetContactRequest { ContactID = deleteRequest.ContactID });
Console.WriteLine("Found contact:");
UIHelper.PrintContact(contact);
Console.Write("Are you sure you want to delete this contact? (Y/N): ");
var confirmation = Console.ReadKey();
Console.WriteLine();
if (confirmation.KeyChar == 'Y' || confirmation.KeyChar == 'y')
{
try
{
var response = await phoneBookClient.DeleteContactAsync(deleteRequest);
Console.WriteLine();
Console.WriteLine($"Server response: {response.Message}");
}
catch (RpcException rpcException)
{
Console.WriteLine("There was an error communicating with gRPC server");
Console.WriteLine($"Code: {rpcException.StatusCode}, Status: {rpcException.Status}");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
catch (RpcException rpcException)
{
if (rpcException.StatusCode == StatusCode.NotFound)
{
Console.WriteLine($"Could not find contact with ID={deleteRequest.ContactID}");
}
else
{
Console.WriteLine("There was an error communicating with gRPC server");
Console.WriteLine($"Code: {rpcException.StatusCode}, Status: {rpcException.Status}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public ActionResult ContactDelete(long id, FormCollection collection)
{
var request = new DeleteContactRequest(SynergySecurity.GetCurrentUser());
request.Id = id;
var RecordId = SynergySecurity.ToLog <DeleteContactRequest>(request);
DeleteContactResponse response = contactApi.DeleteContact(request);
SynergySecurity.ToUpdateLog <DeleteContactResponse>(response, RecordId);
return(RedirectToAction("Contacts"));
}
public bool DeleteContact(DeleteContactRequest request)
{
var contact = _db.Contacts.Where(a => a.Id == request.Id).FirstOrDefault();
if (contact != null)
{
_db.Contacts.Remove(contact);
_db.SaveChanges();
return(true);
}
return(false);
}
public override Task <GenericResponseMessage> DeleteContact(DeleteContactRequest request, ServerCallContext context)
{
ContactModel deleteContact = repository.FindContact(request.ContactID);
if (deleteContact == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Contact with ID={request.ContactID} is not found."));
}
repository.Contacts.Remove(deleteContact);
return(Task.FromResult(new GenericResponseMessage {
Message = "Contact is successfuly deleted"
}));
}
/// <summary>Snippet for DeleteContact</summary>
public void DeleteContactRequestObject()
{
// Snippet: DeleteContact(DeleteContactRequest, CallSettings)
// Create client
EssentialContactsServiceClient essentialContactsServiceClient = EssentialContactsServiceClient.Create();
// Initialize request argument(s)
DeleteContactRequest request = new DeleteContactRequest
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
};
// Make the request
essentialContactsServiceClient.DeleteContact(request);
// End snippet
}
public void DeleteContactResourceNames()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
DeleteContactRequest request = new DeleteContactRequest
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteContact(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null);
client.DeleteContact(request.ContactName);
mockGrpcClient.VerifyAll();
}
public IActionResult Delete(DeleteContactRequest request, [FromHeader] string authorization)
{
UserReadDbo user = _auth.ValidateUser(authorization);
if (user == null)
{
return(_auth.GetError());
}
if (!_repo.DeleteContact(request.Id, user.Id))
{
return(NotFound());
}
return(Ok());
}
public async Task <DeleteContactResult> DeleteContact(DeleteContactRequest request)
{
try
{
DynamicParameters parameters = new DynamicParameters();
parameters.Add("@ContactId", request.ContactId);
return(await SqlMapper.QueryFirstOrDefaultAsync <DeleteContactResult>(cnn : connect,
sql : "sp_DeleteContact",
param : parameters,
commandType : CommandType.StoredProcedure));
}
catch (Exception ex)
{
throw;
}
}
internal async Task <bool> DeleteContact(int contactID)
{
bool status = false;
DeleteContactRequest deleteRequest = new DeleteContactRequest();
deleteRequest.ContactID = contactID;
try
{
ContactModel contact = await contactBookClient.GetContactAsync(new GetContactRequest { ContactID = contactID });
try
{
var response = await contactBookClient.DeleteContactAsync(deleteRequest);
status = true;
}
catch (RpcException rpcException)
{
Console.WriteLine("There was an error communicating with gRPC server");
Console.WriteLine($"Code: {rpcException.StatusCode}, Status: {rpcException.Status}");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
catch (RpcException rpcException)
{
if (rpcException.StatusCode == StatusCode.NotFound)
{
Console.WriteLine($"Could not find contact with ID={deleteRequest.ContactID}");
}
else
{
Console.WriteLine("There was an error communicating with gRPC server");
Console.WriteLine($"Code: {rpcException.StatusCode}, Status: {rpcException.Status}");
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return(status);
}
DeleteContactRequest GetRequestInfo()
{
// Get the Json from the POST.
string strJson = String.Empty;
HttpContext context = HttpContext.Current;
context.Request.InputStream.Position = 0;
using (StreamReader inputStream = new StreamReader(context.Request.InputStream))
{
strJson = inputStream.ReadToEnd();
}
// Deserialize the Json.
DeleteContactRequest req = JsonConvert.DeserializeObject <DeleteContactRequest>(strJson);
return(req);
}
/// <summary>Snippet for DeleteContactAsync</summary>
public async Task DeleteContactRequestObjectAsync()
{
// Snippet: DeleteContactAsync(DeleteContactRequest, CallSettings)
// Additional: DeleteContactAsync(DeleteContactRequest, CancellationToken)
// Create client
EssentialContactsServiceClient essentialContactsServiceClient = await EssentialContactsServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteContactRequest request = new DeleteContactRequest
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
};
// Make the request
await essentialContactsServiceClient.DeleteContactAsync(request);
// End snippet
}
public async Task DeleteContact_Success()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
DeleteContactRequest request = new DeleteContactRequest();
request.ContactID = 3;
// Act
DeleteContactResponse response = await(controller.DeleteContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_SUCCESS);
Assert.AreEqual(response.ReturnValueCustomString, "Contact Deleted Successfully.");
}
public async Task DeleteContact_InValidInput()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
DeleteContactRequest request = new DeleteContactRequest();
request.ContactID = -1;
// Act
DeleteContactResponse response = await(controller.DeleteContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_INVALIDREQUEST);
Assert.AreEqual(response.ReturnValueCustomString, "InValid Contact ID.");
}
public async stt::Task DeleteContactResourceNamesAsync()
{
moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict);
DeleteContactRequest request = new DeleteContactRequest
{
ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"),
};
wkt::Empty expectedResponse = new wkt::Empty {
};
mockGrpcClient.Setup(x => x.DeleteContactAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null);
await client.DeleteContactAsync(request.ContactName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
await client.DeleteContactAsync(request.ContactName, st::CancellationToken.None);
mockGrpcClient.VerifyAll();
}
public async Task DeleteContact_ActiveRowNotFound()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
DeleteContactRequest request = new DeleteContactRequest();
request.ContactID = 2;
// Act
DeleteContactResponse response = await(controller.DeleteContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_RUNTIMEEXCEPTION);
Assert.AreEqual(response.ReturnValueString, "Row not found");
Assert.AreEqual(response.ReturnValueCustomString, "Exception in Delete");
}
public async Task <IActionResult> Delete(string userName)
{
_logger.LogInformation("Received Delete Contact Request");
try
{
var deleteContactRequest = new DeleteContactRequest()
{
UserName = userName
};
await _mediator.Send(deleteContactRequest);
}
catch (NotFound)
{
throw new ResourceNotFoundException();
}
return(NoContent());
}
public async void TestDelete()
{
String accessToken = this.RandomString();
String etag = this.RandomString();
String contactId = this.RandomString();
DeleteContactRequest req = new DeleteContactRequest();
req.ContactId = contactId;
req.Etag = etag;
MockAPI <Contacts> mock = this.MockFor <Contacts>(
HttpMethod.Post,
"/api/v1/contacts.delete",
m => m.WithContent(req.ToString())
.Respond("application/json", req.ToString())
);
APIResponse <dynamic> res = await mock.Instance.Delete(accessToken, contactId, etag, null);
mock.Handler.VerifyNoOutstandingExpectation();
Assert.Equal(System.Net.HttpStatusCode.OK, res.Status);
}
public HttpResponseMessage deleteIDContactUs(int id)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
DeleteContactRequest model = new DeleteContactRequest();
model.id = id;
ContactRequestServices contactService = new ContactRequestServices();
bool isSuccessful = _ContactService.deleteContactRequest(model);
ItemResponse <bool> response = new ItemResponse <bool>();
response.Item = isSuccessful;
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public async Task <DeleteContactResponse> DeleteContact(DeleteContactRequest deleteContactRequest)
{
this.logger.LogInfoMessage(this.GetType(), "Begin DeleteContact");
DeleteContactResponse deleteContactResponse = new DeleteContactResponse();
this.CheckInVariants(deleteContactRequest, deleteContactResponse);
// Validate Request
if (deleteContactResponse.ReturnValueInt == 0)
{
deleteContactRequest.Validate(deleteContactResponse, this.logger);
}
if (deleteContactResponse.ReturnValueInt == 0)
{
try
{
Task <DeleteContactResponse> task = this.core.DeleteContact(deleteContactRequest);
await task;
deleteContactResponse.ReturnValueInt = task.Result.ReturnValueInt;
deleteContactResponse.ReturnValueString = task.Result.ReturnValueString;
deleteContactResponse.ReturnValueCustomString = task.Result.ReturnValueCustomString;
}
catch (Exception e)
{
deleteContactResponse.RunTimeException(e, "Exception while Deleting contact.");
}
}
if (deleteContactResponse.ReturnValueInt == 0)
{
deleteContactResponse.Success("Contact Deleted Successfully.");
}
this.logger.LogInfoMessage(this.GetType(),
String.Format("End DeleteContact:{0}", deleteContactResponse.ReturnValueInt));
return(deleteContactResponse);
}
public void PushbulletDeleteContactTest()
{
try
{
var contacts = Client.CurrentUsersContacts();
Assert.IsNotNull(contacts);
var contact = contacts.Contacts.Where(o => o.Email == "*****@*****.**").FirstOrDefault();
Assert.IsNotNull(contact);
DeleteContactRequest request = new DeleteContactRequest()
{
ContactIden = contact.Iden
};
Client.DeleteContact(request);
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public async Task <OkObjectResult> Delete(DeleteContactRequest request)
{
return(Ok(await contactService.DeleteContact(request)));
}
public async Task <CmdResponse> DeleteContact(DeleteContactRequest request)
{
return(await SendVoidAsync <DeleteContactRequest, CmdResponse>("DeleteContact", request));
}
public async Task <DeleteContactResult> DeleteContact(DeleteContactRequest request)
{
return(await contactRepository.DeleteContact(request));
}
