public void Create(PersonRelation person)
{
if (person == null)
{
throw new ArgumentNullException(nameof(person));
}
_db.PersonRelations.Add(person);
}
public void AddRelatedPerson(int personId, Person relatedPerson, PersonRelationType relationType)
{
var personRelation = new PersonRelation {
PersonId = personId, RelatedPerson = relatedPerson, RelationType = relationType
};
context.PersonRelations.Add(personRelation);
context.SaveChanges();
}
public ServiceResult <bool> AddRelatedPerson(RelatedPersonCreateVm model)
{
model.Validate();
if (!model.PersonId.HasValue)
{
throw new DomainException("Person Id invalid", ExceptionLevel.Error);
}
var person = _repository.Person.GetById(model.PersonId.Value);
if (person == null)
{
throw new DomainException("Person Not Found", ExceptionLevel.Error);
}
if (model.CityId.HasValue)
{
var city = _repository.City.GetById(model.CityId.Value);
if (city == null)
{
throw new DomainException("City not found", ExceptionLevel.Error);
}
}
var newPerson = Domain.Models.PersonModels.Person.Create(model.FirstName,
model.LastName,
model.Gender,
model.PrivateNumber,
model.BirthDate,
model.CityId);
_repository.Person.Create(newPerson);
newPerson.PhoneNumbers = new List <PhoneNumber>();
foreach (var modelPhoneNumber in model.PhoneNumbers)
{
var newPhoneNumber =
PhoneNumber.Create(newPerson.Id, modelPhoneNumber.NumberType, modelPhoneNumber.Number);
newPerson.PhoneNumbers.Add(newPhoneNumber);
}
newPerson.Relation = PersonRelation.Create(model.PersonId.Value, newPerson.Id, model.RelationType);
_repository.Person.Save();
return(new ServiceResult <bool>
{
Status = ServiceResultStatus.Success
});
}
public void Update(PersonRelation model)
{
if (model == null)
{
throw new ArgumentException("Model is empty");
}
var entity = _db.PersonRelations.Single(u => u.Id == model.Id);
entity.RelationType = model.RelationType;
}
public void Save(PersonRelation obj)
{
if (obj.Id == 0)
{
context.Entry(obj).State = System.Data.Entity.EntityState.Added;
}
else
{
context.Entry(obj).State = System.Data.Entity.EntityState.Modified;
}
context.SaveChanges();
}
public async Task <bool> UpdatePersonRelation(PersonRelation entity)
{
string query = @"
UPDATE [PersonRelation]
SET [InviterId] = @InviterId
,[InvitedId] = @InvitedId
,[RelationType] = @RelationType
,[DateCreated] = @DateCreated
,[DateModified] = @DateModified
,[IsActive] = @IsActive
WHERE Id = @Id";
return(await Execute(query, new DynamicParameters(entity)) > 0);
}
public async Task <PersonRelationDTO> AddContact(PersonRelationDTO model)
{
var contact = new PersonRelation
{
PersonID = model.PersonID,
ContactID = model.ContactID,
PersonTypeID = model.PersonTypeID
};
_uow.PersonRelations.Insert(contact);
_uow.Save();
return(_mapper.Map <PersonRelationDTO>(contact));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
PersonRelation = await _context.PersonRelations.FirstOrDefaultAsync(m => m.PersonRelationId == id);
if (PersonRelation == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
PersonRelation = await _context.PersonRelations.FindAsync(id);
if (PersonRelation != null)
{
_context.PersonRelations.Remove(PersonRelation);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <Result <int> > AddedRelatedPersonAsync(int id, RelatedPersonCreateRequest model)
{
var result = new Result <int>();
try
{
var person = await _uow.Persons.GetByIdAsync(id);
if (person == null)
{
result.AddError(ErrorMessages.PersonNotFound);
return(result);
}
var relatedPerson = await _uow.Persons.GetByIdAsync(model.RelatedPersonId);
if (relatedPerson == null)
{
result.AddError(ErrorMessages.RelatedPersonNotFound);
return(result);
}
var relation = new PersonRelation
{
PersonId = id,
RelatedPersonId = model.RelatedPersonId,
Type = model.Type
};
_uow.PersonRelations.Add(relation);
await _uow.SaveAsync();
result.Data = relation.Id;
_logger.LogError($"{nameof(PersonsService)} => {nameof(AddedRelatedPersonAsync)} | Relation Added to person | Id: {id}");
}
catch (Exception ex)
{
_logger.LogError($"{nameof(PersonsService)} => {nameof(AddedRelatedPersonAsync)} | Relation have not added to person | Id: {id} | ex: {ex.ToString()} | trace: {ex.StackTrace.ToString()}");
result.AddError(ErrorMessages.InternalServerError, HttpStatusCode.InternalServerError);
}
return(result);
}
public async Task <string> CreatePersonRelation(PersonRelation entity)
{
string query = @"
INSERT INTO [PersonRelation]
([Id]
,[InviterId]
,[InvitedId]
,[RelationType]
,[DateCreated]
,[DateModified]
,[IsActive])
OUTPUT INSERTED.Id
VALUES
(@Id
,@InviterId
,@InvitedId
,@RelationType
,@DateCreated
,@DateModified
,@IsActive)";
return(await QueryFoD <string>(query, new DynamicParameters(entity)));
}
/// <summary> /// Persons the relation to person create bal. /// </summary> /// <param name="_objPerson">The object person.</param> /// <returns>System.Int64.</returns> public long PersonRelationToPerson_CreateBAL(PersonRelation _objPerson) => DAL.PersonRelationToPerson_CreateDAL(_objPerson);
public PersonRelationVm(PersonRelation personRelation)
{
RelationType = personRelation.RelationType;
RelatedPerson = $"{personRelation.Person.FirstName} {personRelation.Person.LastName}";
}
/// <summary> /// Persons the relation to person duplication check bal. /// </summary> /// <param name="_objPerson">The object person.</param> /// <returns>System.Int32.</returns> public int PersonRelationToPerson_DuplicationCheckBAL(PersonRelation _objPerson) => DAL.PersonRelationToPerson_DuplicationCheckDAL(_objPerson);
/// <summary> /// Persons the relation to person delete bal. /// </summary> /// <param name="_objPerson">The object person.</param> /// <returns>System.Int32.</returns> public int PersonRelationToPerson_DeleteBAL(PersonRelation _objPerson) => DAL.PersonRelationToPerson_DeleteDAL(_objPerson);
public async Task <Result <AddPersonEmergencyContactResponse> > Handle(PersonEmergencyContactCommand request, CancellationToken cancellationToken)
{
try
{
RegisterPersonService rs = new RegisterPersonService(_unitOfWork);
if (request.PersonId > 0)
{
if (request.EmergencyContactPersonId > 0)
{
PersonEmergencyContact pme = new PersonEmergencyContact();
pme = await Task.Run(() => rs.GetSpecificEmergencyContacts(Convert.ToInt32(request.EmergencyContactPersonId), request.PersonId));
if (pme != null)
{
pme.PersonId = request.PersonId;
pme.EmergencyContactPersonId = request.EmergencyContactPersonId;
pme.MobileContact = request.MobileContact;
pme.CreatedBy = request.CreatedBy;
pme.DeleteFlag = request.DeleteFlag;
int res = await Task.Run(() => rs.UpdatePersonEmergencyContact(pme));
if (res > 0)
{
msg += "Person Emergency Mobile Contact Updated Successfully";
personEmergencyContactId = request.EmergencyContactPersonId;
}
var personconsent = await Task.Run(() => rs.GetCurrentPersonConsent(pme.Id, Convert.ToInt32(request.PersonId)));
if (personconsent != null)
{
personconsent.ConsentType = request.ConsentType;
personconsent.ConsentValue = request.ConsentValue;
personconsent.ConsentDate = DateTime.Now;
personconsent.ConsentReason = request.ConsentReason;
int consent = await Task.Run(() => rs.UpdatePersonConsent(personconsent));
if (consent > 0)
{
msg += "Person Consent has been updated successfully";
}
}
else
{
PersonConsent pcs = new PersonConsent();
pcs.PersonId = request.PersonId;
pcs.EmergencyContactId = pme.Id;
pcs.ConsentType = request.ConsentType;
pcs.ConsentValue = request.ConsentValue;
pcs.ConsentDate = DateTime.Now;
pcs.ConsentReason = request.ConsentReason;
var perc = await Task.Run(() => rs.AddPersonConsent(pcs));
if (perc != null)
{
msg += "Person Consent Has been added successfully";
}
}
Person per = new Person();
per.FirstName = request.firstname;
per.MidName = request.middlename;
per.LastName = request.lastname;
per.Sex = request.gender;
per.Id = request.EmergencyContactPersonId;
int resupda = await Task.Run(() => rs.UpdatePerson(per, request.EmergencyContactPersonId));
if (resupda > 0)
{
msg += "PersonEmergencyContact updated successfully";
}
}
}
}
else
{
var personEmerg = await Task.Run(() => rs.InsertPerson(request.firstname, request.middlename, request.lastname, request.gender, request.CreatedBy));
if (personEmerg != null)
{
personEmergencyContactId = personEmerg.Id;
PersonEmergencyContact pmm = new PersonEmergencyContact()
{
PersonId = request.PersonId,
EmergencyContactPersonId = personEmerg.Id,
MobileContact = request.MobileContact,
CreatedBy = request.CreatedBy,
DeleteFlag = request.DeleteFlag
};
int pmeid = await Task.Run(() => rs.AddPersonEmergencyContact(pmm));
if (pmeid > 0)
{
msg += "New Person Emergencycontact Added successfully";
}
PersonConsent pcs = new PersonConsent();
pcs.PersonId = request.PersonId;
pcs.EmergencyContactId = pmeid;
pcs.ConsentType = request.ConsentType;
pcs.ConsentValue = request.ConsentValue;
pcs.ConsentDate = DateTime.Now;
pcs.ConsentReason = request.ConsentReason;
var perc = await Task.Run(() => rs.AddPersonConsent(pcs));
if (perc != null)
{
msg += "Person Consent Has been added successfully";
}
PersonRelation pl = new PersonRelation();
var personrel = await Task.Run(() => rs.AddPersonRelationship(request.PersonId, personEmerg.Id, request.RelationshipType, request.CreatedBy));
if (personrel != null)
{
msg += "Person EmergencyContact relationship added successfully";
}
}
}
return(Result <AddPersonEmergencyContactResponse> .Valid(new AddPersonEmergencyContactResponse()
{
Message = msg,
PersonEmergencyContactId = personEmergencyContactId
}));
}
catch (Exception e)
{
return(Result <AddPersonEmergencyContactResponse> .Invalid(e.Message));
}
}
public ActionResult Relation_Destroy([DataSourceRequest] DataSourceRequest request, PersonRelation _objPersonRelation)
{
if (ModelState.IsValid)
{
_objPersonRelation.UpdatedBy = CurrentUser.NameIdentifierInt64;
_objPersonRelation.UpdatedDate = DateTime.Now;
var result = _PersonBAL.PersonRelationToPerson_DeleteBAL(_objPersonRelation);
string ip = System.Web.HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (string.IsNullOrEmpty(ip))
{
ip = System.Web.HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
}
_objConfigurationBAL.Audit_CreateBAL(ip, DateTime.Now, CurrentUser.CompanyID, CurrentUser.NameIdentifierInt64, EventType.Update, System.Web.HttpContext.Current.Request.Browser.Browser);
if (result == -1)
{
ModelState.AddModelError(lr.ErrorServerError, lr.ResourceUpdateValidationError);
}
}
var resultData = new[] { _objPersonRelation };
return(Json(resultData.AsQueryable().ToDataSourceResult(request, ModelState)));
}
public ActionResult Relation_Create([DataSourceRequest] DataSourceRequest request, long pid, PersonRelation _objPersonRelation)
{
if (ModelState.IsValid)
{
_objPersonRelation.CreatedBy = CurrentUser.NameIdentifierInt64;
_objPersonRelation.CreatedDate = DateTime.Now;
_objPersonRelation.RelationFrom = pid;
if (_PersonBAL.PersonRelationToPerson_DuplicationCheckBAL(_objPersonRelation) == 0)
{
_objPersonRelation.RelationID = _PersonBAL.PersonRelationToPerson_CreateBAL(_objPersonRelation);
string ip = System.Web.HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (string.IsNullOrEmpty(ip))
{
ip = System.Web.HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
}
_objConfigurationBAL.Audit_CreateBAL(ip, DateTime.Now, CurrentUser.CompanyID, CurrentUser.NameIdentifierInt64, EventType.Create, System.Web.HttpContext.Current.Request.Browser.Browser);
}
else
{
ModelState.AddModelError(lr.PersonRelationToField, lr.PersonRelationDuplicationMessage);
}
}
var resultData = new[] { _objPersonRelation };
return(Json(resultData.ToDataSourceResult(request, ModelState)));
}
