public async void AddContactAsync_Creates_One_Contact_And_Returns_201_And_Contact_Created()
{
//declare a contact
Contact contact = _contacts.First();
ContactDTO expectedDTO = _mapper.Map <ContactDTO>(contact);
//set mockRepo return for Add action
_mockRepository.Setup(repo => repo.AddTAsync(contact)).ReturnsAsync(1);
//set repo return for getting the newly created object
_mockRepository.Setup(repo => repo.GetOneByAsync(co => co.Client_Id == contact.Client_Id &&
co.Name == contact.Name &&
co.Position == contact.Position)).ReturnsAsync(contact);
//instantiate the controller, passing the repo object
var controller = new ContactsController(_mockRepository.Object, _mapper, _logger);
//Call the SUT method
var actionResult = await controller.AddContactAsync(contact);
//Get the int result from the posted ActionResult
var createdResult = actionResult.Result as CreatedResult;
var statusCode = createdResult.StatusCode;
ContactDTO actualDto = createdResult.Value as ContactDTO;
//Assert the result
Assert.NotNull(actionResult);
//Validate returned status code
Assert.Equal(201, statusCode);
//Validate the result
actualDto.Should().BeEquivalentTo(expectedDTO, options => options.ComparingByMembers <ContactDTO>());
}
public async Task <ActionResult> AddContact([FromBody] ContactDTO contact)
{
var results = new GenericReturnObject();
try
{
if (contact.ContactId == Guid.Empty)
{
results.Success = false;
results.Message = "Empty Contact ID";
return(BadRequest(JsonConvert.SerializeObject(results)));
}
;
if (contact.UserId == Guid.Empty)
{
results.Success = false;
results.Message = "Empty UserId";
return(BadRequest(JsonConvert.SerializeObject(results)));
}
;
var userRequestingToAddContact = await _userService.GetUser(contact.UserId);
if (userRequestingToAddContact == default)
{
results.Success = false;
results.Message = "User doesn't exist";
return(BadRequest(JsonConvert.SerializeObject(results)));
}
var contactToAdd = await _userService.GetUser(contact.ContactId);
if (contactToAdd == default)
{
results.Success = false;
results.Message = "Contact doesn't exist";
return(BadRequest(JsonConvert.SerializeObject(results)));
}
var addContactResults = await _contactService.AddContact(new Contact
{
ContactId = contact.ContactId,
UserId = contact.UserId
});
if (!addContactResults.Item1)
{
results.Success = false;
results.Message = addContactResults.Item2; //Fix later with more legible code
return(BadRequest(JsonConvert.SerializeObject(results)));
}
}
catch (Exception ex)
{
results.Success = false;
results.Message = ex.Message;
}
results.Success = true;
return(Ok(JsonConvert.SerializeObject(results)));
}
public async Task <ItemDTO <int> > Post([FromBody] ContactDTO contactDTO)
{
var result = this._contactService.InsertContact(contactDTO);
await this._contactHub.SendInsertMessage(contactDTO.Name);
return(result);
}
public async Task <ItemDTO <int> > Put([FromBody] ContactDTO contactDTO)
{
var result = this._contactService.UpdateContact(contactDTO);
await this._contactHub.SendUpdateMessage(contactDTO.Name);
return(result);
}
public async Task <ActionResult <ContactDTO> > CreateContact([FromBody] ContactCreateDTO contactCreateDTO)
{
CreateContactCommand command = mapper.Map <CreateContactCommand>(contactCreateDTO);
ContactDTO contact = await mediator.Send(command);
return(CreatedAtAction("GetContactById", new { id = contact.Id }, contact));
}
void ExecuteSetCurrentItem(Int32 UserId)
{
if (Items == null)
{
Items = new ObservableRangeCollection <ContactDTO>();
}
CurrentOpenContactDTO = Items.FirstOrDefault(u => u.USERID == UserId);
}
public ActionResult DeleteConfirmed(int id)
{
ContactDTO contactDTO = db.Contact.Find(id);
db.Contact.Remove(contactDTO);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public bool UpdateContact(string id, ContactDTO contactDto)
{
var record = contacts.Where(a => a.Id == id).FirstOrDefault();
if (record != null)
{
record.Name = contactDto.Name;
record.Email = contactDto.Name;
record.Company = contactDto.Company;
record.Dob = contactDto.Dob;
if (contactDto.Address != null)
{
record.Address.Address1 = contactDto.Address.Address1;
record.Address.Address2 = contactDto.Address.Address2;
record.Address.City = contactDto.Address.City;
record.Address.State = contactDto.Address.State;
record.Address.ZipCode = contactDto.Address.ZipCode;
record.Address.Country = contactDto.Address.Country;
}
if (contactDto.PhoneNumber != null)
{
if (record.PhoneNumber != null)
{
record.PhoneNumber.PersonalPhone = contactDto.PhoneNumber.PersonalPhone;
record.PhoneNumber.WorkPhone = contactDto.PhoneNumber.WorkPhone;
}
else
{
PhoneNumber number = new PhoneNumber
{
PersonalPhone = contactDto.PhoneNumber.PersonalPhone,
WorkPhone = contactDto.PhoneNumber.WorkPhone
};
record.PhoneNumber = number;
}
}
else
{
record.PhoneNumber = null;
}
if (contactDto.Image != null && contactDto.Image.Length > 0)
{
var file = contactDto.Image;
contactDto.ImageUrl = id;
var fileNameExtension = Path.GetExtension(contactDto.Image.FileName);
contactDto.ImageUrl = String.Concat(id, fileNameExtension);
UpdateContactImage(contactDto);
}
return(true);
}
return(false);
}
public async Task <BatchDTO> PerformLoadAsync(ClientDTO clientDTO, ContactDTO contactDTO, CardDTO carDTO, BatchDTO batchDTO)
{
var client = (await _clientRepository.FilterAsync(filter: c => c.Ruc == clientDTO.Ruc,
includeProperties: "Contacts.Cards")).FirstOrDefault();
if (client == null)
{
client = new Client(clientDTO.Ruc, clientDTO.Address, clientDTO.Email, clientDTO.Name, clientDTO.Phone);
}
else
{
client.UpdateFields(clientDTO.Ruc, clientDTO.Address, clientDTO.Email, clientDTO.Name, clientDTO.Phone);
}
var mainContact = await _contactRepository.CreateOrUpdateMainContact(client, contactDTO.Phone, contactDTO.DocumentType,
contactDTO.DocumentNumber, contactDTO.FirstName,
contactDTO.LastName, contactDTO.Email);
var card = mainContact.Cards.FirstOrDefault(c => c.CardTypeId == carDTO.CardTypeId);
var cardType = _cardTypeRepository.Get(carDTO.CardTypeId);
var batchReason = "Recarga de saldo";
if (card == null)
{
batchReason = "Creación de tarjeta";
card = new Card(mainContact, cardType.Currency, carDTO.CardTypeId, carDTO.TPCode);
}
batchDTO.TPContractReason += " " + batchReason;
var expire = DateTime.Now.AddDays(cardType.Term);
var batch = new Batch(
new Money(batchDTO.Amount.Currency, batchDTO.Amount.Value),
expire, batchDTO.TPChasis,
batchDTO.TPContractDate,
batchDTO.TPInvoiceCode,
batchDTO.TPInvoiceDate,
batchDTO.TPContractType,
batchDTO.TPContractNumber,
batchDTO.TPContractReason,
batchDTO.DealerCode,
batchDTO.DealerName,
batchDTO.BusinessCode,
batchDTO.BusinessDescription
);
client.Batches.Add(batch);
_rechargeService.PerformRecharge(card, batch);
if (client.Id == 0)
{
_clientRepository.Add(client);
}
else
{
_clientRepository.Modify(client);
}
await _clientRepository.UnitOfWork.CommitAsync();
return(batch.ProjectedAs <BatchDTO>());
}
public ResponseDTO DeleteContactDetails(ContactDTO contactDTO)
{
ResponseDTO _outputList = new ResponseDTO();
int resultCode = 0;
_outputList = ApiHandler.ExecutePutAPI <ResponseDTO, ContactDTO>(_ContactAPIURL, "DeleteContactDetails", contactDTO, out resultCode);
return(_outputList);
}
public ResponseDTO CreateNewContact(ContactDTO contactDTO)
{
ResponseDTO _outputList = new ResponseDTO();
int resultCode = 0;
_outputList = ApiHandler.ExecutePostAPI <ResponseDTO, ContactDTO>(_ContactAPIURL, "AddContactDetails", contactDTO, out resultCode);
return(_outputList);
}
public IHttpActionResult CreateContact(ContactDTO contactdto)
{
var contact = Mapper.Map <ContactDTO, Contact>(contactdto);
_context.Contact.Add(contact);
_context.SaveChanges();
return(Ok(Mapper.Map <Contact, ContactDTO>(contact)));
}
public IHttpActionResult DeleteContact(ContactDTO contact)
{
if (contactrepository.Remove(contact))
{
return(Ok());
}
return(NotFound());
}
public async Task <ActionResult <ContactDTO> > PostContact(ContactDTO contactDTO)
{
Contact contact = ContactFromDTO(contactDTO);
_context.Contacts.Add(contact);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetContact", new { id = contact.ContactId }, ContactToDTO(contact)));
}
public void AddOK()
{
mockContactDTOAddRequest = FakeObjectsForTest.mockedContactDTOAddRequest();
mockContactDTOAddResponse = FakeObjectsForTest.mockedContactDTOAddResponseOK();
InitializeMocks();
var response = Add(mockContactDTOAddRequest);
AssertsForTest.AssertResponseContactAddOk(response);
}
public ContactDTO updateContact(ContactDTO contact)
{
var update = uow.GetRepository <Contact>().Get(z => z.Id == contact.Id);
update = MapperFactory.CurrentMapper.Map <Contact>(contact);
uow.GetRepository <Contact>().Update(update);
uow.SaveChanges();
return(MapperFactory.CurrentMapper.Map <ContactDTO>(update));
}
public override void beforeAll()
{
_site = new ObjectMother(AdministratorClarifySession).CreateSite();
_contact = new ObjectMother(AdministratorClarifySession).CreateContact(_site);
var assembler = Container.GetInstance <IModelBuilder <TableToViewWithManyDTOs> >();
_viewModel = assembler.GetOne(_contact.ObjId);
}
public static Contact ConvertContactDTOtoContact(ContactDTO contactDto)
{
return(new Contact
{
Id = Guid.NewGuid(),
ContactType = TranslateContact(contactDto.ContactType),
Value = contactDto.Value
});
}
public async Task <List <ContactDTO> > SearchContactByName(string name)
{
List <ContactDTO> contactDetails = new List <ContactDTO>();
List <Customer> customers = new List <Customer>();
string[] words = name.Split(' ');
foreach (var word in words)
{
List <Customer> resultfirst = await _dbConext.Customers.Where(c => c.FirstName.Contains(word)).ToListAsync();
if (resultfirst.Count > 0)
{
customers.AddRange(resultfirst);
}
List <Customer> resultLast = await _dbConext.Customers.Where(c => c.LastName.Contains(word)).ToListAsync();
if (resultLast.Count > 0)
{
customers.AddRange(resultLast);
}
}
if (customers.Count > 0)
{
List <Customer> uniqueCustomers = customers.Distinct().OrderBy(c => c.FirstName).ToList();
foreach (var customer in uniqueCustomers)
{
if (customer != null)
{
ContactDetails details = await _dbConext.ContactDetails.FirstOrDefaultAsync(d => d.CustomerId.Equals(customer.Id));
Address address = await _dbConext.Address.FirstOrDefaultAsync(a => a.ContactDetailsId.Equals(details.Id));
var contact = new ContactDTO
{
CustomerId = customer.Id.ToString(),
FirstName = customer.FirstName,
LastName = customer.LastName,
Gender = customer.Gender,
Email = details.Email,
MobilePhone = details.MobilePhone,
HomePhone = details.HomePhone,
FacebookId = details.FacebookId,
ContactDetailsId = details.Id.ToString(),
Street = address.Street,
City = address.City,
Province = address.Province,
ZipCode = address.ZipCode
};
contactDetails.Add(contact);
}
}
return(contactDetails);
}
return(null);
}
private ContactDTO getInstance(int id)
{
opContactBase op = new opContactBase();
op.Criteria.Id = id;
var result = _manager.ExecuteOperation(op);
ContactDTO dto = result.Items[0] as ContactDTO;
return(dto);
}
public void PostContactFreelance_WithVATNumber()
{
var person = new ContactDTO {
Id = 1, FirstName = "Laurent", LastName = "FIEVET", GSMNumber = "111515151", IsFreelance = true, VATNumber = "", Address = new AddressDTO {
Name = "test", City = "gfdfd", Country = "fdfdfd", PostalCode = "dfdfd", Street = "fdfdfd", StreetNumber = "fdfdfdfd"
}
};
validator.ShouldHaveValidationErrorFor(x => x.VATNumber, person);
}
public async Task CreateContact(ContactDTO model)
{
string uri = API.Contact.CreateContact(_remoteServiceBaseUrl);
var contact = new StringContent(JsonConvert.SerializeObject(model), Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync(uri, contact);
response.TrySaveModelStateErrors(ref modelStateErrors);
}
public void Edit(ContactDTO contact)
{
var mappedContract = _mapper.Map <Contact>(contact);
var result = _contactRepository.Edit(mappedContract);
if (!result.IsSuccess)
{
throw new ContactNotFoundException();
}
}
public IHttpActionResult GetContact(int id)
{
ContactDTO dto = contactrepository.Get(id);
if (dto == null)
{
return(NotFound());
}
return(Ok(dto));
}
public void DeleteContactService(ContactDTO entity)
{
var contact = contactRepository.GetAll().Where(r => r.ContactId == entity.ContactId).FirstOrDefault();
contact.ContactMessage = entity.ContactMessage;
contact.Sender = entity.Sender;
contact.SendingDate = entity.SendingDate;
contact.IsRead = entity.IsRead;
contactRepository.Delete(contact);
}
public async Task <IHttpActionResult> Get([FromODataUri] Guid key, CancellationToken cancellationToken)
{
ContactDTO contact = _phoneProvider.GetContact(key);
if (contact == null)
{
return(NotFound());
}
return(Ok(contact));
}
public async Task AddRecentContact(ContactDTO contact)
{
await Task.Factory.StartNew(() =>
{
var store = SmartStore.GetGlobalSmartStore();
CheckIfNeededSoupExists(store, RecentContactSoupName);
var record = JObject.FromObject(contact,
JsonSerializer.Create(CustomJsonSerializerSettings.Instance.Settings));
store.Upsert(RecentContactSoupName, record, Constants.Id, false);
});
}
public ActionResult Alterar([FromBody] ContactDTO contactDTO)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
applicationServiceContact.Update(contactDTO);
return(Ok("Contact changed successfully!"));
}
public IHttpActionResult GetContact(int id)
{
ContactDTO contact = _contactService.GetContactById(id);
if (contact == null)
{
return(NotFound());
}
return(Ok(contact));
}
public ActionResult Insert([FromBody] ContactDTO contactDTO)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
applicationServiceContact.Insert(contactDTO);
return(Ok("Contact successfully registered!"));
}
private static void SaveContactInDb(ContactDTO contact)
{
if (contact.Name == null)
{
throw new ArgumentException("Name is required");
}
var ct = new Contact()
{
Name = contact.Name
};
if (contact.Company != null) ct.Company = contact.Company;
if (contact.Site != null) ct.Url = contact.Site;
if (contact.Position != null) ct.Postion = contact.Position;
if (contact.Notes != null)
{
ct.Notes = new HashSet<string>();
ct.Notes.Add(contact.Notes);
}
if (contact.Emails != null)
{
ct.Emails = new HashSet<Email>();
foreach (var em in contact.Emails.Select(email => new Email() {EmailAddress = email}))
{
ct.Emails.Add(em);
}
}
if (contact.Phones != null)
{
ct.Phones = new HashSet<Phone>();
foreach (var ph in contact.Phones.Select(phone => new Phone() {PhoneNumber = phone}))
{
ct.Phones.Add(ph);
}
}
var context = new PhonebookContext();
context.Contacts.Add(ct);
context.SaveChanges();
}
public Contact Map(ContactDTO dto)
{
if (dto == null) return null;
Contact contact = Mapper.Map<ContactDTO, Contact>(dto);
contact.MStatus = MaritalStatas.Single;// _maritalStatusRepository.GetById(dto.MaritalStatusMasterId);
contact.ContactType = _contactTypeRepository.GetById(dto.ContactTypeMasterId);
return contact;
}
public void TransformDTOtoContact()
{
var adapter = new TypeAdapter<ContactDTO, Contact>();
var contact = new ContactDTO()
{
FirstName = "gates"
};
var dto = adapter.Transform<ContactDTO,Contact>(contact);
Assert.Equal(dto.FirstName, contact.FirstName);
}
