public bool InsertContact(AddContactRequest contact, string clientId)
{
Log.Info("InsertContact init...");
Log.Debug("Adding contact for client id " + clientId);
var success = true;
contact.ClientId = clientId;
try
{
var request = ResolveRequest(contact);
var response = _restClient.Execute(request) as RestResponse;
dynamic processedResponse = ProcessResponse(response);
if (!IsSuccess(processedResponse))
{
throw new Exception("API returns error.");
}
}
catch (Exception ex)
{
Log.Error("Contact not added due to error: " + ex.Message);
success = false;
}
Log.Info("InsertContact end.");
return(success);
}
public async Task TestGivenContactIsStoredInGivenRepository()
{
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(respository, new InMemoryMessenger());
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var publicKeyAddress = Seed.Random().Value;
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(Seed.Random().Value),
ImagePath = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(publicKeyAddress),
UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey
};
await interactor.ExecuteAsync(request);
Assert.AreEqual(1, respository.PersistedContacts.Count);
var contact = respository.PersistedContacts[0];
Assert.AreEqual(publicKeyAddress, contact.PublicKeyAddress);
Assert.IsFalse(contact.Rejected);
Assert.IsNotNull(contact.ChatAddress);
}
public async Task TestNoContactInformationCanBeFoundShouldReturnErrorCode()
{
var contactRepositoryMock = new Mock <IContactRepository>();
contactRepositoryMock.Setup(c => c.LoadContactInformationByAddressAsync(It.IsAny <Address>()))
.Throws(new MessengerException(ResponseCode.NoContactInformationPresent));
var messenger = new InMemoryMessenger();
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(contactRepositoryMock.Object, messenger);
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(Seed.Random().Value),
ImagePath = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(Seed.Random().Value),
UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey
};
var response = await interactor.ExecuteAsync(request);
Assert.AreEqual(ResponseCode.NoContactInformationPresent, response.Code);
}
public async Task <AddContactResponse> AddContact(AddContactRequest addContactRequest)
{
this.logger.LogInfoMessage(this.GetType(), "Begin AddContact");
AddContactResponse addContactResponse = new AddContactResponse();
try
{
ContactData cd = this.ConvertContactMessageToObject(addContactRequest);
BaseResponse response = await this.contact.AddContact(cd);
addContactResponse.Build(response.ReturnValueInt, response.ReturnValueString, response.ReturnValueCustomString);
if (response.ReturnValueCustomObject != null)
{
addContactResponse.NewContactID = (Int64)response.ReturnValueCustomObject;
}
}
catch (Exception ex)
{
addContactResponse.RunTimeException(ex, "Exception while adding contact.");
this.logger.LogErrorMessage(this.GetType(), "Exception in AddContact", ex);
}
this.logger.LogInfoMessage(this.GetType(),
String.Format("End AddContact:{0}", addContactResponse.ReturnValueInt));
return(addContactResponse);
}
public async void add([FromBody] AddContactRequest request)
{
using (var dbContext = new PulseDbContext())
{
var account = await dbContext.Accounts
.Include(a => a.Contacts)
.Where(a => a.AccountId == request.AccountId)
.FirstOrDefaultAsync();
if (account == null)
{
return;
}
foreach (var contact in request.Contacts)
{
dbContext.Contacts.Add(contact);
account.Contacts.Add(contact);
await FirebaseHelper.SendMessage(account, "added_contact", new
{
phone_number = contact.PhoneNumber,
name = contact.Name,
type = contact.ContactType,
color = contact.Color,
color_dark = contact.ColorDark,
color_light = contact.ColorLight,
color_accent = contact.ColorAccent
});
}
await dbContext.SaveChangesAsync();
}
}
public Task <AddContactResponse> AddContact(AddContactRequest addContactRequest)
{
return(Task.Run(() =>
{
AddContactResponse response = new AddContactResponse();
if (this.contactDataList.Exists(c => c.EmailAddress == addContactRequest.EmailAddress))
{
response.NewContactID = 0;
response.ReturnValueInt = -13;
response.ReturnValueString = "Email Address already Exists";
response.ReturnValueCustomString = "Exception in Add";
}
else
{
this.contactDataList.Add(new ContactData(6,
addContactRequest.FirstName,
addContactRequest.LastName,
addContactRequest.EmailAddress,
addContactRequest.PhoneNumber,
1));
response.NewContactID = 6;
response.ReturnValueInt = 0;
response.ReturnValueString = "";
response.ReturnValueCustomString = "Contact added Successfully.";
}
response.HTTPReturnCode = (Int16)HttpStatusCode.OK;
response.APIVersion = "1.0.0.0";
response.ReturnValueCustomObject = null;
return response;
}));
}
static void Main(string[] args)
{
XmlConfigurator.Configure();
Log.Info("Main program init...");
Log.Debug("Parsing clients csv file...");
var clients = CsvCollector.Parse <AddClientRequest>(@ConfigManager.ClientsCsv);
Log.Debug("Parsing contacts csv file...");
var contacts = new List <AddContactRequest>(CsvCollector.Parse <AddContactRequest>(@ConfigManager.ContactsCsv));
var rnd = new Random();
Log.Debug("Parsing done.");
foreach (var client in clients)
{
Log.Info("Adding clients, contacts and orders loop start.");
string clientId;
if (!ApiController.InsertClient(client, out clientId))
{
continue;
}
// adding contacts
var numOfContacts = rnd.Next(4);
if (numOfContacts == 0 || contacts.Count == 0)
{
var contactWithNoData = new AddContactRequest();
if (!ApiController.InsertContact(contactWithNoData, clientId))
{
continue;
}
}
else
{
for (var i = 0; i <= numOfContacts; i++)
{
var contact = contacts[0];
contacts.RemoveAt(0);
if (!ApiController.InsertContact(contact, clientId))
{
continue;
}
}
}
// adding orders
if (!ApiController.InsertOrder(clientId))
{
continue;
}
if (!ApiController.ActivateSubscriptions(clientId))
{
continue;
}
Log.Info("Adding clients, contacts and orders loop end.");
}
//ApiController.ActivateSubscriptions("80");
Log.Info("Main program end.");
}
public IActionResult AddContact(AddContactRequest request)
{
if (request == null)
{
return(BadRequest(new { message = "Please check your input" }));
}
return(Ok(contactRepository.AddContact(request)));
}
public async Task<IActionResult> AddContact(AddContactRequest addContactRequest)
{
var result = await _mediator.Send(addContactRequest.MapToCommand());
var potentialBadResult = GeneratePotentialBadResult(result);
return potentialBadResult ?? Created(Url.Action(nameof(GetContactById), new { id = result.Item}), result.Item);
}
private ContactData ConvertContactMessageToObject(AddContactRequest addContactRequest)
{
ContactData c = new ContactData();
c.FirstName = addContactRequest.FirstName;
c.LastName = addContactRequest.LastName;
c.EmailAddress = addContactRequest.EmailAddress;
c.PhoneNumber = addContactRequest.PhoneNumber;
c.Status = 1;
return(c);
}
public HttpResponseMessage AddContact(AddContactRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
response.Item = ContactsService.UpdateContact(model);
return(Request.CreateResponse(response));
}
public async Task <AddContactResult> AddContactAsync(string contactName)
{
if (AuthToken == null)
{
throw new InvalidOperationException("The user is not authenticated");
}
AddContactRequest request = new AddContactRequest(AuthToken, contactName);
AddContactResponse response = await communicationService.SendAsync(request) as AddContactResponse;
return(response.Result);
}
public async Task TestContactCanNotBeAddedToContactRepositoryShouldReturnErrorCode()
{
var respository = new ExceptionContactRepository();
var interactor = new AddContactInteractor(respository, new InMemoryMessenger());
var request = new AddContactRequest
{
ContactAddress = new Address(),
RequestAddress = new Address(Seed.Random().Value),
ImageHash = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(Seed.Random().Value)
};
var response = await interactor.ExecuteAsync(request);
Assert.AreEqual(ResponseCode.CannotAddContact, response.Code);
}
AddContactRequest 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.
AddContactRequest req = JsonConvert.DeserializeObject <AddContactRequest>(strJson);
return(req);
}
public IActionResult AddContact([FromBody] AddContactRequest model)
{
try
{
Log.Information($"Adding contact {model.ContactId} for user {model.UserId}");
var resultMessage = _commSvc.AddToUserContacts(model.UserId, model.ContactId);
return(Ok(new
{
message = resultMessage
}));
}
catch (Exception ex)
{
Log.Error($"Failed to add ontact {model.ContactId} for user {model.UserId} : {ex.Message}");
}
return(StatusCode(500));
}
public WrapResponseResult <ResponseWrapper <BaseContactResponse> > Add(AddContactRequest request)
{
return(new WrapResponseResult <ResponseWrapper <BaseContactResponse> >(() =>
{
if (request != null && ModelState.IsValid)
{
ResponseWrapper <BaseContactResponse> response = null;
response = _contactService.Add(request);
return response;
}
else
{
ResponseWrapper <BaseContactResponse> response = null;
response = ResponseWrapper <BaseContactResponse> .GetBadRequestErrorResponse();
return response;
}
}, this.Request));
}
public async Task TestUnkownExceptionIsThrownShouldReturnErrorCode()
{
var messenger = new ExceptionMessenger(new Exception("Hi"));
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(respository, messenger);
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(Seed.Random().Value),
ImageHash = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(Seed.Random().Value)
};
var response = await interactor.ExecuteAsync(request);
Assert.AreEqual(ResponseCode.UnkownException, response.Code);
}
public async Task TestChatPasKeyIsSentViaMessenger()
{
var messenger = new InMemoryMessenger();
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(respository, messenger);
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(Seed.Random().Value),
ImageHash = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(Seed.Random().Value)
};
var response = await interactor.ExecuteAsync(request);
Assert.AreEqual(2, messenger.SentMessages.Count);
Assert.AreEqual(ResponseCode.Success, response.Code);
}
public void AddContact(AddContactRequest request)
{
try
{
using (var repo = new Data.ContactsRepository())
{
var clist = repo.GetContactList(request.contactlist);
if (!clist.ContactIds.Contains(request.contact))
{
clist.ContactIds.Add(request.contact);
}
repo.UpdateContactList(clist);
}
}
catch (Exception ex)
{
Logger.DebugException("AddContact failed", ex);
throw;
}
}
public ResponseWrapper <BaseContactResponse> Add(AddContactRequest request)
{
ResponseWrapper <BaseContactResponse> response;
response = ResponseWrapper <BaseContactResponse> .GetInternalServerErrorResponse();
try
{
object parameters = new
{
FirstName = request.FirstName,
LastName = request.LastName,
PhoneNumber = request.PhoneNumber,
Email = request.Email,
Status = request.Status
};
string errorCode, errorMessage;
bool result = false;
var transaction = _contactDAL.GetByParam(parameters, DBCommands.USP_ContactDetails_Add, out result, out errorMessage, out errorCode);
if (result == false)
{
response = ResponseWrapper <BaseContactResponse> .GetForbiddenErrorResponse(errorMessage);
}
else
{
response = ResponseWrapper <BaseContactResponse> .GetSuccessResponse();
response.data = new BaseContactResponse();
response.data = Mapper.Map <BaseContactResponse>(transaction);
}
}
catch (Exception ex)
{
response = ResponseWrapper <BaseContactResponse> .GetForbiddenErrorResponse(ex.Message);
LogManager.WriteError("ContactServices:Add" + ex.Message);
}
return(response);
}
public async Task <AddContactResponse> AddContact(AddContactRequest addContactRequest)
{
this.logger.LogInfoMessage(this.GetType(), "Begin AddContact");
AddContactResponse addContactResponse = new AddContactResponse();
this.CheckInVariants(addContactRequest, addContactResponse);
// Validate Request
if (addContactResponse.ReturnValueInt == 0)
{
addContactRequest.Validate(addContactResponse, this.logger);
}
if (addContactResponse.ReturnValueInt == 0)
{
try
{
Task <AddContactResponse> task = this.core.AddContact(addContactRequest);
await task;
addContactResponse.ReturnValueInt = task.Result.ReturnValueInt;
addContactResponse.ReturnValueString = task.Result.ReturnValueString;
addContactResponse.ReturnValueCustomString = task.Result.ReturnValueCustomString;
addContactResponse.NewContactID = task.Result.NewContactID;
}
catch (Exception e)
{
addContactResponse.RunTimeException(e, "Exception while adding contact.");
}
}
if (addContactResponse.ReturnValueInt == 0)
{
addContactResponse.Success("Contact added Successfully.");
}
this.logger.LogInfoMessage(this.GetType(),
String.Format("End AddContact:{0}", addContactResponse.ReturnValueInt));
return(addContactResponse);
}
public async Task TestMessengerCannotSendMessageShouldReturnErrorCodeAndNotWriteToContactRepository()
{
var messenger = new ExceptionMessenger();
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(respository, messenger);
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(Seed.Random().Value),
ImagePath = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(Seed.Random().Value),
UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey
};
var response = await interactor.ExecuteAsync(request);
Assert.AreEqual(ResponseCode.MessengerException, response.Code);
Assert.AreEqual(0, respository.PersistedContacts.Count);
}
public async Task AddContact_InValidInput()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
AddContactRequest request = new AddContactRequest();
request.FirstName = "";
request.LastName = "Lonkar6";
request.EmailAddress = "v.l4a.in";
request.PhoneNumber = "+91 611.111.111";
// Act
AddContactResponse response = await(controller.AddContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_INVALIDREQUEST);
Assert.AreEqual(response.ReturnValueCustomString, "FirstName is empty.InValid Email Address.");
}
public bool AddContact(AddContactRequest request)
{
if (request != null)
{
int secretNumber = 5306;
request.userId = request.userId - secretNumber;
var result = _db.Contacts.Where(a => a.registerId == request.userId).FirstOrDefault();
if (result == null)
{
Contact contact = new Contact
{
Email = request.email,
Mobile = request.mobile,
registerId = request.userId
};
_db.Contacts.Add(contact);
_db.SaveChanges();
return(true);
}
}
return(false);
}
public async Task AddContact_EmailDuplicate()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
AddContactRequest request = new AddContactRequest();
request.FirstName = "Vijay6";
request.LastName = "Lonkar6";
request.EmailAddress = "*****@*****.**";
request.PhoneNumber = "+91 611.111.111";
// Act
AddContactResponse response = await(controller.AddContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_RUNTIMEEXCEPTION);
Assert.AreEqual(response.ReturnValueString, "Email Address already Exists");
Assert.AreEqual(response.ReturnValueCustomString, "Exception in Add");
}
public bool Addcontact(AddContactRequest request)
{
if (request != null)
{
Contact contacts = new Contact();
contacts.First_Name = request.First_Name;
contacts.Last_Name = request.Last_Name;
contacts.Phone = request.Phone;
contacts.Email = request.Email;
contacts.Gender = request.Gender;
contacts.Created_On = DateTime.Now;
contacts.Updated_On = DateTime.Now;
contacts.Isactive = request.Isactive;
contacts.Password = request.Password;
_db.Contacts.Add(contacts);
_db.SaveChanges();
return(true);
}
return(false);
}
public async Task AddContact_Success()
{
// Arrange
ICore core = new MockCore();
ILogger logger = new Logger();
ContactsController controller = new ContactsController(core, logger);
AddContactRequest request = new AddContactRequest();
request.FirstName = "Vijay6";
request.LastName = "Lonkar6";
request.EmailAddress = "*****@*****.**";
request.PhoneNumber = "+91 611.111.111";
// Act
AddContactResponse response = await(controller.AddContact(request));
// Assert
Assert.IsNotNull(response);
Assert.AreEqual(response.NewContactID, 6);
Assert.AreEqual(response.ReturnValueInt, BaseResponse.RESPONSE_SUCCESS);
Assert.AreEqual(response.ReturnValueCustomString, "Contact added Successfully.");
}
public async Task TestMessengerGetsCalledWithAddContactRequestAndContactJsonPayload()
{
var messenger = new InMemoryMessenger();
var respository = new InMemoryContactRepository();
var interactor = new AddContactInteractor(respository, messenger);
var contactAddress = new Address("GUEOJUOWOWYEXYLZXNQUYMLMETF9OOGASSKUZZWUJNMSHLFLYIDIVKXKLTLZPMNNJCYVSRZABFKCAVVIW");
var requestAddress = Seed.Random().Value;
var publicKeyAddress = Seed.Random().Value;
var request = new AddContactRequest
{
ContactAddress = contactAddress,
RequestAddress = new Address(requestAddress),
ImagePath = "kjasdjkahsda89dafhfafa",
Name = "Chiota User",
PublicKeyAddress = new Address(publicKeyAddress),
UserPublicKey = InMemoryContactRepository.NtruKeyPair.PublicKey
};
await interactor.ExecuteAsync(request);
Assert.AreEqual(2, messenger.SentMessages.Count);
var sentMessage = messenger.SentMessages[0];
Assert.AreEqual(contactAddress.Value, sentMessage.Receiver.Value);
var decryptedPayload = NtruEncryption.Key.Decrypt(InMemoryContactRepository.NtruKeyPair, sentMessage.Payload.ToBytes());
var sentPayload = JsonConvert.DeserializeObject <Contact>(Encoding.UTF8.GetString(decryptedPayload));
Assert.AreEqual("kjasdjkahsda89dafhfafa", sentPayload.ImagePath);
Assert.AreEqual("Chiota User", sentPayload.Name);
Assert.AreEqual(publicKeyAddress, sentPayload.PublicKeyAddress);
Assert.AreEqual(requestAddress, sentPayload.ContactAddress);
Assert.IsTrue(InputValidator.IsAddress(sentPayload.ChatAddress));
Assert.IsTrue(InputValidator.IsAddress(sentPayload.ChatKeyAddress));
Assert.IsTrue(sentPayload.Request);
Assert.IsFalse(sentPayload.Rejected);
}
public async Task <Contact> AddContact(string login)
{
var contact = await HttpClientWrapper.GetAsync <Contact>(ApiEndpoints.GetUserInfo(login));
var key = _cryptographyProvider.AES.CreateKey();
var request = new AddContactRequest()
{
ContactName = login,
SymmetricKey = _cryptographyProvider.RSA.Encrypt(key.Key, contact.PublicKey),
IV = _cryptographyProvider.RSA.Encrypt(key.IV, contact.PublicKey)
};
contact = await HttpClientWrapper.PostAsync <Contact>(ApiEndpoints.Add(_userSettings.User.Login, login), request);
var properties = _propertyHandler.Load();
properties.Keys.Add(login, key);
_propertyHandler.Save(properties);
_userSettings.Keys.TryAdd(login, key);
_userSettings.User.Contacts.Add(contact);
return(contact);
}
public AddContactResponse RequestContact(string senderName, string receiverName)
{
var sender = this.Users.First(u => u.Name == senderName);
var receiver = this.Users.First(u => u.Name == receiverName);
var request = new AddContactRequest
{
Name = sender.Name,
ImagePath = string.Empty,
RequestAddress = sender.RequestAddress,
PublicKeyAddress = sender.PublicKeyAddress,
ContactAddress = receiver.PublicKeyAddress,
UserPublicKey = sender.NtruKeyPair.PublicKey
};
this.LastRequest = request;
var response = InstanceBag.AddContactInteractor.ExecuteAsync(
request).Result;
if (response.Code == ResponseCode.Success)
{
sender.Contacts.Add(
new Contact
{
IsApproved = false,
Name = receiver.Name,
NtruKeyPair = receiver.NtruKeyPair,
PublicKeyAddress = receiver.PublicKeyAddress,
RequestAddress = receiver.RequestAddress,
Seed = receiver.Seed
});
}
this.LastResponse = response;
return(response);
}
public async Task <AddContactResponse> AddContact(AddContactRequest request)
{
return(await Client.Execute <AddContactRequest, AddContactResponse>(request));
}
