public async Task SaveDefaultBeneficiaryAsync(ContactDetailViewModel model)
{
if (model.UserID == null)
{
model.UserID = _MasterRepo.DataSource.User.UserID;
var mo = await _DynamixReturnService.AddBeneficiaryAsync(model);
model.UserID = mo.body.benefactorUserId;
}
else
{
await _DynamixService.UpdateContactAsync(model);
}
}
public async Task SaveTrustedSourceAsync(ContactDetailViewModel model)
{
if (model.UserID == null)
{
model.TokenID = _MasterRepo.DataSource.User.TokenID;
model.UserID = _MasterRepo.DataSource.User.UserID;
var mo = await _DynamixReturnService.AddTrustedSourceAsync(model);
model.UserID = mo.body.trusteeUserId;
}
else
{
await _DynamixService.UpdateContactAsync(model);
}
}
private ContactDetailViewModel getContactInformation(Account reference)
{
if (reference != null)
{
ContactDetailViewModel contact = new ContactDetailViewModel();
contact.Email = reference.EmailAddress;
contact.City = reference.City;
contact.ContactName = reference.ContactName;
contact.Country = reference.Country;
contact.Phone = reference.Phone;
contact.State = reference.State;
return(contact);
}
return(null);
}
public async Task UpdateMasterWithBeneficiaryAsync(ContactDetailViewModel model)
{
ContactModel contactModel = _MasterRepo.DataSource.DefaultBeneficiary;
if (contactModel == null)
{
contactModel = new ContactModel();
}
contactModel.UserPicture = model.ContactPicture.Selfie;
contactModel.FirstName = model.FirstName;
contactModel.LastName = model.LastName;
contactModel.CellNumber = model.CellNumber;
contactModel.Email = model.Email;
await _MasterRepo.SaveBeneficiaryAsync(contactModel);
}
public ContactDetailPage()
{
InitializeComponent();
var contact = new Contact
{
FirstName = "",
LastName = "",
MobileNo = "",
EmailAddress = "",
Address = ""
};
viewModel = new ContactDetailViewModel(contact);
BindingContext = viewModel;
}
public void DeleteContactDetail()
{
using (FakeEmployeeContext ctx = BuildContextWithData())
{
EmployeeViewModel vm = BuildViewModel(ctx);
List <ContactDetailViewModel> originalDetails = vm.ContactDetails.ToList();
ContactDetailViewModel toDelete = vm.ContactDetails.First();
vm.CurrentContactDetail = toDelete;
vm.DeleteContactDetailCommand.Execute(null);
Assert.IsNull(vm.CurrentContactDetail, "No detail should be selected after deleting.");
Assert.IsFalse(vm.ContactDetails.Contains(toDelete), "Detail should be removed from ContactDetails property.");
Assert.IsFalse(ctx.IsObjectTracked(toDelete), "Detail should be deleted from context.");
}
}
public IActionResult Detail(int id)
{
var contactFromDb = _contactDatabase.GetContact(id);
var contact = new ContactDetailViewModel()
{
FirstName = contactFromDb.FirstName,
LastName = contactFromDb.LastName,
PhoneNumber = contactFromDb.PhoneNumber,
Address = contactFromDb.Address,
Email = contactFromDb.Email,
Description = contactFromDb.Description,
BirthDate = contactFromDb.BirthDate,
ContactType = contactFromDb.ContactType,
PhotoUrl = contactFromDb.PhotoUrl,
};
return(View(contact));
}
public void ContactTest()
{
//Arrange
var contactDetailViewModel = new ContactDetailViewModel();
//Act
contactDetailViewModel.Contact = new ContactModel
{
FirstName = TestConstants.TestFirstName,
LastName = TestConstants.TestLastName,
PhoneNumber = TestConstants.TestPhoneNumber
};
//Assert
Assert.AreEqual(TestConstants.TestFirstName, contactDetailViewModel.FirstNameText);
Assert.AreEqual(TestConstants.TestLastName, contactDetailViewModel.LastNameText);
Assert.AreEqual(TestConstants.TestPhoneNumber, contactDetailViewModel.PhoneNumberText);
}
public async Task <T> AddTrustedSourceAsync(ContactDetailViewModel model)
{
string requestURL = "/dyn365/api/v1.0/User/addsource";
var httpMethod = BaseNetworkAccessEnum.Put;
var parameters = new Dictionary <string, ParameterTypedValue>()
{
{ "Ocp-Apim-Subscription-Key", new ParameterTypedValue(Constants.APIM_GUID, ParameterTypeEnum.HeaderParameter) },
{ "Authorization", new ParameterTypedValue(model.TokenID, ParameterTypeEnum.HeaderParameter) },
{ "body", new ParameterTypedValue(new
{
trusteeUserId = model.UserID,
trustedSourceFirstName = model.FirstName,
trustedSourceLastName = model.LastName,
trustedSourceMobileNumber = model.CellNumber,
}, ParameterTypeEnum.BodyParameter) }
};
return(await _NetworkInterfaceWithOutput(requestURL, parameters, httpMethod));
}
public async Task AddBeneficiaryAsync(ContactDetailViewModel model)
{
string requestURL = "/dyn365/api/v1.0/User/addbeneficiary";
var httpMethod = BaseNetworkAccessEnum.Put;
var parameters = new Dictionary <string, ParameterTypedValue>()
{
{ "Ocp-Apim-Subscription-Key", new ParameterTypedValue(Constants.APIM_GUID, ParameterTypeEnum.HeaderParameter) },
{ "Authorization", new ParameterTypedValue(model.TokenID, ParameterTypeEnum.HeaderParameter) },
{ "body", new ParameterTypedValue(new
{
benefactorUserId = model.UserID,
beneficiaryFirstName = model.FirstName,
beneficiaryLastName = model.LastName,
beneficiaryMobileNumber = model.CellNumber,
}, ParameterTypeEnum.BodyParameter) }
};
await _NetworkInterface(requestURL, parameters, httpMethod);
}
public IActionResult Detail(int id)
{
Contact contactFromDb = _contactDabase.GetContact(id);
ContactDetailViewModel contact = new ContactDetailViewModel()
{
Id = id,
Voornaam = contactFromDb.Voornaam,
Naam = contactFromDb.Naam,
Geslacht = contactFromDb.Geslacht,
Geboortedatum = contactFromDb.Geboortedatum,
TelefoonNr = contactFromDb.TelefoonNr,
Email = contactFromDb.Email,
Beschrijving = contactFromDb.Beschrijving,
Adres = contactFromDb.Adres,
Avatar = contactFromDb.Avatar
};
return(View(contact));
}
public HttpResponseMessage Create(HttpRequestMessage request, ContactDetailViewModel contactDetailViewModel)
{
return(CreateHttpResponse(request, ()
=>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var contactDettail = Mapper.Map <ContactDetailViewModel, ContactDetail>(contactDetailViewModel);
_contactDetailService.AddContactDetail(contactDettail);
_contactDetailService.Save();
response = request.CreateResponse(HttpStatusCode.Created, contactDetailViewModel);
}
return response;
}));
}
public async Task <JsonResult> SendUpVerificationCode(ContactDetailViewModel model)
{
//Check if any user exist that already used the phone number.
var signUpUser = await _userManager.FindByPhoneNumberAsync(model.PhoneNumber);
//Check if user supplied email address, if yes, check if a user exist that already used the email.
if (!string.IsNullOrEmpty(model.Email))
{
signUpUser = await _userManager.FindByEmailAsync(model.Email);
}
//If user exists with either phone number or email end verification sending.
if (signUpUser != null)
{
throw new UserFriendlyException(L("UserAlreadyExist"));
}
await _verificationCodeService.GenerateAndSendVerificationCode(model.PhoneNumber);
return(Json(new { }));
}
public void BuildViewModel()
{
Phone p = new Phone();
Email e = new Email();
Address a = new Address();
var pvm = ContactDetailViewModel.BuildViewModel(p);
Assert.IsInstanceOfType(pvm, typeof(PhoneViewModel), "Factory method created wrong ViewModel type.");
Assert.AreEqual(p, pvm.Model, "Underlying model object on ViewModel is not correct.");
var evm = ContactDetailViewModel.BuildViewModel(e);
Assert.IsInstanceOfType(evm, typeof(EmailViewModel), "Factory method created wrong ViewModel type.");
Assert.AreEqual(e, evm.Model, "Underlying model object on ViewModel is not correct.");
var avm = ContactDetailViewModel.BuildViewModel(a);
Assert.IsInstanceOfType(avm, typeof(AddressViewModel), "Factory method created wrong ViewModel type.");
Assert.AreEqual(a, avm.Model, "Underlying model object on ViewModel is not correct.");
}
public static void UpdateContactDetail(this ContactDetail contactDetail, ContactDetailViewModel contactDetailViewModel)
{
contactDetail.ID = contactDetailViewModel.ID;
contactDetail.Name = contactDetailViewModel.Name;
contactDetail.Email = contactDetailViewModel.Email;
contactDetail.Phone = contactDetailViewModel.Phone;
contactDetail.Website = contactDetailViewModel.Website;
contactDetail.Other = contactDetailViewModel.Other;
contactDetail.Lat = contactDetailViewModel.Lat;
contactDetail.Lng = contactDetailViewModel.Lng;
contactDetail.Address = contactDetailViewModel.Address;
contactDetail.CreatedDate = contactDetailViewModel.CreatedDate;
contactDetail.CreatedBy = contactDetailViewModel.CreatedBy;
contactDetail.UpdatedDate = contactDetailViewModel.UpdatedDate;
contactDetail.UpdatedBy = contactDetailViewModel.UpdatedBy;
contactDetail.MetaKeyword = contactDetailViewModel.MetaKeyword;
contactDetail.MetaDescription = contactDetailViewModel.MetaDescription;
contactDetail.Status = contactDetailViewModel.Status;
}
public async Task UpdateContactAsync(ContactDetailViewModel model)
{
string requestURL = "/dyn365/api/v1.0/User/update";
var httpMethod = BaseNetworkAccessEnum.Patch;
var parameters = new Dictionary <string, ParameterTypedValue>()
{
{ "Ocp-Apim-Subscription-Key", new ParameterTypedValue(Constants.APIM_GUID, ParameterTypeEnum.HeaderParameter) },
{ "Authorization", new ParameterTypedValue(model.TokenID, ParameterTypeEnum.HeaderParameter) },
{ "body", new ParameterTypedValue(new
{
userId = model.UserID,
eMail = "",
firstName = model.FirstName,
lastName = model.LastName,
idNumber = model.IDNumber,
mobileNumber = model.CellNumber,
profileImageUrl = ""
}, ParameterTypeEnum.BodyParameter) }
};
await _NetworkInterface(requestURL, parameters, httpMethod);
}
public ContactDetailViewModel getContactDetailViewModel(int id)
{
var contact = _repo.Query <Contact>().Where(c => c.Id == id).FirstOrDefault();
var deals = _repo.Query <DealContact>().Where(d => d.ContactId == id).Select(d => d.Deal).ToList();
var tasks = _repo.Query <TaskContact>().Where(t => t.ContactId == id).Select(t => t.UserTask).ToList();
var company = _repo.Query <Company>().Where(co => co.Id == contact.CompanyId).FirstOrDefault();
var interactions = _repo.Query <ContactInteraction>().Where(i => i.ContactId == id).ToList();
//var location = _repo.Query<Location>().Where(l => l.ContactId == id).FirstOrDefault();
var companies = _repo.Query <Company>().ToList();
var contactDetailViewModel = new ContactDetailViewModel
{
Company = company,
Contact = contact,
Deals = deals,
Companies = companies,
Interactions = interactions,
Tasks = tasks,
};
return(contactDetailViewModel);
}
public HttpResponseMessage Create(HttpRequestMessage request, ContactDetailViewModel contactDetailVm)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = null;
if (!ModelState.IsValid)
{
response = request.CreateResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var newContactDetail = new ContactDetail();
newContactDetail.UpdateContactDetail(contactDetailVm);
_contactDetailService.Add(newContactDetail);
_contactDetailService.Save();
var responseData = Mapper.Map <ContactDetail, ContactDetailViewModel>(newContactDetail);
response = request.CreateResponse(HttpStatusCode.Created, responseData);
}
return response;
}));
}
public ActionResult Edit(ContactDetailViewModel model)
{
try
{
if (ModelState.IsValid)
{
var contact = new ContactDetail();
contact.UpdateContactDetail(model);
var result = new ContactDao().Update(contact);
if (result)
{
SetAlert("Cập nhật thành công", "success");
return(RedirectToAction("Index", "Contact"));
}
else
{
ModelState.AddModelError("", "Cập nhật thất bại");
}
}
return(View(model));
}
catch
{ return(View()); }
}
public async Task UpdateMasterWithTrustedSourceAsync(ContactDetailViewModel model)
{
ContactModel contactModel;
if (_MasterRepo.DataSource.TrustedSources.Count > _MasterRepo.DataSource.TrustedSourceEditIndex)
{
contactModel = _MasterRepo.DataSource.TrustedSources[_MasterRepo.DataSource.TrustedSourceEditIndex];
}
else
{
contactModel = new ContactModel();
_MasterRepo.DataSource.TrustedSources.Add(contactModel);
}
contactModel.UserPicture = model.ContactPicture.Selfie;
contactModel.FirstName = model.FirstName;
contactModel.LastName = model.LastName;
contactModel.CellNumber = model.CellNumber;
contactModel.IDNumber = model.IDNumber;
contactModel.Email = model.Email;
contactModel.UserPicture = model.ContactPicture.Selfie;
await _MasterRepo.SaveTrustedSourceAsync(contactModel, _MasterRepo.DataSource.TrustedSourceEditIndex);
_MasterRepo.DataSource.TrustedSourceEditIndex = -1;
}
public async Task SaveUserAsync(ContactDetailViewModel model)
{
await _DynamixService.UpdateContactAsync(model);
}
public void Update(ContactDetailViewModel pageVm)
{
var page = Mapper.Map <ContactDetailViewModel, ContactDetail>(pageVm);
_pageRepository.Update(page);
}
public EditContactPage(ContactDetailViewModel viewModel)
{
InitializeComponent();
BindingContext = this.viewModel = viewModel;
}
public ContactDetailPage(Contact contact)
{
InitializeComponent();
BindingContext = new ContactDetailViewModel(contact);
}
public ContactDetailPage(ContactDetailViewModel viewModel)
{
InitializeComponent();
BindingContext = viewModel;
}
public ContactDetailView(ContactDetailViewModel viewModel)
{
BindingContext = viewModel;
InitializeComponent();
}
public ContactDetail(ContactResponseModel contactDetails)
{
InitializeComponent();
BindingContext = new ContactDetailViewModel(contactDetails);
}
public ContactDetailView(ContactDetailViewModel vm)
{
InitializeComponent();
BindingContext = vm;
}
public void Load(ContactDetailViewModel model)
{
model = _Reposetory.GetTrustedContactDetailFromMaster();
}
public ActionResult Index()
{
ContactDetailViewModel contactDetailViewModel = GetContactDetail();
return(View(contactDetailViewModel));
}