public async Task <IActionResult> Get([FromHeader] GetPersonRequest request)
{
IService service = _personServiceFactory.GetService(PersonServiceType.GetPerson, request);
var result = await service.ProcessAsync();
return(StatusCode((int)(result?.StatusCode ?? HttpStatusCode.InternalServerError), result?.Response));
}
/// <summary>
/// Fetch a single person
/// </summary>
/// <param name="id">Entity identification</param>
/// <returns></returns>
public async Task <Person> Get(int id)
{
var getPersonRequest = new GetPersonRequest(id);
var personResponse = await _mediator.Send(getPersonRequest);
return(personResponse);
}
public IActionResult GetPerson([FromQuery] GetPersonRequest request)
{
if (request.AuditingEnabled && !string.IsNullOrEmpty(request.UserId))
{
var auditRequest = new CreateRequestAuditRequest()
{
ActionName = "view_resident",
UserName = request.UserId,
Metadata = new Dictionary <string, object>()
{
{ "residentId", request.Id }
}
};
_createRequestAuditUseCase.Execute(auditRequest);
}
var response = _residentUseCase.GetResident(request);
if (response == null)
{
return(NotFound());
}
return(StatusCode(200, response));
}
public static GetPersonRequest MapSSNToGetPersonRequest(string ssn)
{
GetPersonRequest getRequest = new GetPersonRequest();
CriteriaPSC2CanonicalType CriteriaPSC2 = new CriteriaPSC2CanonicalType();
ASA.Web.Services.LoanService.Proxy.PersonManagement.CriterionSSNType PersonSSNCriterion = new ASA.Web.Services.LoanService.Proxy.PersonManagement.CriterionSSNType();
PersonSSNCriterion.RelationalOperator = ASA.Web.Services.LoanService.Proxy.PersonManagement.RelationalOperatorType.EQUALS;
PersonSSNCriterion.SSN = ssn; // SEARCH CRITERIA
PersonSSNCriterion.LogicalOperator = ASA.Web.Services.LoanService.Proxy.PersonManagement.LogicalOperatorType.AND;
ASA.Web.Services.LoanService.Proxy.PersonManagement.CriterionCustomerIdType criterionCustomerIdType = new ASA.Web.Services.LoanService.Proxy.PersonManagement.CriterionCustomerIdType();
criterionCustomerIdType.RelationalOperator = ASA.Web.Services.LoanService.Proxy.PersonManagement.RelationalOperatorType.EQUALS;
criterionCustomerIdType.LogicalOperator = ASA.Web.Services.LoanService.Proxy.PersonManagement.LogicalOperatorType.AND;
criterionCustomerIdType.CustomerId = 1;//customerID is master person.
ASA.Web.Services.LoanService.Proxy.PersonManagement.ReturnListType listReturnTypesType = new ASA.Web.Services.LoanService.Proxy.PersonManagement.ReturnListType();
listReturnTypesType.PersonTier2Type = ASA.Web.Services.LoanService.Proxy.PersonManagement.YNFlagType.Y;
CriteriaPSC2.CriterionSSN = PersonSSNCriterion;
CriteriaPSC2.CriterionCustomerID = criterionCustomerIdType;
CriteriaPSC2.ListReturnTypes = listReturnTypesType;
getRequest.Criteria = CriteriaPSC2 as PersonServiceCriteriaType;
getRequest.Criteria.MaxEntities = 25;
return(getRequest);
}
public void GetPersonByIdCallsTheCreateRequestAuditUseCaseWithCorrectValuesWhenAuditingIsEnabledIsTrueAndUserIdIsProvided()
{
var getPersonRequest = new GetPersonRequest()
{
AuditingEnabled = true, UserId = _faker.Person.Email, Id = 1
};
var request = new CreateRequestAuditRequest()
{
ActionName = "view_resident",
UserName = getPersonRequest.UserId,
Metadata = new Dictionary <string, object>()
{
{ "residentId", getPersonRequest.Id }
}
};
_mockCreateRequestAuditUseCase.Setup(x => x.Execute(request)).Verifiable();
_residentController.GetPerson(getPersonRequest);
_mockCreateRequestAuditUseCase.Verify(x => x.Execute(It.Is <CreateRequestAuditRequest>(
y => y.ActionName == request.ActionName &&
y.UserName == request.UserName &&
JsonConvert.SerializeObject(y.Metadata) == JsonConvert.SerializeObject(request.Metadata)
)), Times.Once);
}
public GetPersonResponse Get(GetPersonRequest request)
{
return(new GetPersonResponse
{
Person = this.personsApplication.Get(Request.ToCaller(), request.Id, request.ToGetOptions())
});
}
public IValidator GetValidator(IRequest request)
{
return(request switch
{
GetPersonRequest _ => new GetPersonRequestValidator(),
_ => null
});
public HttpResponseMessage Get(GetPersonRequest request)
{
try
{
dynamic search = request.Id > 0 ? (dynamic)request.Id : request.PhoneNumber;
switch (request.PersonType)
{
case PersonType.Student:
var student = PersonsService <Student> .Instance.GetPerson(search);
var studentJson = JsonConvert.SerializeObject(student);
return(new HttpResponseMessage()
{
Content = new StringContent(studentJson)
});
case PersonType.Entrant:
var entrants = PersonsService <Entrant> .Instance.GetPerson(search);
var entrantsJson = JsonConvert.SerializeObject(entrants);
return(new HttpResponseMessage {
Content = new StringContent(entrantsJson)
});
case PersonType.Employee:
var employee = PersonsService <Employee> .Instance.GetPerson(search);
var employeeJson = JsonConvert.SerializeObject(employee);
return(new HttpResponseMessage {
Content = new StringContent(employeeJson)
});
case PersonType.Guest:
var guest = PersonsService <Guest> .Instance.GetPerson(search);
var guestJson = JsonConvert.SerializeObject(guest);
return(new HttpResponseMessage {
Content = new StringContent(guestJson)
});
default:
return(new HttpResponseMessage {
Content = new StringContent("such person type is not supported")
});
}
}
catch (Exception ex)
{
return(new HttpResponseMessage()
{
Content = new StringContent(ex.Message)
});
}
}
public void GetPersonRequestValidator()
{
IRequest request = new GetPersonRequest();
var result = PersonValidatorFactory.GetValidator(request);
Assert.IsTrue(result is GetPersonRequestValidator);
}
public override async Task <Person> GetPerson(GetPersonRequest request, ServerCallContext context)
{
return(new Person
{
Email = $"test{request.Id}@test.com",
Id = request.Id,
Name = $"Test{request.Id} Testerson{request.Id}"
});
}
async void LoadCustomer()
{
if (currentWorkOrder.WorkOrder.CustomerId != 0)
{
GetPersonRequest personRequest = new GetPersonRequest();
personRequest.PersonId = currentWorkOrder.WorkOrder.CustomerId;
((App)App.Current).PostRequest <GetPersonRequest, GetPersonResponse>("GetPerson", personRequest).ContinueWith(a => CustomerLoaded(a.Result));
}
}
public void OnSearchPersonClicked(object sender, EventArgs e)
{
GetPersonRequest request = new GetPersonRequest();
request.FirstName = Name.Text;
request.Email = Email.Text;
((App)App.Current).GetVendors(request).ContinueWith(a => LoadVendors(a.Result));
}
public void Setup()
{
MockServiceValidationConverter = new Mock <IServiceValidationConverter>();
MockValidatorFactory = new Mock <IValidatorFactory>();
MockPersonRepository = new Mock <IPersonRepository>();
Request = new GetPersonRequest
{
PersonID = int.MaxValue
};
}
public void Initialize()
{
this.identifierFactory = new Mock <IIdentifierFactory>();
this.identifierFactory.Setup(f => f.IsValid(It.IsAny <Identifier>())).Returns(true);
this.validator = new GetPersonRequestValidator(new HasGetOptionsValidator(), this.identifierFactory.Object);
this.dto = new GetPersonRequest
{
Id = "anid"
};
}
public override Task <PersonListResponse> GetPersonList(GetPersonRequest request, ServerCallContext context)
{
return(Task.Factory.StartNew <PersonListResponse>(() =>
{
TestEntity.BLL.Person bll = new TestEntity.BLL.Person();
var result = bll.GetPersonList(new TestEntity.Params.GetPersonParam());
var response = new PersonListResponse();
return response;
}));
}
public void GetPersonByIdCallsPersonUseCaseWhenOnlyIdIsProvidedToEnsureBackwardsCompatibility()
{
var getPersonRequest = new GetPersonRequest {
Id = 1
};
_residentController.GetPerson(getPersonRequest);
_mockResidentUseCase.Verify(x => x.GetResident(getPersonRequest));
}
//Called Get - actually a Post
public async Task <GetPersonResponse> GetCustomer(long customerId)
{
GetPersonRequest request = new GetPersonRequest();
request.PersonId = customerId;
GetPersonResponse taskResponse = await PostRequest <GetPersonRequest, GetPersonResponse>("GetPerson", request);
return(taskResponse);
}
public void GetPersonByIdReturns404WhenPersonNotFound()
{
var request = new GetPersonRequest();
_mockResidentUseCase.Setup(x => x.GetResident(request));
var result = _residentController.GetPerson(request) as ObjectResult;
result?.StatusCode.Should().Be(404);
}
/// <summary>
/// Отдаёт клиенту на скачивание файл биографии персоны асинхронно
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <byte[]> DownloadAsync(GetPersonRequest request)
{
if (request == null)
{
throw new ArgumentNullException("Person model GetPersonRequest is invalid");
}
var person = await factory.CreateUnitOfWork().Persons.GetItemAsync(request.Id);
return(person.Biography);
}
public GetPersonService(IValidatorFactory validatorFactory,
IPersonRepository personRepository,
IServiceValidationConverter serviceValidationConverter,
IRequest request)
{
_validatorFactory = validatorFactory;
_personRepository = personRepository;
_serviceValidationConverter = serviceValidationConverter;
_request = request as GetPersonRequest;
}
protected void CreateUser_Click(object sender, EventArgs e)
{
if (checkMail(Email.Text))
{
GetPersonRequest rqt = new GetPersonRequest()
{
Username = Email.Text
};
using (Service1Client client = new Service1Client())
{
GetPersonResponse rsp = client.GetPerson(rqt);
//Check mail is not already used
if (rsp.Errored)
{
//Check password and Hash
if (check_password(Password.Text) && Password.Text == ConfirmPassword.Text)
{
// Add to database
Person user = new Person()
{
Username = Email.Text,
Company = Company.Text,
IsAdmin = false,
Password = Password.Text
};
RegisterUserResponse response = client.RegisterUser(new RegisterUserRequest()
{
User = user
});
if (!response.Errored)
{
ErrorMessage.Text = "Your account has been created";
}
else
{
ErrorMessage.Text = "Fail to create your account";
}
}
else
{
ErrorMessage.Text = "Wrong Password";
}
}
else
{
ErrorMessage.Text = "This email adress is already used";
}
}
}
else
{
ErrorMessage.Text = "Wrong email address format";
}
}
public async Task NullRequest()
{
GetPersonRequest request = null;
var validator = new GetPersonRequestValidator();
var validatorResults = await validator.ValidateAsync(request);
Assert.IsTrue(!validatorResults.IsValid);
Assert.IsTrue(validatorResults?.Errors?.Count == 1);
Assert.IsTrue(validatorResults.Errors.FirstOrDefault(e => e.PropertyName == "Request" && e.ErrorMessage == "The request has not been populated.") != null);
Assert.IsTrue(validatorResults?.Errors[0].PropertyName == "Request");
}
public void OnCustomerSearchClicked(object sender, EventArgs e)
{
GetPersonRequest request = new GetPersonRequest();
request.Email = Email.Text;
request.FirstName = FirstName.Text;
request.LastName = LastName.Text;
request.PhonePrimary = Phone.Text;
((App)App.Current).GetCustomers(request).ContinueWith(a => CustomersLoaded(a.Result));
}
public void GetPersonByIdCallsTheCreateRequestAuditUseCaseWhenAuditingIsEnabledIsTrueAndUserIdIsProvided()
{
var getPersonRequest = new GetPersonRequest()
{
AuditingEnabled = true, UserId = _faker.Person.Email, Id = 1
};
_residentController.GetPerson(getPersonRequest);
_mockCreateRequestAuditUseCase.Verify(x => x.Execute(It.IsAny <CreateRequestAuditRequest>()), Times.Once);
}
public override async Task <Person> GetDbPerson(GetPersonRequest request, ServerCallContext context)
{
var dbPerson = await this.dbContext.TestPersonGrpcTbl.SingleOrDefaultAsync(x => x.Id == request.Id);
return(new Person
{
Email = dbPerson.Email,
Name = dbPerson.Name,
Id = request.Id
});
}
[HttpGet("[action]")] // route is specified - may only need Person
public async Task <IGetPersonResponse> GetPerson(Guid personId, string groupId)
{
var request = new GetPersonRequest
{
PersonId = personId,
GroupId = Convert.ToInt32(groupId)
};
return(await _cognitiveAdminService.Handle(request));
}
public async Task <GetPersonResponse> GetPerson(GetPersonRequest request)
{
HttpResponseMessage res = await _client.GetAsync($"person/{request.Username}");
var content = await res.Content.ReadAsStringAsync();
EnsureSuccessStatusCode(res, content);
var getPersonResponse = JsonConvert.DeserializeObject <GetPersonResponse>(content);
return(getPersonResponse);
}
public async Task SuccessfulRequest()
{
var request = new GetPersonRequest
{
PersonID = int.MaxValue
};
var validator = new GetPersonRequestValidator();
var validatorResults = await validator.ValidateAsync(request);
Assert.IsTrue(validatorResults.IsValid);
Assert.IsTrue(validatorResults?.Errors?.Count == 0);
}
public void GetPersonByIdReturns200WhenSuccessful()
{
var request = new GetPersonRequest();
_mockResidentUseCase
.Setup(x => x.GetResident(request))
.Returns(new GetPersonResponse());
var response = _residentController.GetPerson(request) as ObjectResult;
response?.StatusCode.Should().Be(200);
}
public void GetPersonByIdDoesNotCallTheCreateRequestAuditUseCaseWhenAuditingIsEnabledIsFalse()
{
var request = new GetPersonRequest
{
AuditingEnabled = false,
UserId = _faker.Person.Email,
Id = 7
};
_residentController.GetPerson(request);
_mockCreateRequestAuditUseCase.Verify(x => x.Execute(It.IsAny <CreateRequestAuditRequest>()), Times.Never);
}
