public async Task <IActionResult> Get([FromQuery] PersonParameters personParameters)
{
var persons = await _repo.GetPeople(personParameters);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(persons.MetaData));
return(Ok(persons));
}
public async Task <PagingResponse <Person> > GetPeople(PersonParameters personParameters)
{
var queryStringParam = new Dictionary <string, string>
{
["pageNumber"] = personParameters.PageNumber.ToString()
};
var response = await _client.GetAsync(QueryHelpers.AddQueryString("https://localhost:5001/api/people", queryStringParam));
var content = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
throw new ApplicationException(content);
}
var pagingResponse = new PagingResponse <Person>
{
Items = JsonSerializer.Deserialize <List <Person> >(content, new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
}),
MetaData = JsonSerializer.Deserialize <MetaData>(response.Headers.GetValues("X-Pagination").First(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
})
};
return(pagingResponse);
}
public async Task <PagedList <Person> > GetPeople(PersonParameters personParameters)
{
var persons = await _context.People.ToListAsync();
return(PagedList <Person>
.ToPagedList(persons, personParameters.PageNumber, personParameters.PageSize));
}
public HttpResponseMessage CreatePersonAndFamily([FromBody] PersonParameters personParameters)
{
var rockContext = new RockContext();
var response = new HttpResponseMessage(HttpStatusCode.Created);
try
{
rockContext.WrapTransaction(() =>
{
var person = CreatePerson(personParameters, null, rockContext, false);
response.Content = new StringContent(person.Id.ToString());
});
}
catch (HttpResponseException exception)
{
return(exception.Response);
}
catch (Exception exception)
{
var errorResponse = new HttpResponseMessage(HttpStatusCode.InternalServerError);
errorResponse.Content = new StringContent(exception.Message);
return(errorResponse);
}
return(response);
}
public GameObject GetEnemyPrefab(Enemy enemy, AI.EnemyType enemyType)
{
GameObject enemyPrefab = enemy.Prefab;
PersonParameters enemyParameters = enemyPrefab.GetComponent <PersonParameters>();
enemyParameters = SetParameters(enemyParameters, enemy, enemyType);
return(enemyPrefab);
}
public async Task <PagedList <Person> > GetAllPersonsAsync(PersonParameters personParameters, bool trackChanges)
{
var persons = await FindAll(trackChanges)
.FilterPersons(personParameters.MinBirthDate, personParameters.MaxBirthDate, personParameters.BirthPlace,
personParameters.MinHeight, personParameters.MaxHeight)
.Search(personParameters.SearchTerm)
.Sort(personParameters.OrderBy)
.ToListAsync();
return(PagedList <Person> .ToPagedList(persons, personParameters.PageNumber, personParameters.PageSize));
}
private string CreateResourceUri(PersonParameters uriParameters, ResourceUriTypeEnum type)
{
switch (type)
{
case ResourceUriTypeEnum.Base:
return(_urlHelper.Link("GetPeople",
new
{
fields = uriParameters.Fields,
orderBy = uriParameters.OrderBy,
searchQuery = uriParameters.SearchQuery,
//pageSize = uriParameters.PageSize,
lastName = uriParameters.LastName
}));
case ResourceUriTypeEnum.PreviousPage:
return(_urlHelper.Link("GetPeople",
new
{
fields = uriParameters.Fields,
orderBy = uriParameters.OrderBy,
searchQuery = uriParameters.SearchQuery,
pageNumber = uriParameters.PageNumber - 1,
pageSize = uriParameters.PageSize,
lastName = uriParameters.LastName
}));
case ResourceUriTypeEnum.NextPage:
return(_urlHelper.Link("GetPeople",
new
{
fields = uriParameters.Fields,
orderBy = uriParameters.OrderBy,
searchQuery = uriParameters.SearchQuery,
pageNumber = uriParameters.PageNumber + 1,
pageSize = uriParameters.PageSize,
lastName = uriParameters.LastName
}));
default:
return(_urlHelper.Link("GetPeople",
new
{
fields = uriParameters.Fields,
orderBy = uriParameters.OrderBy,
searchQuery = uriParameters.SearchQuery,
pageNumber = uriParameters.PageNumber,
pageSize = uriParameters.PageSize,
lastName = uriParameters.LastName
}));
}
}
public async Task <IActionResult> GetPersons([FromQuery] PersonParameters personParameters)
{
if (!personParameters.ValidParametersRange)
{
return(BadRequest("Max birth date can't be lower than min birth date and max height can't be lower than min height."));
}
var persons = await _repository.Person.GetAllPersonsAsync(personParameters, false);
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(persons.MetaData));
var personsDto = _mapper.Map <IEnumerable <PersonDto> >(persons);
return(Ok(_dataShaper.ShapeData(personsDto, personParameters.Fields)));
}
public async Task <IActionResult> GetPersons([FromQuery] PersonParameters par)
{
if (!_propertyMappingService.ValidMappingExistsFor <PersonModel, PersonEntity>(par.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <PersonModel>(par.Fields))
{
return(BadRequest());
}
var PersonsFromRepo = await _peopleService.GetAsync(par);
var previousPageLink = PersonsFromRepo.HasPrevious ?
CreateResourceUri(par,
ResourceUriTypeEnum.PreviousPage) : null;
var nextPageLink = PersonsFromRepo.HasNext ?
CreateResourceUri(par,
ResourceUriTypeEnum.NextPage) : null;
var basePageLink = CreateResourceUri(par, ResourceUriTypeEnum.Base);
var paginationMetadata = new
{
totalCount = PersonsFromRepo.TotalCount,
pageSize = PersonsFromRepo.PageSize,
currentPage = PersonsFromRepo.CurrentPage,
totalPages = PersonsFromRepo.TotalPages,
previousPageLink = previousPageLink,
nextPageLink = nextPageLink,
basePageLink = basePageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var model = Mapper.Map <List <PersonModel> >(PersonsFromRepo);
var result = new
{
results = model,
metadata = paginationMetadata
};
return(Ok(result));
}
private IQueryable <PersonEntity> filter(PersonParameters searchModel)
{
var result = _context.People.ApplySort(searchModel.OrderBy, _propertyMappingService.GetPropertyMapping <PersonModel, PersonEntity>());
if (searchModel != null)
{
if (!string.IsNullOrWhiteSpace(searchModel.City))
{
result = result.Where(x => x.City == searchModel.City);
}
if (!string.IsNullOrWhiteSpace(searchModel.LastName))
{
result = result.Where(x => x.LastName == searchModel.LastName);
}
}
return(result);
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
IList <Person> persons = ViewModel.Persons;
for (int i = 0; i < persons.Count; i++)
{
var person = persons[i];
NIButton btnPerson = new NIButton(new RectangleF(0, i * 25, 250, 21));
btnPerson.Text = person.Name;
btnPerson.SetOnClick((sender, args) =>
{
PersonParameters param = new PersonParameters(person.Id);
StartPage <PersonDetailsViewController, PersonParameters>(param);
});
vwPersons.AddSubview(btnPerson);
}
}
private PersonParameters SetParameters(PersonParameters enemyParameters, Enemy enemy, AI.EnemyType enemyType)
{
switch (enemyType)
{
case AI.EnemyType.Enemy:
enemyParameters.HealthParameter.MaxValue = enemy.MaxHealthEnemy.Value;
enemyParameters.MoveSpeedParameter.Value = enemy.MoveSpeedEnemy.Value;
enemyParameters.AnimationTimeScaleParameter.Value = enemy.TimeScaleAnimationEnemy.Value;
enemyParameters.DamageHandParameter.Value = enemy.DamageHandEnemy.Value;
enemyParameters.DamageLegParameter.Value = enemy.DamageLegEnemy.Value;
break;
case AI.EnemyType.Boss:
enemyParameters.HealthParameter.MaxValue = enemy.MaxHealthBoss.Value;
enemyParameters.MoveSpeedParameter.Value = enemy.MoveSpeedBoss.Value;
enemyParameters.AnimationTimeScaleParameter.Value = enemy.TimeScaleAnimationBoss.Value;
enemyParameters.DamageHandParameter.Value = enemy.DamageHandBoss.Value;
enemyParameters.DamageLegParameter.Value = enemy.DamageLegBoss.Value;
enemyParameters.DamageLegParameter.Value = enemy.DamageSuperBoss.Value;
break;
}
return(enemyParameters);
}
public async Task <IActionResult> GetPersons([FromQuery] PersonParameters personParameters)
{
var persons = await _repository.Person.GetAllPersonsAsync(personParameters, false);
return(Ok(persons));
}
/// <summary>
/// Creates the person.
/// </summary>
/// <param name="giveParameters">The give parameters.</param>
/// <param name="locationId">The location identifier.</param>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
private Person CreatePerson(PersonParameters personParameters, int?locationId, RockContext rockContext, bool requireEmail = true)
{
if (requireEmail && string.IsNullOrWhiteSpace(personParameters.Email))
{
GenerateResponse(HttpStatusCode.BadRequest, "Email is required");
return(null);
}
if (!personParameters.Email.IsValidEmail())
{
GenerateResponse(HttpStatusCode.BadRequest, "Email must be valid");
return(null);
}
if (string.IsNullOrWhiteSpace(personParameters.FirstName) || string.IsNullOrWhiteSpace(personParameters.LastName))
{
GenerateResponse(HttpStatusCode.BadRequest, "FirstName and LastName are required");
return(null);
}
var person = new Person()
{
Guid = personParameters.PersonGuid.HasValue ? personParameters.PersonGuid.Value : Guid.NewGuid(),
FirstName = personParameters.FirstName,
LastName = personParameters.LastName,
IsEmailActive = true,
Email = personParameters.Email,
EmailPreference = EmailPreference.EmailAllowed,
RecordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id,
ConnectionStatusValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_PARTICIPANT).Id,
RecordStatusValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE).Id
};
// Create Person/Family
var familyGroup = PersonService.SaveNewPerson(person, rockContext, personParameters.CampusId, false);
if (!string.IsNullOrWhiteSpace(personParameters.PhoneNumber))
{
person.PhoneNumbers.Add(new PhoneNumber()
{
Number = personParameters.PhoneNumber,
NumberTypeValueId = DefinedValueCache.Read(new Guid(Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME)).Id
});
}
if (locationId.HasValue)
{
familyGroup.GroupLocations.Add(new GroupLocation()
{
GroupLocationTypeValueId = DefinedValueCache.Read(new Guid(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME)).Id,
LocationId = locationId.Value
});
}
if (personParameters.UserId.HasValue)
{
var user = new UserLoginService(rockContext).Get(personParameters.UserId.Value);
if (!user.PersonId.HasValue)
{
user.PersonId = person.Id;
}
}
rockContext.SaveChanges();
return(person);
}
public async Task <PagedList <PersonEntity, PersonModel> > GetAsync(PersonParameters fi)
{
var Person = filter(fi);
return(PagedList <PersonEntity, PersonModel> .Create(Person, fi.PageNumber, fi.PageSize, _mapper));
}
public async Task <List <PersonModel> > GetList(PersonParameters fi)
{
return(_mapper.Map <List <PersonModel> >(await filter(fi).ToListAsync()));
}
/// <summary>
/// Creates the person.
/// </summary>
/// <param name="giveParameters">The give parameters.</param>
/// <param name="locationId">The location identifier.</param>
/// <param name="rockContext">The rock context.</param>
/// <returns></returns>
private Person CreatePerson( PersonParameters personParameters, int? locationId, RockContext rockContext, bool requireEmail = true )
{
if ( requireEmail && string.IsNullOrWhiteSpace( personParameters.Email ) )
{
GenerateResponse( HttpStatusCode.BadRequest, "Email is required" );
return null;
}
if ( !personParameters.Email.IsValidEmail() )
{
GenerateResponse( HttpStatusCode.BadRequest, "Email must be valid" );
return null;
}
if ( string.IsNullOrWhiteSpace( personParameters.FirstName ) || string.IsNullOrWhiteSpace( personParameters.LastName ) )
{
GenerateResponse( HttpStatusCode.BadRequest, "FirstName and LastName are required" );
return null;
}
var person = new Person()
{
Guid = personParameters.PersonGuid.HasValue ? personParameters.PersonGuid.Value : Guid.NewGuid(),
FirstName = personParameters.FirstName,
LastName = personParameters.LastName,
IsEmailActive = true,
Email = personParameters.Email,
EmailPreference = EmailPreference.EmailAllowed,
RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id,
ConnectionStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_PARTICIPANT ).Id,
RecordStatusValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE ).Id
};
// Create Person/Family
var familyGroup = PersonService.SaveNewPerson( person, rockContext, personParameters.CampusId, false );
if ( !string.IsNullOrWhiteSpace( personParameters.PhoneNumber ) )
{
person.PhoneNumbers.Add( new PhoneNumber()
{
Number = personParameters.PhoneNumber,
NumberTypeValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id
} );
}
if ( locationId.HasValue )
{
familyGroup.GroupLocations.Add( new GroupLocation()
{
GroupLocationTypeValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME ) ).Id,
LocationId = locationId.Value
} );
}
if ( personParameters.UserId.HasValue )
{
var user = new UserLoginService( rockContext ).Get( personParameters.UserId.Value );
if ( !user.PersonId.HasValue )
{
user.PersonId = person.Id;
}
}
rockContext.SaveChanges();
return person;
}
