public ActionResult Save(CreateContactViewModel model)
{
Contact newContact = new Contact()
{
Address = model.Address,
Name = model.Name,
Lastname = model.Lastname,
Avatar = "",
BirthDay = DateTime.Now.AddDays(-5045),
WebSite = model.WebSite,
Numbers = new List <TelephoneNumber>()
{
new TelephoneNumber("Home", "+39 051 552 888"),
new TelephoneNumber("Work", "+39 051 888 225")
},
Emails = new List <EmailAddress>()
{
new EmailAddress("Home", "*****@*****.**"),
new EmailAddress("Work", "*****@*****.**")
}
};
StoreDB.AddContact(newContact);
ViewBag.Contact = newContact;
ViewBag.Contacts = StoreDB.GetContactsShort();
return(Redirect("index"));
}
public JsonResult CreateContacts(CreateContactViewModel contactVM)
{
// TriggerProfileKey("ProfileNAME", "ProfileKEY", 10);
contactVM = RegisterContact(contactVM);
// return View("~/Views/Page/Contacts/CreateContact.cshtml",contactVM);
return(Json(new { Message = contactVM.OperationStatus }, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult <ContactViewModel> > CreateContact([FromBody] CreateContactViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(ModelStateErrorResponseError());
}
var createContactCommand = _mapper.Map <CreateContactCommand>(model);
var result = await Mediator.SendCommandAsync(createContactCommand);
if (result.Success)
{
await Mediator.NotifyDomainNotification(
DomainNotification.Success($" The contact to {model.ContactName} was add with success !"));
}
var contactId = result.Id;
var contact = await _contactRepository.GetContactById(contactId);
if (contact == null)
{
NotifyError("Fail to create the contact");
return(ModelStateErrorResponseError());
}
var returnModel = _mapper.Map <ContactViewModel>(contact);
return(ResponsePost(
nameof(CreateContact),
returnModel));
}
public async Task <ActionResult> AddContact([FromBody] CreateContactViewModel model)
{
try
{
await _contactService.CreateNewContact(
model.FirstName,
model.LastName,
model.Email,
model.Birthday,
model.Gender,
model.IsFavorite,
model.Company,
model.Avatar,
model.Address,
model.Phone,
model.Comments
);
return(StatusCode(201));
}
catch (BadRequestException e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> CreateContactAsync(CreateContactViewModel model)
{
try
{
ContactDto contact = new ContactDto
{
Name = model.Name,
TelephoneNumber1 = model.TelephoneNumber1,
TelephoneNumber2 = model.TelephoneNumber2,
Address = model.Address,
Email = model.Email,
LegalOrNaturalPerson = model.LegalOrNaturalPerson,
Profession = model.Profession,
CompanyId = model.CompanyId
};
await contactService.CreateAsync(contact);
return(RedirectToAction("ContactsList", "Contact"));
}
catch (Exception ex)
{
ErrorViewModel errorModel = new ErrorViewModel();
errorModel.ErrorMessage = ex.Message.ToString();
return(View("Views/Shared/Error.cshtml", errorModel));
}
}
public async Task CreateValidContact()
{
var faker = new Faker();
var viewModel = new CreateContactViewModel
{
FirstName = faker.Name.FirstName(),
LastName = faker.Name.LastName(),
Email = faker.Internet.Email(),
Birthday = faker.Date.Past(18),
IsFavorite = false,
Gender = "m",
Address = faker.Address.FullAddress(),
Avatar = faker.Internet.Avatar(),
Company = faker.Company.CompanyName(),
Phone = faker.Phone.PhoneNumber("(##) #####-####"),
Comments = faker.Random.Words(faker.Random.Int(0, 100))
};
var client = _factory.CreateClient();
var result = await client.PostAsJsonAsync("/api/contacts", viewModel);
result.EnsureSuccessStatusCode();
var contact = await _factory.DbContext.Contacts.SingleOrDefaultAsync();
Assert.Equal(viewModel.FirstName, contact.FirstName);
Assert.Equal(viewModel.LastName, contact.LastName);
Assert.Equal(viewModel.Email, contact.Email);
}
public async Task OnGetAsync()
{
Contact = new CreateContactViewModel();
var groupLookup = await _contactAppService.GetGroupLookupAsync();
Groups = groupLookup.Items.Select(x => new SelectListItem(x.Name, x.Id.ToString())).ToList();
}
public IActionResult Delete(CreateContactViewModel vm)
{
Contact contact = _context.Contacts.Single(m => m.Id == vm.Id);
_context.Contacts.Remove(contact);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Contact(CreateContactViewModel viewModel)
{
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
return(View("Contact", viewModel));
}
public IHttpActionResult Post(CreateContactViewModel newModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_service.Create(_mapper.Map <Contact>(newModel));
return(Ok());
}
public async Task <IActionResult> CreateContactAsync(CreateContactViewModel createContactViewModel)
{
var createCommentDTO = _mapper.Map <CreateContactDTO>(createContactViewModel);
var resultDTO = await _contactService.CreateContactAsync(createCommentDTO);
var resultVM = _mapper.Map <ContactViewModel>(resultDTO);
return(Ok(resultVM));
}
public ActionResult CreateContacts()
{
CreateContactViewModel contactVM = new CreateContactViewModel
{
PageTitle = "Contacts Creation",
PageIntro = "Use this page to create contacts in Experience Profile"
};
return(View("~/Views/Page/Contacts/CreateContact.cshtml", contactVM));
}
public ActionResult Create([Bind(Include = "Name,LastName,IsActive")] CreateContactViewModel contact)
{
if (ModelState.IsValid)
{
var domainObject = AutoMapper.Mapper.Map <Contact>(contact);
contactService.CreateContact(domainObject);
return(RedirectToAction("Index"));
}
return(View(contact));
}
public async Task <IActionResult> Contact()
{
var user = await _userManager.GetUserAsync(User);
var model = new CreateContactViewModel
{
Email = user.Email
};
return(View(model));
}
public ActionResult Index(CreateContactViewModel model)
{
this.contacts.Add(new Contact()
{
Subject = model.Subject,
Email = model.Email,
Message = model.Message
});
this.TempData["Notification"] = "Message succesfuly sent";
return this.RedirectToAction(x => x.Index());
}
public async Task <ActionResult <Contact> > PostContact(CreateContactViewModel contact)
{
Contact c = new Contact
{
PersonId = contact.PersonId,
Type = contact.Type,
Value = contact.Value
};
await _contactsRepository.CreateContactAsync(c);
return(StatusCode(201));
}
public async Task <IViewComponentResult> InvokeAsync(
string actionUrl = "",
string formTitle = "",
string formDescription = "",
string coverImageUrl = "",
bool withContactInfo = false,
bool withSocialNetworks = false,
string viewName = null)
{
var model = new CreateContactViewModel {
WidgetTitle = formTitle,
WidgetDescription = formDescription,
WidgetCoverImageUrl = coverImageUrl,
WidgetActionUrl = actionUrl
};
if (withContactInfo)
{
var contactInfo = await _websiteOptionService.GetContactInfoAsync();
if (contactInfo != null)
{
model.ContactInfo = contactInfo.Adapt <WebsiteContactInfoViewModel>();
}
}
if (withSocialNetworks)
{
var socialNetworks = await _websiteOptionService.GetSocialNetworksAsync();
if (socialNetworks != null)
{
model.SocialNetworks = socialNetworks.Adapt <WebsiteSocialNetworksViewModel>();
}
}
if (viewName.IsNotNullOrEmpty())
{
return(await Task.FromResult(
View(viewName, model)
));
}
return(await Task.FromResult(
View(model)
));
}
public async Task <IActionResult> Create([Bind("Type,Value,PersonId")] CreateContactViewModel contact)
{
if (ModelState.IsValid)
{
Contact c = new Contact
{
PersonId = contact.PersonId,
Type = contact.Type,
Value = contact.Value
};
await _contactsRepository.CreateContactAsync(c);
return(RedirectToAction(nameof(Index)));
}
ViewData["PersonId"] = new SelectList(await _peopleRepository.GetPeopleAsync(), "Id", "Nome", contact.PersonId);
return(View(contact));
}
public void Contact_OnPostWithValidViewModel_ReturnsCorrectView()
{
var controller = new HomeController();
var viewModel = new CreateContactViewModel
{
Name = "mike",
Email = "*****@*****.**",
Message = "okish",
Phone = 1234569871
};
var result = controller.Contact(viewModel) as RedirectToRouteResult;
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.RouteValues["Action"]);
}
// GET: Contact/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
Contact contact = _context.Contacts.Single(m => m.Id == id);
if (contact == null)
{
return(HttpNotFound());
}
List <string> list = new List <string>();
if (contact.isAssociate)
{
list.Add("Associate");
}
if (contact.isColleague)
{
list.Add("Colleague");
}
if (contact.isFamily)
{
list.Add("Family");
}
if (contact.isFriend)
{
list.Add("Friend");
}
CreateContactViewModel vm = new CreateContactViewModel()
{
FirstName = contact.FirstName,
LastName = contact.LastName,
BirthDate = contact.BirthDate,
EmailAddress = contact.EmailAddress,
PhoneNumber = contact.PhoneNumber,
SelectedGroups = list
};
return(View(vm));
}
public IActionResult CreateContact(CreateContactViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var contact = _contactService.Create(model);
if (!contact.Valid)
{
return(ValidationProblem(contact.GetAllNotifications()));
}
return(Created(
$@"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}{HttpContext.Request.Path}/{contact.Id}",
contact));
}
public async Task <ActionResult> Create([Bind(Include = "FirstName, LastName, EMail, TelephoneNumber_Entry")] CreateContactViewModel createContactVModel)
{
try
{
if (ModelState.IsValid)
{
var req = new ContactCreateRequest
{
LastName = createContactVModel.LastName,
FirstName = createContactVModel.FirstName,
EMail = createContactVModel.EMail,
TelephoneNumber_Entry = createContactVModel.TelephoneNumber_Entry,
Creator = LoggedInUserFacade.UserName
};
var result = await _contactRepository.ContactCreateAsync(req);
this.AddToastMessage(@Resource.Resource.Toast_Success, @Resource.Resource.CreateContact_Toast_Success, ToastType.Success);
return(RedirectToAction("Edit", new { id = result.Contact.Id }));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", @Resource.Resource.Model_Error_Unable_To_Perform_Action);
this.AddToastMessage(@Resource.Resource.CreateContact_Toast_Failure, ex.Message, ToastType.Error);
var em = new ContactCreateExceptionMessage {
Message = ex.Message
};
Log.Error(ex, ex.Message);
return(View("ContactCreationFailed", em));
}
return(View(createContactVModel));
}
public async Task CreateInvalidEmailContact()
{
var faker = new Faker();
var viewModel = new CreateContactViewModel
{
FirstName = faker.Name.FirstName(),
LastName = faker.Name.LastName(),
Email = "INVALID_EMAIL",
Birthday = faker.Date.Past(18),
IsFavorite = false,
Gender = "m",
Address = faker.Address.FullAddress(),
Avatar = faker.Internet.Avatar(),
Company = faker.Company.CompanyName(),
Phone = faker.Phone.PhoneNumber("(##) #####-####"),
Comments = faker.Random.Words(faker.Random.Int(0, 100))
};
var client = _factory.CreateClient();
var result = await client.PostAsJsonAsync("/api/contacts", viewModel);
Assert.Equal(HttpStatusCode.BadRequest, result.StatusCode);
}
public IActionResult Contact([Bind("Email, FullName, Message")] CreateContactViewModel model)
{
if (ModelState.IsValid)
{
var user = new CreateContactViewModel
{
Email = model.Email,
FullName = model.FullName,
Message = model.Message
};
var adminUsers = (from p in _context.Users
join e in _context.UserRoles on p.Id equals e.UserId
where e.RoleId == "b51d6fb0-1d08-4e6a-854c-10d1f1d84a71"
select new
{
email = p.Email
}).ToList();
for (int i = 0; i < adminUsers.Count; i++)
{
var email = new EmailComposer
{
emailAddressSender = "*****@*****.**",
emailAddressRecipient = adminUsers[i].email,
smtpServiceAddress = "smtp.sapo.pt",
port = 25,
password = "******",
subject = user.FullName + " is contacting the administration",
body = user.Message + "\nUser Email: " + user.Email,
};
email.SendEmail();
}
}
return(RedirectToAction("Contact"));
}
public async Task <IActionResult> Create(CreateContactViewModel vm, IFormFile file)
{
if (ModelState.IsValid)
{
Contact contact = new Contact();
contact.BirthDate = vm.BirthDate;
contact.Comments = vm.Comments;
contact.EmailAddress = vm.EmailAddress;
contact.FirstName = vm.FirstName;
contact.LastName = vm.LastName;
contact.PhoneNumber = vm.PhoneNumber;
// File upload logic
var uploads = Path.Combine(_environment.WebRootPath, "images/UploadedProfileImages");
if (file != null && file.Length > 0)
{
contact.ProfileImagePath = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
await file.SaveAsAsync(Path.Combine(uploads, contact.ProfileImagePath));
}
//
if (vm.SelectedGroups != null)
{
foreach (string group in vm.SelectedGroups)
{
switch (group)
{
case "Associate":
contact.isAssociate = true;
break;
case "Colleague":
contact.isColleague = true;
break;
case "Family":
contact.isFamily = true;
break;
case "Friend":
contact.isFriend = true;
break;
default:
contact.isAssociate = false;
contact.isColleague = false;
contact.isFamily = false;
contact.isFriend = false;
break;
}
}
}
else
{
contact.isAssociate = false;
contact.isColleague = false;
contact.isFamily = false;
contact.isFriend = false;
}
_context.Contacts.Add(contact);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(vm));
}
public CreateContactViewModelTest()
{
mockRepository = new ContactRepositoryMock();
subject = new CreateContactViewModel(mockRepository);
}
public static CreateContactViewModel RegisterContact(CreateContactViewModel contactVM)
{
CreateContactViewModel conctVMLocal = contactVM;
// var offlineGoal = Guid.Parse("A9948719-E6E4-46D2-909B-3680E724ECE9");//offline goal - KioskSubmission goal
// var channelId = Guid.Parse("3FC61BB8-0D9F-48C7-9BBD-D739DCBBE032"); // /sitecore/system/Marketing Control Panel/Taxonomies/Channel/Offline/Store/Enter store - offline enter storl channel
var goal = Guid.Parse("D59F316C-8C87-44A9-8347-E66C5A996CF5"); //online goal- directsitesubmission goal
var channelId = Guid.Parse("B418E4F2-1013-4B42-A053-B6D4DCA988BF"); // /sitecore/system/Marketing Control Panel/Taxonomies/Channel/Online/Direct/Direct - online direct channel
CertificateWebRequestHandlerModifierOptions options =
CertificateWebRequestHandlerModifierOptions.Parse("StoreName=My;StoreLocation=LocalMachine;FindType=FindByThumbprint;FindValue=587d948806e57cf511b37a447a2453a02dfd3686");
// Optional timeout modifier
var certificateModifier = new CertificateWebRequestHandlerModifier(options);
List <IHttpClientModifier> clientModifiers = new List <IHttpClientModifier>();
var timeoutClientModifier = new TimeoutHttpClientModifier(new TimeSpan(0, 0, 20));
clientModifiers.Add(timeoutClientModifier);
// This overload takes three client end points - collection, search, and configuration
var collectionClient = new CollectionWebApiClient(new Uri("https://sc9.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var searchClient = new SearchWebApiClient(new Uri("https://sc9.xconnect/odata"), clientModifiers, new[] { certificateModifier });
var configurationClient = new ConfigurationWebApiClient(new Uri("https://sc9.xconnect/configuration"), clientModifiers, new[] { certificateModifier });
var config = new XConnectClientConfiguration(
new XdbRuntimeModel(CollectionModel.Model), collectionClient, searchClient, configurationClient);
config.Initialize();
using (Sitecore.XConnect.Client.XConnectClient client = new XConnectClient(config))
{
bool isExist = false;
Contact extContact = client.Get <Contact>(new IdentifiedContactReference("HIxConnect", contactIdentifierPrefix + contactVM.FormEmailAddress), new ContactExpandOptions(new string[] { PersonalInformation.DefaultFacetKey, EmailAddressList.DefaultFacetKey }));
if (extContact != null)
{
isExist = true;
}
try
{
// Identifier for a 'known' contact
var identifier = new ContactIdentifier[]
{
new ContactIdentifier("HIxConnect", contactIdentifierPrefix + contactVM.FormEmailAddress, ContactIdentifierType.Known)
};
Contact knownContact = null;
if (isExist)
{
knownContact = extContact;
}
else
{
// Create a new contact with the identifier
knownContact = new Contact(identifier);
client.AddContact(knownContact);
}
//Persona information facet
PersonalInformation personalInfoFacet = new PersonalInformation();
personalInfoFacet.FirstName = contactVM.FormFirstName;
personalInfoFacet.LastName = contactVM.FormLastName;
personalInfoFacet.JobTitle = contactVM.FormJobTitle;
client.SetFacet <PersonalInformation>(knownContact, PersonalInformation.DefaultFacetKey, personalInfoFacet);
Interaction interaction = null;
if (!isExist)
{
// Create a new interaction for that contact
interaction = new Interaction(knownContact, InteractionInitiator.Contact, channelId, "");
// Add events - all interactions must have at least one event
var xConnectEvent = new Goal(goal, DateTime.UtcNow);
interaction.Events.Add(xConnectEvent);
}
#region EmailAddress Facet
EmailAddressList emails = new EmailAddressList(new EmailAddress(contactVM.FormEmailAddress, true), EmailAddressList.DefaultFacetKey);
//OR the following code
//var emails = existingContact.GetFacet<EmailAddressList>(EmailAddressList.DefaultFacetKey);
//emails.PreferredEmail = new EmailAddress("*****@*****.**", true);
client.SetFacet <EmailAddressList>(knownContact, EmailAddressList.DefaultFacetKey, emails);
#endregion
IpInfo ipInfo = new IpInfo("127.0.0.1");
ipInfo.BusinessName = "WebSiteSitecore";
client.SetFacet <IpInfo>(interaction, IpInfo.DefaultFacetKey, ipInfo);
// Submit contact and interaction - a total of two operations
if (!isExist)
{
// Add the contact and interaction
client.AddInteraction(interaction);
}
client.Submit();
var operations = client.LastBatch;
contactVM.OperationStatus = "created";
}
catch (XdbExecutionException ex)
{
// Manage exception
conctVMLocal.OperationStatus = "false";
}
catch (Exception ex)
{
conctVMLocal.OperationStatus = "false";
}
return(conctVMLocal);
}
}
public async Task <IActionResult> CreateAsync(
[FromBody] CreateContactViewModel createContactViewModel
)
{
try
{
if (createContactViewModel.IdLibraryBook <= 0)
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.LibraryNotFound }
}
}));
}
// buscar do usuario autenticado
var login = Util.GetClaim(_httpContext,
Constants.UserClaimIdentifier);
var userDbRequest = await _userMananger
.GetByLogin(login);
if (userDbRequest == null)
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.UserNotFound }
}
}));
}
// verificar se existe contado de usuario logado
var contactDbRequest = await _contactMananger
.GetByEmail(userDbRequest.Login);
// criar contato caso não exista
if (contactDbRequest == null)
{
contactDbRequest = new Contact
{
Email = userDbRequest.Login,
Name = userDbRequest.Person.Name,
Phone = userDbRequest.Person.Phones
.SingleOrDefault(x => x.Master == true).Number,
Active = true,
CreatedAt = Util.CurrentDateTime()
};
}
else
{
// verifica se já solicitou contato para o mesmo livro
var contactDb = await _contactMananger
.GetByIdLiraryAndContactRequest(
createContactViewModel.IdLibraryBook,
contactDbRequest.Id);
if (contactDb != null)
{
return(Conflict(new ResponseErrorViewModel
{
Errors = new List <object>
{
new { Message = Constants.ContactConflict }
},
Status = Constants.Error
}));
}
}
contactDbRequest.UpdatedAt = Util.CurrentDateTime();
if (contactDbRequest.Id > 0)
{
_contactMananger.Update(contactDbRequest);
}
else
{
await _contactMananger.CreateAsync(contactDbRequest);
}
// buscar livro da biblioteca
var libraryBook = await _libraryBookMananger
.GetByIdAsync(createContactViewModel.IdLibraryBook);
if (libraryBook == null)
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.BooksNotFound }
}
}));
}
// buscar o login do usuario dono da biblioteca para criar cadastro
var userOwner = await _userMananger
.GetByIdAsyncNoTracking(libraryBook.Library.Person.Id);
// verifica se o livro requisitado não é do mesmo usuario
if (userOwner.Login.Equals(userDbRequest.Login))
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.BookInvalid }
}
}));
}
if (userOwner == null)
{
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object>
{
new { Message = Constants.UserNotFound }
}
}));
}
var contactDbOwner = await _contactMananger
.GetByEmail(userOwner.Login);
if (contactDbOwner == null)
{
contactDbOwner = new Contact
{
Name = userOwner.Person.Name,
Email = userOwner.Login,
Phone = userOwner.Person.Phones
.SingleOrDefault(x => x.Master == true).Number,
ContactBooksOwner = new List <ContactBook>(),
Active = true,
CreatedAt = Util.CurrentDateTime()
};
}
contactDbOwner.UpdatedAt = Util.CurrentDateTime();
var contactBook = new ContactBook
{
ContactOwner = contactDbOwner,
ContactRequest = contactDbRequest,
LibraryBook = libraryBook,
Approved = libraryBook.LibraryBookTypes.Any(x => x.Type.Id == 5),
Denied = false,
CreatedAt = Util.CurrentDateTime()
};
contactDbOwner.ContactBooksOwner.Add(contactBook);
if (contactDbOwner.Id > 0)
{
_contactMananger.Update(contactDbOwner);
}
else
{
await _contactMananger.CreateAsync(contactDbOwner);
}
// gerar notificação
var notification = new Notification
{
Name = "Você tem uma solicitação de contado!",
Description = "Entre em seu perfil e verifique os contatos!",
CreatedAt = Util.CurrentDateTime()
};
await _notificationMananger.CreateAsync(notification);
var personNotification = new NotificationPerson
{
Notification = notification,
Person = libraryBook.Library.Person,
Active = true,
CreatedAt = Util.CurrentDateTime()
};
await _notificationPersonMananger
.CreateAsync(personNotification);
_uow.Commit();
return(Created(
new Uri(Url.ActionLink("Create", "Contact")), new ResponseViewModel
{
Result = null,
Status = Constants.Sucess
}));
}
catch (Exception ex)
{
// gerar log
return(BadRequest(new ResponseErrorViewModel
{
Status = Constants.Error,
Errors = new List <object> {
Util.ReturnException(ex)
}
}));
}
}
