public override void Seed(IDbContext context)
{
var organisation = new OrganisationSettings();
organisation.Names.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "Company name."
});
organisation.Urls.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "https://company.co.uk/"
});
var contact = new PersonContact
{
ContactType = Kernel.Federation.MetaData.Configuration.Organisation.ContactType.Technical,
Forename = new LocalisedName {
Name = "John", Language = CultureInfo.CurrentCulture.Name
},
Surname = new LocalisedName {
Name = "Doe", Language = CultureInfo.CurrentCulture.Name
},
};
contact.Emails.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "*****@*****.**"
});
contact.Phones.Add(new Phone {
Type = PhoneType.Working, Number = "020 123 456"
});
contact.Organisations.Add(organisation);
organisation.Contacts.Add(contact);
Seeder._cache.Add(Seeder.Organisation, organisation);
context.Add <OrganisationSettings>(organisation);
}
public int UpdatePersonContact(PersonContact p)
{
using (UnitOfWork unitOfWork = new UnitOfWork(new PersonContext()))
{
SqlParameter personIdParameter = new SqlParameter("personIdParameter", SqlDbType.Int);
personIdParameter.Value = p.PersonId;
SqlParameter physicalAdressParameter = new SqlParameter("physicalAddressParameter", SqlDbType.VarBinary);
physicalAdressParameter.Value = Encoding.ASCII.GetBytes(p.PhysicalAddress);
SqlParameter mobileNumberParameter = new SqlParameter("mobileNumberParameter", SqlDbType.VarBinary);
mobileNumberParameter.Value = Encoding.ASCII.GetBytes(p.MobileNumber);
SqlParameter alternativeNumberParameter = new SqlParameter("alternativeNumberParameter",
SqlDbType.VarBinary);
alternativeNumberParameter.Value = Encoding.ASCII.GetBytes(p.AlternativeNumber);
SqlParameter emailAddressParameter = new SqlParameter("emailAddressParameter", SqlDbType.VarBinary);
emailAddressParameter.Value = Encoding.ASCII.GetBytes(p.EmailAddress);
SqlParameter id = new SqlParameter("Id", SqlDbType.Int);
id.Value = p.Id;
unitOfWork.PersonContactRepository.ExecuteProcedure(
"exec PersonContact_Update @personIdParameter,@physicalAddressParameter,@mobileNumberParameter,@alternativeNumberParameter,@emailAddressParameter, @Id",
personIdParameter, physicalAdressParameter, mobileNumberParameter, alternativeNumberParameter,
emailAddressParameter, id);
_result = unitOfWork.Complete();
unitOfWork.Dispose();
return(_result);
}
}
public bool AddContact(PersonDto personDto)
{
IContactInformationDataAccess <Person> contactInformationDataAccess
= new ContactInfoDataAccess <Person>();
Person person = new Person();
person.FirstName = personDto.FirstName;
person.LastName = personDto.LastName;
person.PersonContacts = new List <PersonContact>();
foreach (var item in personDto.personContactDtos)
{
PersonContact personContact = new PersonContact();
personContact.ContactTypeId = item.ContactTypeId;
personContact.ContactTypeValue = item.ContactTypeValue;
personContact.PersonId = personDto.Id;
person.PersonContacts.Add(personContact);
}
contactInformationDataAccess.Add(person);
return(true);
}
public async Task <Result <AddUpdatePersonContactResponse> > Handle(AddUpdatePersonContactCommand request, CancellationToken cancellationToken)
{
try
{
RegisterPersonService registerPersonService = new RegisterPersonService(_unitOfWork);
PersonContact personContact = await registerPersonService.GetPersonContactByPersonId(request.PersonId);
if (personContact != null)
{
await registerPersonService.UpdatePersonContact(request.PersonId, request.PhysicalAddress,
request.MobileNumber, request.EmailAddress, request.AlternativeNumber);
}
else
{
personContact = await registerPersonService.addPersonContact(request.PersonId,
request.PhysicalAddress, request.MobileNumber, request.AlternativeNumber, request.EmailAddress,
request.UserId);
}
return(Result <AddUpdatePersonContactResponse> .Valid(new AddUpdatePersonContactResponse()
{
PersonContactId = personContact.Id,
Message = "Person Contact Successful"
}));
}
catch (Exception e)
{
return(Result <AddUpdatePersonContactResponse> .Invalid(e.Message));
}
}
public int AddPersonContact(int personId, string physicalAddress, string mobileNumber, string alternativeNumber, string emailAddress, int userId)
{
//Utility x = new Utility();
//if (alternativeNumber != null)
//{
// alternativeNumber = (alternativeNumber);
//}
//if (emailAddress != null)
//{
// emailAddress = x.Encrypt(emailAddress);
//}
PersonContact personContact = new PersonContact
{
PersonId = personId,
PhysicalAddress = physicalAddress,
MobileNumber = mobileNumber,
AlternativeNumber = alternativeNumber,
EmailAddress = emailAddress,
CreatedBy = userId
};
_result = this._personContact.AddPersonContact(personContact);
return(_result);
}
Contact CreateContact(IModel m, string nameGiven, List <string> nameAdditional, string nameFamily, DateTime birthDate, string emailAddress, string country, string street, string pocode, string city)
{
Uri contactUri = new Uri("semio:" + nameGiven + ":" + Guid.NewGuid().ToString());
PersonContact c = m.CreateResource <PersonContact>(contactUri);
StringBuilder b = new StringBuilder();
foreach (string n in nameAdditional)
{
b.Append(n);
b.Append(" ");
c.NameAdditional.Add(n);
}
if (b.Length > 1)
{
b.Remove(b.Length - 1, 1);
}
c.Fullname = string.Format("{0} {1} {2}", nameGiven, b, nameFamily);
c.NameGiven = nameGiven;
c.NameFamily = nameFamily;
c.BirthDate = birthDate;
c.EmailAddresses.Add(CreateEmailAddress(m, emailAddress));
c.PostalAddresses.Add(CreatePostalAddress(m, country, street, pocode, city));
c.Commit();
return(c);
}
public async Task <IActionResult> ContactEntry(PersonContact personContact)
{
_appDbContext.PersonContacts.Add(personContact);
await _appDbContext.SaveChangesAsync();
return(CreatedAtAction("GetContact", new { id = personContact.ContactId }, personContact));
}
public override void Seed(IDbContext context)
{
var organisation = new OrganisationSettings();
organisation.Names.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "Apira LTD"
});
organisation.Urls.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "https://apira.co.uk/"
});
var contact = new PersonContact
{
ContactType = Kernel.Federation.MetaData.Configuration.Organisation.ContactType.Technical,
Forename = new LocalisedName {
Name = "John", Language = CultureInfo.CurrentCulture.Name
},
Surname = new LocalisedName {
Name = "Murphy", Language = CultureInfo.CurrentCulture.Name
},
};
contact.Emails.Add(new LocalisedName {
Language = CultureInfo.CurrentCulture.Name, Name = "*****@*****.**"
});
contact.Phones.Add(new Phone {
Type = PhoneType.Working, Number = "020 xxx"
});
contact.Organisations.Add(organisation);
organisation.Contacts.Add(contact);
Seeder._cache.Add(Seeder.Organisation, organisation);
context.Add <OrganisationSettings>(organisation);
}
public async Task <IActionResult> PutPersonContact(int id, int personId, PersonContact personContact)
{
if (id != personContact.PersonContactId)
{
return(BadRequest());
}
_context.Entry(personContact).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonContactExists(id, personId))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void ModelNameTest()
{
Uri modelUri = new Uri("http://www.example.com");
Uri modelUri2 = new Uri("http://www.example.com/");
IModel m1 = Store.GetModel(modelUri);
m1.Clear();
IModel m2 = Store.GetModel(modelUri2);
Assert.IsTrue(m1.IsEmpty);
Assert.IsTrue(m2.IsEmpty);
PersonContact c = m1.CreateResource <PersonContact>(new Uri("http://www.example.com/testResource"));
c.NameFamily = "Doe";
c.Commit();
Assert.IsFalse(m1.IsEmpty);
Assert.IsFalse(m2.IsEmpty);
m1.Clear();
Assert.IsTrue(m1.IsEmpty);
Assert.IsTrue(m2.IsEmpty);
}
public async Task <IHttpActionResult> PutPersonContact(int id, PersonContact personContact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != personContact.PersonContactId)
{
return(BadRequest());
}
db.Entry(personContact).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonContactExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(long id, [Bind("ContactID,Title,FirstName,MiddleName,LastName,HomePhone,MobilePhone")] PersonContact personContact)
{
if (id != personContact.ContactID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(personContact);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonContactExists(personContact.ContactID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(personContact));
}
public async Task <Result <AddUpdatePersonContactResponse> > Handle(AddUpdatePersonContactCommand request, CancellationToken cancellationToken)
{
try
{
RegisterPersonService rs = new RegisterPersonService(_unitOfWork);
if (request.PersonId > 0)
{
PersonContact pc = new PersonContact();
pc = await rs.GetPersonContactByPersonId(request.PersonId);
if (pc != null)
{
pc.MobileNumber = request.MobileNumber;
pc.AlternativeNumber = request.AlternativeNumber;
pc.EmailAddress = request.EmailAddress;
pc.PersonId = request.PersonId;
var personcontact = await rs.UpdatePersonContact(pc.PersonId, pc.MobileNumber, pc.AlternativeNumber, pc.Id);
if (personcontact != null)
{
res = personcontact.Id;
msg += "Person Contact Updated Successfully";
}
}
else
{
var personcontact = await rs.addPersonContact(request.PersonId, request.PhysicalAddress, request.MobileNumber, request.AlternativeNumber, request.EmailAddress, request.UserId);
if (personcontact != null)
{
res = personcontact.Id;
msg += "Person Contact Added Successfully";
}
}
}
else
{
var personcontact = await rs.addPersonContact(request.PersonId, request.PhysicalAddress, request.MobileNumber, request.AlternativeNumber, request.EmailAddress, request.UserId);
if (personcontact != null)
{
res = personcontact.Id;
msg += "Person Contact Added Successfully";
}
}
return(Result <AddUpdatePersonContactResponse> .Valid(new AddUpdatePersonContactResponse()
{
PersonContactId = res,
Message = msg
}));
}
catch (Exception e)
{
return(Result <AddUpdatePersonContactResponse> .Invalid(e.Message));
}
}
public async Task <PersonContact> Update(PersonContact personContact)
{
var res = _db.PersonContact.Update(personContact);
await _db.SaveChangesAsync();
return(res.Entity);
}
public async Task <PersonContact> Add(PersonContact personContact)
{
var res = await _db.PersonContact.AddAsync(personContact);
await _db.SaveChangesAsync();
return(res.Entity);
}
public async Task <PersonContact> PostPerson(PersonContact personContact)
{
var res = await _context.PersonContact.AddAsync(personContact);
await _context.SaveChangesAsync();
return(res.Entity);
}
public NewEditContactWindowView(PersonContact contact)
{
InitializeComponent();
var viewModel = new NewEditContactWindowViewModel(contact);
viewModel.CancelChangesCommand.RequestCommand += Close;
viewModel.SaveChangesCommand.RequestCommand += CloseCommandOnRequestCommand;
DataContext = viewModel;
}
public int AddPersonContact(PersonContact personContact)
{
using (var db = new ApartmentManagerContext())
{
var record = db.PersonContact.Add(personContact);
db.SaveChanges();
return(record.Entity.Id);
}
}
public static async Task <bool> DeletePersonContact(PersonContact contact)
{
HttpResponseMessage response = await _client.DeleteAsync($"https://localhost:5001/api/person/{contact.PersonContactId}");
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
public int DeletePersonContact(int id)
{
using (UnitOfWork unitOfWork = new UnitOfWork(new PersonContext()))
{
PersonContact personContact = unitOfWork.PersonContactRepository.GetById(id);
unitOfWork.PersonContactRepository.Remove(personContact);
_result = unitOfWork.Complete();
unitOfWork.Dispose();
return(_result);
}
}
public async Task <IHttpActionResult> GetPersonContact(int id)
{
PersonContact personContact = await db.PersonContacts.FindAsync(id);
if (personContact == null)
{
return(NotFound());
}
return(Ok(personContact));
}
public ActionResult DeleteConfirmed(int id)
{
PersonContact PersonContact = _PersonContactService.Find(id);
_PersonContactService.Delete(id);
_unitOfWork.Save();
return(RedirectToAction("Index", new { Id = PersonContact.PersonId }).Success("Data deleted successfully"));
}
/// <summary>
/// Initialize window for updating a contact
/// </summary>
/// <param name="contact"></param>
public ContactForm(IContact contact)
{
InitializeComponent();
this.contact = contact;
Text = "Update Contact";
PersonContact personContact = (PersonContact)contact;
nameTextBox.Text = personContact.Name;
emailAddressTextBox.Text = personContact.EmailAddress;
}
public async Task <IActionResult> Create([Bind("ContactID,Title,FirstName,MiddleName,LastName,HomePhone,MobilePhone")] PersonContact personContact)
{
if (ModelState.IsValid)
{
_context.Add(personContact);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(personContact));
}
public static async Task <bool> AddPersonContact(PersonContact contact)
{
HttpResponseMessage response = await _client.PostAsJsonAsync("https://localhost:5001/api/personContact", contact);
if (response.IsSuccessStatusCode)
{
return(true);
}
return(false);
}
public HttpResponseMessage GetPersonContact(int id)
{
PersonContact personContact = db.PersonContacts.Find(id);
if (personContact == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Person with id: " + id + " Not Found"));
}
return(Request.CreateResponse <PersonContact>(HttpStatusCode.OK, personContact));
}
public async Task <IHttpActionResult> PostPersonContact(PersonContact personContact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.PersonContacts.Add(personContact);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = personContact.PersonContactId }, personContact));
}
public IHttpActionResult PostPersonContact(PersonContact personContact)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.PersonContacts.Add(personContact);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = personContact.Id }, personContact));
}
public async Task <ActionResult <PersonContact> > DeletePersonContact(PersonContact per)
{
if (per == null)
{
return(NotFound());
}
_context.PersonContact.Remove(per);
await _context.SaveChangesAsync();
return(per);
}
public async Task <IHttpActionResult> DeletePersonContact(int id)
{
PersonContact personContact = await db.PersonContacts.FindAsync(id);
if (personContact == null)
{
return(NotFound());
}
db.PersonContacts.Remove(personContact);
await db.SaveChangesAsync();
return(Ok(personContact));
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
try
{
CommunityAssistEntities cae = new CommunityAssistEntities();
Person p = new Person();
p.FirstName = txtFirstname.Text;
p.LastName = txtLastName.Text;
cae.People.Add(p);
PersonAddress pa = new PersonAddress();
pa.Person = p;
pa.Street = txtAddress.Text;
pa.City = txtCity.Text;
pa.State = txtState.Text;
pa.Zip = txtZipCode.Text;
cae.PersonAddresses.Add(pa);
PersonContact pc = new PersonContact();
pc.Person = p;
pc.ContactInfo = txtEmail.Text;
pc.ContactTypeKey = 6;
cae.PersonContacts.Add(pc);
PersonContact phone = new PersonContact();
phone.Person = p;
phone.ContactInfo = txtHomePhone.Text;
phone.ContactTypeKey = 1;
cae.PersonContacts.Add(phone);
Donation d = new Donation();
d.DonationDate = DateTime.Now;
d.Person = p;
d.DonationAmount = decimal.Parse(txtDonation.Text);
cae.Donations.Add(d);
cae.SaveChanges();
txtError.Text = "Donation Submitted";
}
catch (Exception ex)
{
txtError.Text = ex.Message;
}
}
