public void Initialize()
{
_repository = new ContactRepository();
_repository.Add(new Contact { Id = 1, Name = "Contact one", Email = "*****@*****.**", Phone = "555-1234" });
_repository.Add(new Contact { Id = 2, Name = "Contact two", Email = "*****@*****.**", Phone = "555-2222" });
_repository.Add(new Contact { Id = 3, Name = "Contact three", Email = "*****@*****.**", Phone = "555-3333" });
}
public int AddCategory(Models.DomainModels.Contact Contact)
{
contactRepository.Add(Contact);
contactRepository.SaveChanges();
return(Contact.ContactID); // If Exception occurs this line will not be executed
}
public string ImportData(ScrapeDto dto)
{
if (dto.ClientId < 0)
{
return("Invalid contactId");
}
var urlparams = $"?amount={dto.Count}®ion={dto.Country}&ext";
var response = _apiClient.Get(_settings.Value.ApiUrls.Url, urlparams);
if (response.StatusCode != HttpStatusCode.OK)
{
return($"Data retrieval failed form: {_settings.Value.ApiUrls.Url}{urlparams}");
}
var importedContactsList = JsonConvert.DeserializeObject <List <ImportedContactsDto> >(response.Content);
if (importedContactsList == null || importedContactsList.Count == 0)
{
return("No Contacts imported from external api");
}
var data = Mapper.Map <List <ImportedContactsDto>, List <ImportedContact> >(importedContactsList);
data.ForEach(item =>
{
_contactRepo.Add(item, dto.ClientId);
});
return($"{data.Count} Contacts Imported");
}
public IActionResult Create([FromBody] Contact[] contacts)
{
if (contacts == null)
{
return(BadRequest());
}
foreach (Contact contact in contacts)
{
_contactRepository.Add(contact);
}
return(CreatedAtRoute("Getcontact", new { id = contacts.Count() }, contacts));
}
public void Initialize()
{
_repository = new ContactRepository();
_repository.Add(new Contact {
Id = 1, Name = "Contact one", Email = "*****@*****.**", Phone = "555-1234"
});
_repository.Add(new Contact {
Id = 2, Name = "Contact two", Email = "*****@*****.**", Phone = "555-2222"
});
_repository.Add(new Contact {
Id = 3, Name = "Contact three", Email = "*****@*****.**", Phone = "555-3333"
});
}
public async Task <ActionResult> Create(ContactViewModel contactVm)
{
if (!ModelState.IsValid)
{
contactVm.PartnerNumberSelection = await GetPartnerSelection();
return(View(contactVm));
}
_contactRepository.Add(contactVm.Map <Contact>());
await UnitOfWork.CompleteAsync();
return(RedirectToAction("List"));
}
public async Task <IHttpActionResult> UpdateAsync(int id, ContactDto contact)
{
var contactInDb = await _contactRepository.GetAsync(id);
if (contactInDb == null)
{
return(NotFound());
}
_contactRepository.Add(contact.Map <Contact>());
await UnitOfWork.CompleteAsync();
return(Ok());
}
/// <summary>
/// Sign someone up to the mailing list.
/// </summary>
public OperationResult <Contact> SignUpToMailingList(SignUpViewModel model)
{
if (_contactRepository.GetByEmail(model.Email) != null)
{
return(new OperationResult <Contact>(null, OperationStatus.Error, "This email has already been added to the mailing list."));
}
var response = _contactRepository.Add(Mapper.Map <Contact, ContactEntity>(new Contact {
Email = model.Email
}));
if (response != null)
{
var apiKey = (_appConfiguration.Value.SendGridApiKey);
var client = new SendGridClient(apiKey);
var from = new EmailAddress(_appConfiguration.Value.AdminEmail, "Levin Blog Admin");
var subject = $"Welcome to {_appConfiguration.Value.SiteTitle}.";
var to = new EmailAddress(model.Email);
var plainTextContent = $"Dear {model.Email}, Thank you for signing up for Levin Blog, here is the url {_appConfiguration.Value.SiteUrl}";
var htmlContent = $"Dear {model.Email}, Thank you for signing up for Levin Blog, here is the url {_appConfiguration.Value.SiteUrl}";
var msg = MailHelper.CreateSingleEmail(from, to, subject, plainTextContent, htmlContent);
client.SendEmailAsync(msg).Wait();
}
return(new OperationResult <Contact>(Mapper.Map <ContactEntity, Contact>(response), OperationStatus.Created));
}
public JsonResult contact(tb_contact model)
{
if (model != null)
{
if (ModelState.IsValid)
{
try
{
contactRepository.Add(model);
contactRepository.Save();
contactMailer.ContactToutokazz(model).Send();
}
catch (Exception exp) {
return(Json(exp.Message, JsonRequestBehavior.AllowGet));
}
string msg = "Merci de nous contacter, nous vous repondrons prochainement";
return(Json(msg, JsonRequestBehavior.AllowGet));
}
else
{
string msg = "Une erreur a ete detecte lors dans les valeurs saisie.";
return(Json(msg, JsonRequestBehavior.AllowGet));
}
}
else
{
string msg = "Une erreur a ete detecte lors dans les valeurs saisie.";
return(Json(msg, JsonRequestBehavior.AllowGet));
}
}
public async Task <ActionResult <ContactLogModel> > Post(ContactLogModel model, string moniker)
{
try
{
var student = await _repository.GetStudentAsync(moniker);
if (student == null)
{
return(BadRequest("Student not found."));
}
var contact = _mapper.Map <ContactLog>(model);
contact.Student = student;
_repository.Add(contact);
if (await _repository.SaveChangesAsync())
{
var url = _linkGenerator.GetPathByAction(HttpContext, "Get", values:
new { moniker, id = contact.Id });
return(Created(url, _mapper.Map <ContactLogModel>(contact)));
}
else
{
return(BadRequest("Failed to save new contact"));
}
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public async Task <ActionResult <StudentModel> > Post(StudentModel model)
{
try
{
var existing = await _repository.GetStudentAsync(model.Moniker);
if (existing != null)
{
return(BadRequest("Moniker in use."));
}
var location = _linkGenerator.GetPathByAction("Get", "Students", new { moniker = model.Moniker });
if (string.IsNullOrWhiteSpace(location))
{
return(BadRequest("Could not use moniker."));
}
var student = _mapper.Map <Student>(model);
_repository.Add(student);
if (await _repository.SaveChangesAsync())
{
return(Created($"/api/students/{student.Moniker}", _mapper.Map <StudentModel>(student)));
}
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex));
}
return(BadRequest());
}
private Contact CreateNewContact()
{
var contact = new Contact();
_contactRepository.Add(contact);
return(contact);
}
public async Task <IActionResult> PostAddress([FromBody] AddressDTO contactDto, Guid tenantId, Guid userId, Guid contactId)
{
if (await _tenantRepo.GetById(tenantId) == null)
{
return(BadRequest("Invalid tenant id"));
}
if (await _userRepo.GetById(userId) == null)
{
return(BadRequest("Invalid user id"));
}
if (await _contactRepo.GetById(contactId) == null)
{
return(BadRequest("Invalid user id"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Address not added properly"));
}
await _repository.Add(new Address { City = contactDto.City, ContactId = contactId });
return(Created("", "New Address Added Successfully"));
}
public async Task <IActionResult> Add([FromBody] Contact contact)
{
var userId = _claimsProvider.GetUserId(this.HttpContext);
var domainContact = await _repository.Add(userId, _mapper.Map <Contact, DomainObjects.Contact>(contact));
return(CreatedAtAction(nameof(GetById), new { id = domainContact.Id }, _mapper.Map <DomainObjects.Contact, Contact>(domainContact)));
}
public async Task <ResultModel <Dictionary <string, object> > > Create(Dictionary <string, object> model)
{
try
{
IEnumerable <AddedColumn> addedColumns = await _addedColumn.GetAll();
Contact entity = MapToEntity(model, addedColumns);
var checkunique = await _contact.GetAll(t => t.Name == entity.Name);
if (checkunique.Any())
{
return(ResultModel <Dictionary <string, object> > .GetErrorResult(new List <ResultErrorModel> {
new ResultErrorModel(ResultErrorTypeEnum.UniqueFieldError, new string[] { "Contact Name" })
}));
}
entity = await _contact.Add(entity);
await _contact.Commit();
model = MapToModel(entity);
return(ResultModel <Dictionary <string, object> > .GetSuccessResult(model));
}
catch (Exception e)
{
await _contact.Abort();
ResultErrorModel error = new ResultErrorModel(e);
return(ResultModel <Dictionary <string, object> > .GetExceptionResult(error));
}
}
public void Add(Contact contact)
{
contact.CreatedDate = contact.ModifiedDate = System.DateTime.Now;
contact.CreatedBy = contact.ModifiedBy = "System";
contactRepository.Add(contact);
}
public async Task CreateAsync([FromBody] Contact contact)
{
if (ModelState.IsValid)
{
await _iContactRepository.Add(contact);
}
}
public async Task <IActionResult> Create([FromBody] ContactDto contact)
{
if (contact == null)
{
return(BadRequest("No existe un contacto para guardar"));
}
var contactClient = new Contact
{
Id = Guid.NewGuid(),
Nombres = contact.Nombres,
Empresa = contact.Empresa,
Correo = contact.Correo,
Telefono = contact.Telefono,
Mensaje = contact.Mensaje,
FechaCreacion = DateTime.Now,
FechaModificacion = DateTime.Now
};
contactClient = await contactRepository.Add(contactClient);
var sender = configuration.GetSection("Settings").GetSection("EnvioCorreo").GetSection("Sender").Value;
var password = configuration.GetSection("Settings").GetSection("EnvioCorreo").GetSection("Password").Value;
UtilsSendEmail.SendEmailNotificacion(contactClient.Correo, contactClient.Nombres, contactClient.Empresa, contactClient.Correo, contactClient.Telefono, contactClient.Mensaje, sender, password);
return(Ok());
}
public void InsertNew(Contact contact)
{
//Validate rules for contact
_contactRepository.Add(contact);
_contactRepository.Commit();
}
public IActionResult Add(ContactModel contactModel)
{
// add contact
_contactRepository.Add(contactModel);
TempData["SuccessMessage"] = "Contact created successfully";
return(RedirectToAction("All"));
}
public IActionResult Post([FromBody] ContactModel model)
{
var contact = Mapper.Map <Contact>(model);
_contactRepository.Add(contact);
return(Ok(contact));
}
public async Task <ContactListDTO> AddContact(ContactDTO contactDTO)
{
var currentContact = (await _contactRepository.FilterAsync(filter: c => c.Phone == contactDTO.ContactParent.Phone, includeProperties: "Client")).FirstOrDefault();
var existingContact = _contactRepository.Filter(c => c.Phone == contactDTO.Phone).FirstOrDefault();
if (existingContact != null)
{
throw new InvalidOperationException(_resources.GetStringResource(LocalizationKeys.Application.exception_ContactAlreadyExists));
}
if (currentContact.Client != null)
{
var contact = new Contact(
currentContact.Client,
ContactType.Secondary,
contactDTO.DocumentType,
contactDTO.DocumentNumber,
contactDTO.Phone,
contactDTO.FirstName,
contactDTO.LastName,
contactDTO.Email,
currentContact.Id
);
_contactRepository.Add(contact);
await _contactRepository.UnitOfWork.CommitAsync();
return(contact.ProjectedAs <ContactListDTO>());
}
else
{
throw new InvalidOperationException(_resources.GetStringResource(LocalizationKeys.Application.exception_CannotCreateContactForNonExistingClient));
}
}
public IActionResult ContactCreate(ContactCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var newContact = new Contact
{
FirstName = model.FirstName,
LastName = model.LastName,
Role = model.Role,
Email = model.Email,
Phone = model.Phone,
Mkt = model.Mkt,
CIOCircle = model.CIOCircle,
InnovationForum = model.InnovationForum,
TAC = model.TAC,
PostalAddress = model.PostalAddress,
Comments = model.Comments,
ApplicationUserId = model.ApplicationUserId,
};
var response = _contactRepository.Add(newContact);
if (response == null || response.Id == 0)
{
return(View());
}
return(RedirectToAction("Index"));
}
private void View_SaveContactClicked(object sender, ContactsViewEventArgs e)
{
try
{
if (SelectedContact?.Id == null)
{
SelectedContact = new Contact();
contactRepository.Add(SelectedContact);
}
SelectedContact.FirstName = View.FirstName;
SelectedContact.LastName = View.LastName;
SelectedContact.Phone = View.Phone;
SelectedContact = null;
}
catch (Exception ex)
{
alertService.ShowError($"Error removing contact: {Environment.NewLine}{ex.ToString()}", "Contacts");
}
finally
{
Display();
DisplayDetail();
}
}
public async Task <ActionResult> PostContact([FromBody] ContactDTO contactDto, Guid userId, Guid tenantId)
{
if (await _tenantRepo.GetById(tenantId) == null)
{
return(BadRequest("Invalid tenant id"));
}
if (await _userRepo.GetById(userId) == null)
{
return(BadRequest("Invalid user id"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Contact not inserted properly"));
}
Contact contact = await _repository.FirstOrDefault(x => x.MobileNumber == contactDto.MobileNumber);
if (contact != null)
{
return(BadRequest("Mobile number is already exist"));
}
await _repository.Add(new Contact { Name = contactDto.Name, MobileNumber = contactDto.MobileNumber, UserId = userId, IsFavorite = contactDto.IsFavorite });
return(Created("", "New Contact Added Successfully"));
}
public ActionResult Action(tblContact objSubmit)
{
if (objSubmit.ID == 0)
{
objSubmit.DateCreated = DateTime.Now;
objSubmit.DateUpdated = DateTime.Now;
objSubmit.IsDeleted = false;
objSubmit.IsViewed = false;
contactRepository.Add(objSubmit);
}
else
{
var obj = contactRepository.GetById <tblContact>(objSubmit.ID);
UpdateModel(obj);
objSubmit.DateUpdated = DateTime.Now;
contactRepository.Update(obj);
}
return(Json(new
{
Error = false
}, JsonRequestBehavior.AllowGet));
}
public IActionResult AddContact([FromBody] ContactCreateDto contactDto)
{
if (contactDto is null)
{
return(BadRequest(ModelState));
}
if (_contactRepository.Exists(c => c.Name == contactDto.Name && c.Surname == contactDto.Surname))
{
ModelState.AddModelError("", "contact already in the database");
return(StatusCode(500, ModelState));
}
Contact contact = _mapper.Map <Contact>(contactDto);
_contactRepository.Add(_mapper.Map <Contact>(contactDto));
if (_contactRepository.Save() > 0)
{
return(CreatedAtRoute("GetContact", new { contact.Id }, contact));
}
else
{
ModelState.AddModelError("", "Something went wrong savign the contact");
return(StatusCode(500, ModelState));
}
}
public void AddTest()
{
Contact Contact = new Contact(new Guid());
Contact.FirstName = "My Test Contact";
repository.Add(Contact);
this.unitOfWork.Commit();
Contact savedContact = this.repository.FindBy(Contact.Key);
Assert.AreEqual("My Test Contact", savedContact.FirstName);
this.repository.Remove(savedContact);
this.unitOfWork.Commit();
}
void IContactService.Create(Contact contact)
{
_repository.Add(contact);
if (this._log.IsInfoEnabled)
{
this._log.InfoFormat("新增联系人#{0}|{1}|{2}", contact.ID, contact.FullName, contact.Email);
}
}
/// <summary>
/// Create contact ,actually message sending by every website visitor
/// </summary>
/// <param name="contactViewModel"></param>
/// <returns></returns>
public Contact CreateContact(ContactViewModel contactViewModel)
{
var contact = contactViewModel.ConvertToContactModel();
contact.CreationTime = DateTime.Now;
_contactRepository.Add(contact);
_contactRepository.SaveChanges();
return(contact);
}
public void DeleteContact_Should_Remove_Contact_From_Database_But_Keep_Person()
{
WhatsAppContact contactOnDb = new WhatsAppContact {
Person = new Person {
Name = "name"
}, Name = "home", WhatsAppNumber = "0000-0000"
};
_contactRepository.Add(contactOnDb);
_contactsService.DeleteContact(contactOnDb);
IEnumerable <Contact> contactsOnDb = _contactRepository.RetrieveAll();
IEnumerable <Person> personOnDb = _personRepository.RetrieveAll();
contactsOnDb.Should().BeEmpty();
personOnDb.Should().HaveCount(1);
}