public bool create(PersonDetails personDetails, AddressDetails addressDetails)
{
int personID = DaycareAccess.CreatePerson(personDetails.FName, personDetails.LName, personDetails.UserName, "", "", "", 1);
int addressID=DaycareAccess.CreateAddress(addressDetails.Country, addressDetails.State, addressDetails.City, addressDetails.AddressL1, addressDetails.AddressL2, addressDetails.PostalCode, addressDetails.Longitude, addressDetails.Latitude, personID );
return true;
}
public Person Get(PersonDetails request)
{
var person = PersonRepository.GetById(request.Id);
if (person == null)
throw HttpError.NotFound("Person does not exist: " + request.Id);
return person;
}
partial void CopyDetails(PersonDetails details)
{
// force the load of related entities to make sure that updating these to null deletes the relationship in EF
var forceLoadOfRole = this.LatestDetails.Role;
this.LatestDetails.FirstName = details.FirstName;
this.LatestDetails.LastName = details.LastName;
this.LatestDetails.Phone = details.Phone;
this.LatestDetails.Role = details.Role;
this.LatestDetails.Email = details.Email;
this.LatestDetails.Validity =
this.LatestDetails.Validity.ChangeStart(details.Validity.Start).ChangeFinish(details.Validity.Finish);
this.LatestDetails.Person = this;
}
public PersonDetails build()
{
PersonDetails paDetails = new PersonDetails();
paDetails.Description = this.Description;
paDetails.FName = this.FName;
paDetails.Image = this.Image;
paDetails.LName = this.LName;
paDetails.PersonID = this.PersonID;
paDetails.Thumbnail = this.Thumbnail;
paDetails.UserName = this.UserName;
return paDetails;
}
public bool Update(PersonDetails entity)
{
return(_personDetailsDAL.Update(entity) > 0);
}
public bool Delete(int entityID)
{
PersonDetails personDetails = _personDetailsDAL.Get(a => a.PersonID == entityID);
return(_personDetailsDAL.Delete(personDetails) > 0);
}
public bool Add(PersonDetails entity)
{
return(_personDetailsDAL.Add(entity) > 0);
}
public ActionResult SideBar()
{
PersonDetails person = db.PersonDetails.Where(w => w.DeletedDate == null).FirstOrDefault();
return(View(person));
}
protected void bntSave_Click(object sender, EventArgs e)
{
try
{
int persID = 0;
bool valid = false;
bool blnSaveSuccess = false;
String js = String.Empty;
Button but = (Button)sender;
string butID = but.ID;
if (butID.ToUpper().Equals("BTNSAVEBYPASS"))
{
valid = this.checkBypassRequiredfields();
}
else
{
Page.Validate();
valid = Page.IsValid;
}
if (Session["contactid"] != null)
persID = (int)Session["contactid"];
if (valid)
{
PersonDetails persDetails = new PersonDetails();
persDetails.IsActive = Convert.ToString(cbActive.Checked);
persDetails.HasMinimumData = cbContactPersonOnly.Checked;
//persDetails.Introducer = ucContactDetails.ddlRemisierID;
//persDetails.IntroducerEmployee = ucContactDetails.ddlRemisierEmployeeID;
persDetails.LastName = tbLastName.Text;
persDetails.Initials = tbInitials.Text;
persDetails.MiddleName = tbMiddleName.Text;
if (ucBirthDate.SelectedDate != DateTime.MinValue ||
ucBirthDate.SelectedDate.Year > 1800)
persDetails.BirthDate = Convert.ToString(ucBirthDate.SelectedDate);
else
persDetails.BirthDate = string.Empty;
persDetails.Gender = rbGender.SelectedValue;
persDetails.ResidentialState = rbResidentStatus.SelectedValue;
if (ucContactDetails.InternetEnabled.Length > 0)
persDetails.InternetEnabled = ucContactDetails.InternetEnabled;
else
persDetails.InternetEnabled = InternetEnabled.Unknown.ToString();
persDetails.Nationality = ddNationality.SelectedValue;
persDetails.Title = tbTitle.Text;
persDetails.IDType = ddIDType.SelectedValue;
persDetails.IDNumber = tbIdentificationID.Text;
if (ucIdExpirationDate.SelectedDate != DateTime.MinValue ||
ucIdExpirationDate.SelectedDate.Year > 1800)
persDetails.IDExpirationDate = Convert.ToString(ucIdExpirationDate.SelectedDate);
else
persDetails.IDExpirationDate = string.Empty;
persDetails.BurgerServiceNummer = tbBurgerServiceNummer.Text;
persDetails.Email = ucContactDetails.Email;
persDetails.SendNewsItem = ucContactDetails.SendNewsItem;
persDetails.Mobile = ucContactDetails.Mobile;
persDetails.Fax = ucContactDetails.Fax;
persDetails.Telephone = ucContactDetails.Telephone;
persDetails.TelephoneAH = ucContactDetails.TelephoneAH;
persDetails.Street = ucAddress.Street;
persDetails.HouseNumber = ucAddress.HouseNumber;
persDetails.HouseNumberSuffix = ucAddress.HouseNumberSuffix;
persDetails.Postalcode = ucAddress.PostCode;
persDetails.City = ucAddress.City;
persDetails.Country = ucAddress.Country;
if ((!ucAddress.Street.Equals(ucAddress.PAStreet)) ||
(!ucAddress.HouseNumber.Equals(ucAddress.PAHouseNumber)) ||
(!ucAddress.PostCode.Equals(ucAddress.PAPostCode)))
{
persDetails.PostalStreet = ucAddress.PAStreet;
persDetails.PostalHouseNumber = ucAddress.PAHouseNumber;
persDetails.PostalHouseNumberSuffix = ucAddress.PAHouseNumberSuffix;
persDetails.PostalPostalcode = ucAddress.PAPostCode;
persDetails.PostalCity = ucAddress.PACity;
persDetails.PostalCountry = ucAddress.PACountry;
}
else
{
persDetails.PostalStreet = ucAddress.Street;
persDetails.PostalHouseNumber = ucAddress.HouseNumber;
persDetails.PostalHouseNumberSuffix = ucAddress.HouseNumberSuffix;
persDetails.PostalPostalcode = ucAddress.PostCode;
persDetails.PostalCity = ucAddress.City;
persDetails.PostalCountry = ucAddress.Country;
}
PersonEditAdapter.SavePerson(ref persID, ref blnSaveSuccess, persDetails);
Session["contactid"] = persID;
Session["blnSaveSuccess"] = blnSaveSuccess.ToString();
if (CompanyID > 0)
CompanyContactPersonEditAdapter.AddContactPerson(CompanyID, persID);
Response.Redirect("Person.aspx");
}
}
catch (Exception ex)
{
elbErrorMessage.Text = Utility.GetCompleteExceptionMessage(ex) + "<br />";
}
}
public void Run(IBrowser browser, ManualResetEvent pauseEvent, PersonDetails personDetails)
{
browser.EnterTextIntoElement("#Sections_0__Questions_0__Answer", personDetails.StrokeConditionDetails.TransientIschaemicAttackDetails.MonthsSinceFirstDiagnosed.ToString());
browser.ClickElementWithCss("#nextPageButton");
pauseEvent.WaitOne(Timeout.Infinite);
}
public void Run(IBrowser browser, ManualResetEvent pauseEvent, PersonDetails personDetails)
{
browser.EnterTextIntoElement("#Sections_0__Questions_0__Answer", personDetails.HeartConditionDetails.AnginaDetails.MonthsAgoSinceSymptoms.ToString());
browser.ClickElementWithCss("#nextPageButton");
pauseEvent.WaitOne(Timeout.Infinite);
}
public static void Main(string[] args)
{
List <PersonDetails> persons = new List <PersonDetails>();
do
{
Type = _Menu();
PersonDetailsConsole personConsoleObj = new PersonDetailsConsole();
PetConsole petConsoleObj = new PetConsole();
PersonDetails personObj = new PersonDetails();
Pet petObj = new Pet();
switch (Type)
{
case 1:
var getPerson = _Get();
if (getPerson.Item2 != DateTime.MinValue)
{
persons.Add(new PersonDetails(getPerson.Item1, getPerson.Item2));
Console.WriteLine("\nDetails Added\n");
}
else
{
Console.WriteLine("\nInvalid Date\n");
}
break;
case 2:
var getPet = _Get();
string petBreed = _GetPetBreed();
if (getPet.Item2 != DateTime.MinValue)
{
persons.Add(new Pet(getPet.Item1, petBreed, getPet.Item2));
Console.WriteLine("\nDetails Added\n");
}
else
{
Console.WriteLine("\nInvalid Date\n");
}
break;
case 3:
if (persons.Count != 0)
{
List <PersonDetails> sortedList = PersonDetailsConsole.SortPersons(persons);
Console.WriteLine("\nThe sorted list is :\n");
foreach (var item in sortedList)
{
_Output(item);
}
}
else
{
Console.WriteLine("\nlist is empty\n");
}
break;
case 4:
var lists = _DivideList(persons);
if (lists.Item1.Count != 0)
{
personConsoleObj.Serializer(lists.Item1);
}
if (lists.Item2.Count != 0)
{
petConsoleObj.Serializer(lists.Item2);
}
Console.WriteLine("\nWritten to File\n");
break;
case 5:
if (File.Exists(@"D:/PersonDetails.json"))
{
if (new FileInfo(@"D:/PersonDetails.json").Length != 0)
{
personConsoleObj.Deserializer();
}
else
{
Console.WriteLine("File is Empty");
}
}
if (File.Exists(@"D:/Pets.xml"))
{
if (new FileInfo(@"D:/Pets.xml").Length != 0)
{
petConsoleObj.Deserializer();
}
else
{
Console.WriteLine("File is Empty");
}
}
break;
case 6:
var lists1 = _DivideList(persons);
if (lists1.Item1.Count != 0)
{
personObj.Write(lists1.Item1);
}
if (lists1.Item2.Count != 0)
{
petObj.Write(lists1.Item2);
}
Console.WriteLine("\nDatabase Updated\n");
break;
case 7:
personObj.Read();
petObj.Read();
break;
default: Console.WriteLine("Invalid Entry"); break;
}
Console.WriteLine("Do you wish to continue(y/n)?");
} while (Console.ReadLine() == "y");
Console.WriteLine("\nPress any key to exit");
Console.ReadLine();
}
public static CurrentPersonViewData Create(PersonDetails person, District district, School school, SchoolYear schoolYear, IList <ClaimInfo> claims)
{
return(new CurrentPersonViewData(person, district, school, schoolYear, claims));
}
public ActionResult addInfos(PersonDetails postPerson, HttpPostedFileBase mediaUrl, string fileName)
{
if (mediaUrl != null)
{
bool valid = true;
if (!mediaUrl.CheckImageType())
{
ModelState.AddModelError("mediaUrl", "Şəkil uyğun deyil!");
valid = false;
}
if (!mediaUrl.CheckImageSize(5))
{
ModelState.AddModelError("mediaUrl", "Şəklin ölçüsü uyğun deyil!");
valid = false;
}
if (valid)
{
string newPath = mediaUrl.SaveImage(Server.MapPath("~/Template/media"));
//System.IO.File.Move(Server.MapPath(System.IO.Path.Combine("~/Template/media", entity.MediaUrl)),
// Server.MapPath(System.IO.Path.Combine("~/Template/media", entity.MediaUrl)));
postPerson.MediaUrl = newPath;
}
}
else if (string.IsNullOrWhiteSpace(postPerson.MediaUrl))
{
postPerson.MediaUrl = null;
}
var personExists = db.PersonDetails.Any();
var person = db.PersonDetails.FirstOrDefault();
if (personExists)
{
if (ModelState.IsValid)
{
person.Age = postPerson.Age;
person.CareerLevel = postPerson.CareerLevel;
person.Degree = postPerson.Degree;
person.Email = postPerson.Email;
person.Experience = postPerson.Experience;
person.Fax = postPerson.Fax;
person.Location = postPerson.Location;
person.MediaUrl = postPerson.MediaUrl;
person.Name = postPerson.Name;
person.Phone = postPerson.Phone;
person.Website = postPerson.Website;
person.ModifiedDate = DateTime.UtcNow;
person.MediaUrl = postPerson.MediaUrl;
db.SaveChanges();
return(PartialView("EditCV"));
}
}
if (ModelState.IsValid)
{
postPerson.MediaUrl = mediaUrl.SaveImage(Server.MapPath("~/Template/media"));
postPerson.CreationDate = DateTime.UtcNow;
db.PersonDetails.Add(postPerson);
db.SaveChanges();
}
return(View("EditCV"));
}
private void AddResultButtons(PersonDetails personDetails)
{
var resultRibbon = new ADXRibbonItem(this.components)
{
Caption = personDetails.FirstName+ " " +personDetails.MiddleName +" "+personDetails.LastName,
Id = personDetails.DigipostAddress,
ImageTransparentColor = Color.Red,
ScreenTip = personDetails.MobileNumber+ "\r\n"+personDetails.DigipostAddress
};
this.adxDDLSearchResult.Items.Add(resultRibbon);
adxPersonGroup.Visible = true;
}
public bool Create(PersonDetails personDetails)
{
_peopleDetails.InsertOne(personDetails);
return(true);
}
private static void WithTests()
{
QUnit.Module("WithTests");
QUnit.Test("Simple string property update using With directly", assert =>
{
var x = new SomethingWithStringId("abc");
x = x.With(_ => _.Id, "def");
assert.Equal(x.Id, "def");
});
QUnit.Test("With does not affect original instance", assert =>
{
var x0 = new SomethingWithStringId("abc");
var x1 = x0.With(_ => _.Id, "def");
assert.Equal(x0.Id, "abc");
assert.Equal(x1.Id, "def");
});
QUnit.Test("Simple string property update of property on a base class using With directly", assert =>
{
// This test is just to ensure that there's no monkey business involved when targeting properties on a base class (as there are
// with interface properties - see above)
var x = new SecurityPersonDetails(1, "test", 10);
x = x.With(_ => _.Name, "test2");
assert.Equal(x.Name, "test2");
});
QUnit.Test("Simple string property update using With indirectly", assert =>
{
var x = new SomethingWithStringId("abc");
var idUpdater = x.With(_ => _.Id);
x = idUpdater("def");
assert.Equal(x.Id, "def");
});
QUnit.Test("Simple string property update using GetProperty and With", assert =>
{
var x = new SomethingWithStringId("abc");
var propertyToUpdate = x.GetProperty(_ => _.Id);
x = x.With(propertyToUpdate, "def");
assert.Equal(x.Id, "def");
});
QUnit.Test("Single-element NonNullList<string> property update using With directly", assert =>
{
var x = new SomethingWithNonNullListStringValues(NonNullList.Of("abc", "def"));
x = x.With(_ => _.Values, 1, "xyz");
assert.Equal(x.Values[1], "xyz");
});
QUnit.Test("Single-element NonNullList<string> property update using GetProperty and With", assert =>
{
var x = new SomethingWithNonNullListStringValues(NonNullList.Of("abc", "def"));
var propertyToUpdate = x.GetProperty(_ => _.Values);
x = x.With <SomethingWithNonNullListStringValues, string>(propertyToUpdate, 1, "xyz");
assert.Equal(x.Values[1], "xyz");
});
QUnit.Test("Single-element Set<string> (legacy compatibility alias for NonNullList) property update using GetProperty and With", assert =>
{
#pragma warning disable CS0618 // Ignore the fact that Set is obsolete
var x = new SomethingWithNonNullListStringValues(Set.Of("abc", "def"));
#pragma warning restore CS0618
var propertyToUpdate = x.GetProperty(_ => _.Values);
x = x.With <SomethingWithNonNullListStringValues, string>(propertyToUpdate, 1, "xyz");
assert.Equal(x.Values[1], "xyz");
});
QUnit.Test("The Validate method (if there is one defined with zero parameters) should be called after With", assert =>
{
var x = new SomethingWithNonZeroKey(123);
assert.Throws(
() => x.With(_ => _.Key, (uint)0),
"The Validate method should be called after With"
);
});
// When first changing the Clone behaviour within ImmutabilityHelpers to work with Bridge 16 (which changes how properties are defined on objects), there was a
// bug introduced where the updating properties on the clone would update the values on the original value too! These tests confirm that that bug is no more.
QUnit.Test("Simple string property update against an interface using With directly", assert =>
{
// Inspired by issue https://github.com/ProductiveRage/Bridge.Immutable/issues/4
IAmImmutableAndHaveName viaInterfacePerson = new PersonDetails(1, "test");
viaInterfacePerson = viaInterfacePerson.With(_ => _.Name, "test2");
assert.Equal(viaInterfacePerson.Name, "test2");
});
QUnit.Test("Double-check must-not-affect-original-instance when targeting property on base class", assert =>
{
var x0 = new SecurityPersonDetails(1, "test", 10);
var x1 = x0.With(_ => _.Name, "test2");
assert.Equal(x0.Name, "test");
assert.Equal(x1.Name, "test2");
});
}
public static PersonDetails[] GetAPersonWUserName(string UserName)
{
DbCommand comm = GenericDataAccess.CreateCommand();
comm.CommandText = "GetAPersonWUserName";
DbParameter param = comm.CreateParameter();
param.ParameterName = "@UserName";
param.DbType = DbType.String;
param.Value = UserName;
comm.Parameters.Add(param);
DataTable personTable = GenericDataAccess.ExecuteSelectCommand(comm);
PersonDetails[] personStructs = new PersonDetails[personTable.Rows.Count];
for (int row = 0; row < personTable.Rows.Count; row++)
{
DataRow dataRow = personTable.Rows[row];
personStructs[row].PersonID = Int32.Parse(dataRow["PersonID"].ToString());
personStructs[row].FName = dataRow["FName"].ToString();
personStructs[row].LName = dataRow["LName"].ToString();
personStructs[row].UserName = dataRow["UserName"].ToString();
personStructs[row].Image = dataRow["Image"].ToString();
personStructs[row].Thumbnail = dataRow["Thumbnail"].ToString();
personStructs[row].Description = dataRow["Description"].ToString();
}
return personStructs;
}
public void ValidDetailsSaved()
{
var validatorFactory = new Mock <IValidatorEngine>();
var mappingEngine = new Mock <IMappingEngine>();
var repository = new Mock <IRepository>();
var searchCache = new Mock <ISearchCache>();
// Contract
var cd = new EnergyTrading.MDM.Contracts.Sample.PersonDetails {
Forename = "John", Surname = "Smith", Email = "*****@*****.**"
};
var nexus = new EnergyTrading.Mdm.Contracts.SystemData {
StartDate = new DateTime(2012, 1, 1)
};
var identifier = new EnergyTrading.Mdm.Contracts.MdmId {
SystemName = "Test", Identifier = "A"
};
var contract = new EnergyTrading.MDM.Contracts.Sample.Person {
Details = cd, MdmSystemData = nexus
};
contract.Identifiers.Add(identifier);
// Domain
var system = new SourceSystem {
Name = "Test"
};
var mapping = new PersonMapping {
System = system, MappingValue = "A"
};
var d1 = new PersonDetails {
Id = 1, FirstName = "Bill", LastName = "Jones", Email = "*****@*****.**", Timestamp = 74UL.GetVersionByteArray()
};
var entity = new Person();
entity.AddDetails(d1);
var d2 = new PersonDetails {
FirstName = "John", LastName = "Smith", Email = "*****@*****.**"
};
var range = new DateRange(new DateTime(2012, 1, 1), DateTime.MaxValue);
validatorFactory.Setup(x => x.IsValid(It.IsAny <CreateMappingRequest>(), It.IsAny <IList <IRule> >())).Returns(true);
validatorFactory.Setup(x => x.IsValid(It.IsAny <EnergyTrading.MDM.Contracts.Sample.Person>(), It.IsAny <IList <IRule> >())).Returns(true);
repository.Setup(x => x.FindOne <Person>(1)).Returns(entity);
mappingEngine.Setup(x => x.Map <EnergyTrading.MDM.Contracts.Sample.PersonDetails, PersonDetails>(cd)).Returns(d2);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.SystemData, DateRange>(nexus)).Returns(range);
mappingEngine.Setup(x => x.Map <EnergyTrading.Mdm.Contracts.MdmId, PersonMapping>(identifier)).Returns(mapping);
var service = new PersonService(validatorFactory.Object, mappingEngine.Object, repository.Object, searchCache.Object);
// Act
service.Update(1, 74, contract);
// Assert
Assert.AreEqual(2, entity.Details.Count, "Details count differs");
Assert.AreEqual(1, entity.Mappings.Count, "Mapping count differs");
repository.Verify(x => x.Save(entity));
repository.Verify(x => x.Flush());
}
