public GetPersonModule(IQueryDispatcher queryDispatcher) : base("/api/v1/")
{
Get["/persons/{id}"] = parameters =>
{
GetPersonQuery query = null;
try
{
query = this.Bind <GetPersonQuery>();
}
catch (ModelBindingException e)
{
return(Response.AsText(e.Message).WithStatusCode(HttpStatusCode.BadRequest));
}
PersonDto person = null;
try
{
person = queryDispatcher.Execute <GetPersonQuery, PersonDto>(query);
}
catch (Exception e)
{
return(Response.AsText(e.Message).WithStatusCode(HttpStatusCode.InternalServerError));
}
return(person == null?Response.AsText("").WithStatusCode(HttpStatusCode.NotFound)
: Response.AsJson(person).WithStatusCode(HttpStatusCode.OK));
};
}
public IList <PersonVM> GetPerson()
{
var query = new GetPersonQuery();
var data = _readData.GetPerson(query);
var vm = _mapper.Map <IList <PersonVM> >(data);
return(vm);
}
public GetPersonQueryResult Get(GetPersonQuery query)
{
return(Execute <GetPersonQueryResult>(PersonListApiActions.Get,
keys: new Dictionary <string, string>()
{
{ "id", query.Id.ToString() }
}));
}
public void GetPersonFail(string term)
{
GetPersonQuery query = new GetPersonQuery(term);
query.Execute();
GetPersonResult result = query.GetResult() as GetPersonResult;
Assert.IsTrue(result.Succeeded);
Assert.AreEqual(0, result.Persons.Count);
}
public PersonDto GetPerson(GetPersonQuery query)
{
var person = PeopleDB.Items.Find(p => p.Id == query.Id);
return(new PersonDto
{
Id = person.Id,
FirstName = person.FirstName,
MiddleName = person.MiddleName,
LastName = person.LastName
});
}
public void GetPerson(string term)
{
GetPersonQuery query = new GetPersonQuery(term);
query.Execute();
GetPersonResult result = query.GetResult() as GetPersonResult;
Assert.IsTrue(result.Succeeded);
Assert.AreEqual(1, result.Persons.Count);
Assert.AreEqual(1, result.Persons[0].Id);
Assert.AreEqual("Avocado", result.Persons[0].Name);
Assert.AreEqual("Brazil", result.Persons[0].Nationality);
}
public void ListPersons()
{
GetPersonQuery query = new GetPersonQuery();
query.Execute();
GetPersonResult result = query.GetResult() as GetPersonResult;
Assert.AreEqual(result.Persons.Count, 3);
Assert.AreEqual(result.Persons[0].Name, "Alfred");
Assert.AreEqual(result.Persons[0].Nationality, "Africa");
Assert.AreEqual(result.Persons[1].Name, "Billy");
Assert.AreEqual(result.Persons[1].Nationality, "Botswana");
Assert.AreEqual(result.Persons[2].Name, "Chad");
Assert.AreEqual(result.Persons[2].Nationality, "Chad");
}
public async Task <IActionResult> GetPerson([FromBody] GetPersonQuery query)
{
var result = await _queryExecutor.ExecuteAsync <GetPersonQuery, Person>(query);
if (!result.Success)
{
return(BadRequest(new { success = false }));
}
return(Ok(new
{
data = JsonConvert.SerializeObject(new
{
firstName = result.Data.FirstName,
Phone = result.Data.Phone
})
}));
}
public async Task <IActionResult> GetAgentProfile(
[BindRequired, FromQuery] Agent agent,
CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var person = await _mediator.Send(GetPersonQuery.Create(agent), cancellationToken);
if (person == null)
{
return(NotFound());
}
return(Ok(person));
}
public ActionResult <List <Person> > Get(string term = "")
{
var query = new GetPersonQuery(term);
query.Execute();
if (!query.GetResult().Succeeded)
{
return(BadRequest("The request for Persons failed."));
}
var result = query.GetResult() as GetPersonResult;
if (result.Persons.Count == 0)
{
return(NoContent());
}
return(Ok(result.Persons));
}
public void DeletePerson()
{
DeletePersonCommand dpc = new DeletePersonCommand(1);
dpc.Execute();
DeletePersonResult dpr = dpc.GetResult() as DeletePersonResult;
Assert.IsTrue(dpr.Succeeded);
Assert.AreEqual(1, dpr.Person.Id);
Assert.AreEqual("Boris", dpr.Person.Name);
Assert.AreEqual("Britian", dpr.Person.Nationality);
GetPersonQuery gpq = new GetPersonQuery("Boris");
gpq.Execute();
GetPersonResult gpr = gpq.GetResult() as GetPersonResult;
Assert.IsTrue(gpr.Succeeded);
Assert.AreEqual(0, gpr.Persons.Count);
}
public void UpdatePerson()
{
Command unc = new UpdatePersonCommand(1, "Gazza", "Gurder");
unc.Execute();
UpdatePersonResult unr = unc.GetResult() as UpdatePersonResult;
Assert.IsTrue(unr.Succeeded);
Assert.AreEqual("Gazza", unr.Person.Name);
Command gpq = new GetPersonQuery("1");
gpq.Execute();
GetPersonResult gpr = gpq.GetResult() as GetPersonResult;
Assert.IsTrue(gpr.Succeeded);
Assert.AreEqual(1, gpr.Persons.Count);
Assert.AreEqual("Gazza", gpr.Persons[0].Name);
Assert.AreEqual("Gurder", gpr.Persons[0].Nationality);
}
public async Task <Person> GetPerson(Agent agent, CancellationToken cancellationToken = default)
{
var fallback = new Person();
fallback.Add(agent);
var storedAgent = await mediator.Send(GetAgentQuery.Create(agent));
if (storedAgent == null)
{
return(fallback);
}
var person = await mediator.Send(GetPersonQuery.Create(storedAgent.ObjectType, storedAgent.AgentId), cancellationToken);
if (person == null)
{
return(fallback);
}
return(mapper.Map <Person>(person));
}
public async Task <ActionResult <PersonsListViewModel> > GetPerson(GetPersonQuery model)
{
var result = await this._mediatR.Send(model);
return(this.Ok(result));
}
public List <Person> Handle(GetPersonQuery query)
{
var data = _dataContext.db.Query <Person>("select * from People").ToList();
return(data);
}
/// <inheritdoc/>
public GetPersonQuery.Person GetPerson(GetPersonQuery query)
{
Person person = _repository.GetPerson(query.Id);
return(person == null ? null : person.Adapt <GetPersonQuery.Person>());
}
public IEnumerable <Person> GetPerson(GetPersonQuery query)
{
var data = _messages.Dispatch(query);
return(data);
}
