public ActionResult Index(string PersonID)
{
int personID = 0;
Int32.TryParse(PersonID, out personID);
Session["ID"] = personID;
if (personID != 0)
{
PersonsModel persons = personsModel.GetPersonalDetails(personID);
if (persons == null)
{
ModelState.AddModelError("PersonID", "We Did't Find Your ID Please Regiter First And Try Again");
return(View("Index"));
}
else
{
return(RedirectToAction("PersonsDetails", persons));
}
}
else
{
ModelState.AddModelError("PersonID", "Please Enter a Valid ID");
return(View("Index"));
}
}
public static int UpdatePerson(long PersonId, PersonsModel person)
=> Update(PersonsTable.TableName, new ParamtersMap
{
[PersonsTable.PeName] = person.PeName,
[PersonsTable.PeAddress] = person.PeAddress,
[PersonsTable.PeIdentity] = person.PeIdentity,
[PersonsTable.PeType] = person.PeType
}, $"{PersonsTable.PeId}={PersonId}");
public ResponseModel <List <PersonsModel> > CreatePerson(PersonsModel model)
{
if (_repo.DoesIdNumberExist(model.IdNumber))
{
return(FailResponse(2, "ID Number exists"));
}
return(_repo.CreatePerson(model));
}
private void BtnSave_Click(object sender, EventArgs e)
{
PersonsModel model = new PersonsModel();
model.FirstName = FirstName.Text;
model.LastName = LastName.Text;
/*model.TypeId = TypeId.*/
Conn.AddEmployee(model);
loadPersons();
}
public void EditPerson(PersonsModel req)
{
var result = _ctx.Persons.Where(x => x.PersonID == req.PersonID).FirstOrDefault();
result.Address = req.Address;
result.City = req.City;
result.FirstName = req.FirstName;
result.LastName = req.LastName;
_ctx.SaveChanges();
}
public async Task <PersonsModel> EditPersonAsync(int personId, PersonsModel person)
{
var oldmodel = await _context.Persons
.FirstOrDefaultAsync(e => e.PersonId == personId);
var result = Mapping.Mapper.Map(person, oldmodel);
await _context.SaveChangesAsync();
var personModel = await GetPersonModel(personId);
return(Mapping.Mapper.Map <PersonsModel>(personModel));
}
private void PresentPerson(PersonsModel person)
{
var adress = person.PeAddress.Split(new String[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
FullName = person.PeName;
PersonalId = person.PeIdentity;
if (adress != null && adress.Length == 2)
{
City = adress[0];
Adress = adress[1];
}
}
public static int InsertPerson(out long insertId, PersonsModel person)
{
var changedCount = Insert(out insertId, PersonsTable.TableName, new ParamtersMap
{
[PersonsTable.PeName] = person.PeName,
[PersonsTable.PeAddress] = person.PeAddress,
[PersonsTable.PeIdentity] = person.PeIdentity,
[PersonsTable.PeType] = person.PeType
});
return(changedCount);
}
public void UpdatePerson(PersonsModel person)
{
try
{
//Update the person
_PersonRepository.EditPersonsModel(person);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public JsonResult SavePerson(PersonsModel person)
{
try
{
//Save person method
_PersonRepository.SavePerson(person);
return(Json(person, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
void PresentPerson(PersonsModel person)
{
var adress = person.PeAddress.Split(new String[] { "-" }, StringSplitOptions.RemoveEmptyEntries);
SelectedPersonType = PersonTypeSource.Where(x => x.CId == person.PeType).FirstOrDefault();
FullName = person.PeName;
PersonalId = person.PeIdentity;
if (adress != null && adress.Length == 2)
{
City = adress[0];
Adress = adress[1];
}
}
public VMPersonEdit(PersonsModel person, List <CodesModel> PersonTypes, List <CodesModel> CommTypes, List <PersonsCommunicationModel> PersonCommunications)
{
//SystemValues.CommTypes = CommTypes;
PersonTypeSource.ReFill(PersonTypes);
EditedPerson = person;
PresentPerson(person);
CommunicationCodeSource.ReFill(CommTypes);
foreach (var item in PersonCommunications)
{
CommunicationSource.Add((item, CommTypes));
}
//CommunicationSource.ReFill(PersonCommunications);
}
public void AddPerson(PersonsModel req)
{
PersonsModel newReq = new PersonsModel()
{
PersonID = req.PersonID,
Address = req.Address,
City = req.City,
FirstName = req.FirstName,
LastName = req.LastName
};
_ctx.Persons.Add(newReq);
_ctx.SaveChanges();
}
public async Task <IActionResult> CreatePersonAsync(PersonsModel person)
{
if (_personService.CheckIfNewPersonExit(person))
{
var model = await _personService.CreatePersonAsync(person);
var location = _linkGanarator.GetPathByAction("GetPersonByIdAsync", "Persons", new { personId = model.PersonId });
return(Created(location, model));
}
else
{
return(BadRequest("person has already been added"));
}
}
public ResponseModel <List <T> > CreatePerson(PersonsModel model)
{
try
{
var personEntity = _mapper.Map <PersonsModel, PersonsEntity>(model);
_context.Person.Add(personEntity);
_context.SaveChanges();
return(SuccessResponse(0, "Saved successfully", ""));
}
catch (Exception ex)
{
return(FailResponse(1, "Error updating record", ex.GetBaseException().ToString()));
}
}
public JsonResult GetPersonByID(int id)
{
try
{
//New instance of person
var pm = new PersonsModel();
//Load the data into the instance of the person
pm = _PersonRepository.GetPersonByID(id);
return(Json(pm, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
//
// GET: /Person/
public ActionResult Index()
{
//var context = new SchoolContext();
//var personsDbSet = context.Set<Person>();
//List<Person> persons = personsDbSet.ToList();
List <Person> persons = repo.Get().ToList();
var model = new PersonsModel
{
Persons = persons.Select(p => new PersonModel
{
Name = p.FirstName + ((!string.IsNullOrWhiteSpace(p.Prefix)) ? " " + p.Prefix : string.Empty) + " " + p.LastName
}).ToList()
};
return(View(model));
}
public void Edit(Window window)
{
IsInProgress = true;
new Thread(() =>
{
var peId = EditedPerson.PeId;
EditedPerson = new PersonsModel()
{
PeId = peId,
PeName = FullName,
PeIdentity = PersonalId,
PeType = (int)SelectedPersonType.CId,
PeAddress = ""
};
var personValueChange = DataAccess.UpdatePerson(EditedPerson.PeId, EditedPerson);
if (personValueChange == 1)
{
var commChangeValue = DataAccess.DeletePersonCommunication(peId);
foreach (var item in CommunicationSource)
{
item.CoPeIdFk = peId;
var commValueChange = DataAccess.InsertPersonCommunication(out var id, item);
AddedCommunication.Add(item);
}
var addressChangeValue = DataAccess.DeletePersonAddress(peId);
var address = new PersonsAddressModel()
{
PeAdCity = City,
PeAdStreetName = Adress,
PeAdPerIdFk = EditedPerson.PeId
};
DataAccess.InsertPersonAddress(out var adressId, address);
AddedAddress.Add(address);
}
IsInProgress = false;
App.Current.Dispatcher.Invoke((Action) delegate
{
window.DialogResult = true;
window.Close();
});
})
{
IsBackground = true
}.Start();
public async Task <IActionResult> Create(PersonsModel model)
{
if (model == null)
{
return(RedirectToAction("Index"));
}
try
{
using (IDbConnection conn = new SqlConnection(_conString))
{
await conn.ExecuteAsync("INSERT INTO Person(FirstName,LastName,MiddleName) VALUES(@FirstName,@LastName,@MiddleName) ", model);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(RedirectToAction("Index"));
}
public void Add(Window window)
{
IsInProgress = true;
new Thread(() =>
{
AddedPerson = new PersonsModel()
{
PeName = FullName,
PeIdentity = PersonalId,
PeType = (int)SelectedPersonType.CId,
PeAddress = ""
//PhoneNo = PhoneNo,
//MobileNo = MobileNo,
//Email = EmailAdress,
//Address = ""
};
var personValueChange = DataAccess.InsertPerson(out var personId, AddedPerson);
AddedPerson.PeId = personId;
foreach (var item in CommunicationSource)
{
item.CoPeIdFk = personId;
var commValueChange = DataAccess.InsertPersonCommunication(out var id, item);
AddedCommunication.Add(item);
}
var address = new PersonsAddressModel()
{
PeAdCity = City,
PeAdStreetName = Adress,
PeAdPerIdFk = AddedPerson.PeId
};
DataAccess.InsertPersonAddress(out var adressId, address);
AddedAddress.Add(address);
IsInProgress = false;
App.Current.Dispatcher.Invoke(() =>
{
window.DialogResult = true;
window.Close();
});
})
{
IsBackground = true
}.Start();
public VMUserEdit(UsersModel user, PersonsModel person, List <PersonsCommunicationModel> PersonCommunications, List <GroupsModel> Groups, List <RolesModel> Roles, List <GroupRolesModel> GroupRoles, List <UserGroupModel> UserGroups, List <CodesModel> SystemConstants)
{
Person = person;
SelectedUserType = SystemConstants.Where(x => x.CId == person.PeType && x.CId == SystemValues.MasterSystemConstants.UserType).FirstOrDefault();
UserState = user.UIsActive.ToBool();
UserTypeSource.ReFill(SystemConstants.Where(x => x.CMasterId == SystemValues.MasterSystemConstants.UserType));
CommunicationCodeSource.ReFill(SystemConstants.Where(x => x.CMasterId == SystemValues.MasterSystemConstants.CommunicationType));
this.GroupRoles = GroupRoles;
this.Roles = Roles;
AddedGroupsSource.ReFill(Groups.Where(x => UserGroups.Where(y => y.GroupId == x.GId && y.UserId == person.PeId).Count() > 0));
SuggestedGroupsSource.ReFill(Groups.Where(x => !AddedGroupsSource.Contains(x)));
foreach (var item in PersonCommunications.Where(x => x.CoPeIdFk == person.PeId))
{
CommunicationSource.Add((item, SystemConstants));
}
PresentUser(user);
PresentPerson(person);
}
public static PersonsModel ToPersons(this DataRow item)
{
PersonsModel person = new PersonsModel();
//if (!item[PersonsTable.PeName].GetType().Name.Equals("DBNull"))
// person.PeName = item[PersonsTable.PeName].ToString();
//if (!item[PersonsTable.PeId].GetType().Name.Equals("DBNull"))
// person.PeId = Convert.ToInt64(item[PersonsTable.PeId]);
//if (!item[PersonsTable.PeAddress].GetType().Name.Equals("DBNull"))
// person.PeAddress = Convert.ToInt64(item[PersonsTable.PeAddress]);
//if (!item[PersonsTable.PeIdentity].GetType().Name.Equals("DBNull"))
// person.PeIdentity = Convert.ToInt32(item[PersonsTable.PeIdentity]);
//if (!item[PersonsTable.PeType].GetType().Name.Equals("DBNull"))
// person.PeType = Convert.ToInt32(item[PersonsTable.PeType]);
return(person);
}
public async Task <PersonsModel> CreatePersonAsync(PersonsModel person)
{
var personResult = Mapping.Mapper.Map <Persons.Data.Entities.Persons>(person);
await _context.Persons.AddAsync(personResult);
if (person.Address != null)
{
var Addressresult = Mapping.Mapper.Map <Addresses>(person.Address);
Addressresult.PersonId = personResult.PersonId;
await _context.Addresses.AddAsync(Addressresult);
await _context.SaveChangesAsync();
personResult.AddressId = Addressresult.AddressId;
}
await _context.SaveChangesAsync();
var personModel = await GetPersonModel(personResult.PersonId);
return(personModel);
}
public ResponseModel <List <T> > UpdatePerson(PersonsModel model)
{
try
{
var entity = _context.Person.Where(i => i.Code == model.Code).FirstOrDefault();
if (entity == null)
{
var response = new ResponseModel <List <T> >();
response.IsSuccess = false;
response.UserInterfaceMessage = "Person does not exist";
return(response);
}
entity.Name = model.Name;
entity.Surname = model.Surname;
entity.IdNumber = model.IdNumber;
entity.Active = model.Active;
_context.SaveChanges();
return(SuccessResponse(0, "Updated successfully", ""));
}
catch (Exception ex)
{
return(FailResponse(1, "Error updating record", ex.GetBaseException().ToString()));
}
}
public ResponseModel <List <PersonsModel> > UpdatePerson(PersonsModel model)
{
return(_repo.UpdatePerson(model));
}
public MainViewModel()
{
PersonsModel = new PersonsModel(this);
ProgressBarInProgress = Visibility.Hidden;
}
public PersonsController()
{
personsModel = new PersonsModel();
}
public bool CheckIfOldPersonExit(int personId, PersonsModel person)
{
var result = _context.Persons.FirstOrDefault(e => e.PersonId == personId);
return(_context.Persons.FirstOrDefault(e => e.PrivateNumber == person.PrivateNumber) == null || result.PrivateNumber != person.PrivateNumber ? true : false);
}
public bool CheckIfNewPersonExit(PersonsModel person)
{
return(_context.Persons.FirstOrDefault(e => e.PrivateNumber == person.PrivateNumber) == null ? true : false);
}
public JobListsController()
{
eventsModel = new EventsModel();
personsModel = new PersonsModel();
departmentsModel = new DepartmentsModel();
}
public static VMUserEdit Create(UsersModel user, PersonsModel person, List <PersonsCommunicationModel> PersonCommunications, List <GroupsModel> Groups, List <RolesModel> Roles, List <GroupRolesModel> GroupRoles, List <UserGroupModel> UserGroups, List <CodesModel> SystemConstants) => ViewModelSource.Create(() => new VMUserEdit(user, person, PersonCommunications, Groups, Roles, GroupRoles, UserGroups, SystemConstants));
public void AddEmployee(PersonsModel personsModel)
{
this.Connect.Execute("PersonsProc", personsModel, commandType: CommandType.StoredProcedure);
}
