public void Infant_agecategory_return_correct_minimum_and_maximum_ages()
{
var sut = new AgeCategory(AgeCategoryEnum.Infant);
Assert.AreEqual(0, sut.MinimumAge);
Assert.AreEqual(0, sut.MaximumAge);
}
public IActionResult PutCategory(int id, [FromBody] AgeCategory cate)
{
if (id != cate.AgeCatId)
{
return(BadRequest());
}
try
{
_database.Entry(cate).State = EntityState.Modified;
_database.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!AgecatExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(new JsonResult(new { message = "Updated" }));
}
public void Child_agecategory_return_correct_minimum_and_maximum_ages()
{
var sut = new AgeCategory(AgeCategoryEnum.Child);
Assert.AreEqual(5, sut.MinimumAge);
Assert.AreEqual(15, sut.MaximumAge);
}
public void Adult_agecategory_return_correct_minimum_and_maximum_ages()
{
var sut = new AgeCategory(AgeCategoryEnum.Adult);
Assert.AreEqual(16, sut.MinimumAge);
Assert.AreEqual(119, sut.MaximumAge);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AgeCategoryName")] AgeCategory ageCategory)
{
if (id != ageCategory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ageCategory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AgeCategoryExists(ageCategory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ageCategory));
}
public void Toddler_agecategory_return_correct_minimum_and_maximum_ages()
{
var sut = new AgeCategory(AgeCategoryEnum.Toddler);
Assert.AreEqual(1, sut.MinimumAge);
Assert.AreEqual(4, sut.MaximumAge);
}
public void Post([FromBody] AgeCategory value)
{
//if(value!=null)
//{
// kvestroom.
//}
}
public async Task <ActionResult <AgeCategory> > PostAgeCategory(AgeCategory ageCategory)
{
_context.AgeCategories.Add(ageCategory);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAgeCategory", new { id = ageCategory.AgeCategoryID }, ageCategory));
}
public async Task <IActionResult> PutAgeCategory(int id, AgeCategory ageCategory)
{
if (id != ageCategory.AgeCategoryID)
{
return(BadRequest());
}
_context.Entry(ageCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AgeCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void SetUp()
{
rooms = new List <KvestRoom>
{
new KvestRoom()
{
Id = 1, Name = "GamePlay", AgeCategoryId = 3, PriceForOneUser = 300, UsersValueId = 2,
},
new KvestRoom()
{
Id = 2, Name = "Play", AgeCategoryId = 2, PriceForOneUser = 500, UsersValueId = 3,
},
new KvestRoom()
{
Id = 3, Name = "Game", AgeCategoryId = 1, PriceForOneUser = 200, UsersValueId = 2,
},
new KvestRoom()
{
Id = 4, Name = "GP", AgeCategoryId = 5, PriceForOneUser = 300, UsersValueId = 1,
}
};
ages = new List <AgeCategory>
{
new AgeCategory()
{
Id = 1, max = 2, min = 1
},
new AgeCategory()
{
Id = 2, max = 3, min = 2
},
new AgeCategory()
{
Id = 3, max = 4, min = 3
}
};
users = new List <UsersValue>
{
new UsersValue()
{
ID = 1, min = 1, max = 2
},
new UsersValue()
{
ID = 2, min = 2, max = 3
},
new UsersValue()
{
ID = 3, min = 3, max = 4
}
};
age = new AgeCategory()
{
Id = 1, max = 5, min = 4
};
user = new UsersValue()
{
ID = 2, max = 6, min = 2
};
}
public override string ToString()
{
return($@"
{Title}
{PriceToRubles} рублей
{Url}
{AgeCategory.GetDisplayName()}
{Recipient.GetDisplayName()}");
}
private Dictionary <String, String> MapObject(AgeCategory item)
{
Dictionary <String, String> mappedObject = new Dictionary <string, string>();
mappedObject.Add("categoryName", item.Name);
mappedObject.Add("minAge", item.MinAge.ToString());
mappedObject.Add("maxAge", item.MaxAge.ToString());
return(mappedObject);
}
public void UpdateAgeCategory(String ageCategoryName, String minAge, String maxAge)
{
Int32 minAgeArgument = Converter.ConvertToInt32(minAge);
Int32 maxAgeArgument = Converter.ConvertToInt32(maxAge);
AgeCategory ageCategory = new AgeCategory(ageCategoryName, minAgeArgument, maxAgeArgument);
_validator.Validate(ageCategory);
_repository.UpdateItem(ageCategory);
}
public async Task <ActionResult> Search(string q, string gender, int age)
{
var ageGroup = new AgeCategory(age);
var url = _configuration.GetBusinessApiPathwaySearchUrl(gender, ageGroup.Value);
var response = await _restClientBusinessApi.ExecuteAsync <List <SearchResultViewModel> >(new RestRequest(url, Method.GET)).ConfigureAwait(false);
return(View(new SearchJourneyViewModel {
Results = response.Data
}));
}
public async Task <JsonResult> PathwaySearch(string gender, int age, string searchTerm)
{
var ageGroup = new AgeCategory(age);
var response =
await
_restClientBusinessApi.ExecuteTaskAsync(
new RestRequest(_configuration.GetBusinessApiPathwaySearchUrl(gender, ageGroup.Value, true),
Method.GET));
return(Json(response.Content));
}
public async Task <ActionResult> Search(string q, string gender, int age)
{
var ageGroup = new AgeCategory(age);
var response = await _restfulHelper.GetAsync(_configuration.GetBusinessApiPathwaySearchUrl(gender, ageGroup.Value));
var results = JsonConvert.DeserializeObject <List <SearchResultViewModel> >(response);
return(View(new SearchJourneyViewModel {
Results = results
}));
}
public async Task <IActionResult> Create([Bind("Id,AgeCategoryName")] AgeCategory ageCategory)
{
if (ModelState.IsValid)
{
_context.Add(ageCategory);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(ageCategory));
}
private static IDictionary <string, string> BuildState(string gender, int age, IDictionary <string, string> state)
{
var ageCategory = new AgeCategory(age);
state.Add("PATIENT_AGE", age.ToString());
state.Add("PATIENT_GENDER", string.Format("\"{0}\"", gender.First().ToString().ToUpper()));
state.Add("PATIENT_PARTY", "1");
state.Add("PATIENT_AGEGROUP", ageCategory.Value);
return(state);
}
public void Ctor_WithEnum_CreatesValidObject()
{
var sut = new AgeCategory(AgeCategoryEnum.Infant);
Assert.AreEqual("Infant", sut.Value);
sut = new AgeCategory(AgeCategoryEnum.Toddler);
Assert.AreEqual("Toddler", sut.Value);
sut = new AgeCategory(AgeCategoryEnum.Child);
Assert.AreEqual("Child", sut.Value);
sut = new AgeCategory(AgeCategoryEnum.Adult);
Assert.AreEqual("Adult", sut.Value);
}
private async Task <IEnumerable <string> > GetCovidPathways(string gender, AgeCategory ageGroup)
{
var requestPath = _configuration.GetBusinessApiGuidedPathwaySearchUrl(gender, ageGroup.Value, true);
var request = new RestRequest(requestPath, Method.POST);
request.AddJsonBody(new { query = Uri.EscapeDataString(SearchReservedCovidTerms.SearchTerms.First()) });
var response = await _restClient.ExecuteAsync <List <GuidedSearchResultViewModel> >(request).ConfigureAwait(false);
CheckResponse(response);
return(response.Data.Select(p => p.PathwayNo));
}
public void Ctor_WithValidInt_CreatsValidObject()
{
var sut = new AgeCategory(0);
Assert.AreEqual("Infant", sut.Value);
sut = new AgeCategory(1);
Assert.AreEqual("Toddler", sut.Value);
sut = new AgeCategory(5);
Assert.AreEqual("Child", sut.Value);
sut = new AgeCategory(16);
Assert.AreEqual("Adult", sut.Value);
}
public async Task<IActionResult> UpdateAgeCategory([FromBody] AgeCategory ageCategory)
{
try
{
var userId = User.Identity.Name;
ageCategory = await _organizerService.UpdateAgeCategoryAsync(ageCategory, userId);
return Ok(ageCategory);
}
catch(Exception ex)
{
return BadRequest(ex.Message);
}
}
private Participant Converter(IDataReader dataReader)
{
var name = dataReader.GetString(0);
var age = dataReader.GetInt32(1);
var idAgeCategory = dataReader.GetString(2);
var minAge = dataReader.GetInt32(3);
var maxAge = dataReader.GetInt32(4);
var ageCategory = new AgeCategory(idAgeCategory, minAge, maxAge);
return(new Participant(name, age, ageCategory));
}
public async Task <AgeCategory> AddAgeCategoryAsync(AgeCategory ageCategory, string userId)
{
var group = await GetAgeCategoryGroupAsync(ageCategory.AgeCategoryGroupId, userId);
if (group != null)
{
_context.Add(ageCategory);
await _context.SaveChangesAsync();
return(ageCategory);
}
throw new Exception("Could not add a category");//this should never happen
}
private Category GetCategory(AgeCategory ageCategory, List <IDataAgeDistribution> distributions)
{
Category category = new Category
{
Name = GetAgeCategoryName(ageCategory),
RgbColor = _ageCategoryColors[ageCategory]
};
for (int i = 0; i < distributions.Count; ++i)
{
category.Percents.Add(((double)distributions[i].TransactionCounts[ageCategory] / _sums[i]) * 100);
}
return(category);
}
public List <Participant> GetParticipantsForTrial(string trialName, AgeCategory ageCategory)
{
String query = "SELECT e.participantName, p.age, p.ageCategoryName, a.minAge, a.maxAge " +
"FROM entries e INNER JOIN participants p ON e.participantName=p.name INNER JOIN " +
"agecategories a ON p.ageCategoryName=a.categoryName " +
"WHERE e.trialName=@trialName AND p.ageCategoryName=@ageCategoryName";
Dictionary <String, String> arguments = new Dictionary <string, string>
{
{ "trialName", trialName },
{ "ageCategoryName", ageCategory.Name }
};
return(QueryBuilder.ExecuteReader <Participant>(query, arguments, ConverterParticipant));
}
public async Task <AgeCategory> UpdateAgeCategoryAsync(AgeCategory category, string userId)
{
var existing = await GetAgeCategoryAsync(category.Id, userId);//this is more for cheking that category is for this user
if (existing != null)
{
existing.Name = category.Name;
existing.MinAge = category.MinAge;
existing.MaxAge = category.MaxAge;
_context.Update(existing);
await _context.SaveChangesAsync();
}
return(existing);
}
public void AddItem(AgeCategory item)
{
if (ExistsItem(item.Name))
{
throw new RepositoryExceptionDuplicateEntry("Duplicate Entry for AgeCategory!\n");
}
Dictionary <String, String> mappedObject = MapObject(item);
String addQuery = QueryBuilder.CreateInsertQuery(TableName, mappedObject);
Int32 affectedRows = QueryBuilder.ExecuteNonQuery(addQuery, mappedObject);
if (affectedRows.Equals(0))
{
throw new RepositoryException("No age category inserted!\n");
}
}
public static IDictionary <string, string> BuildState(string gender, int age, IDictionary <string, string> state)
{
AgeCategory ageCategory = new AgeCategory(age);
Normalise(state);
if (!state.ContainsKey("PATIENT_AGE"))
{
state.Add("PATIENT_AGE", age.ToString());
}
state.Add("PATIENT_GENDER", string.Format("\"{0}\"", gender.First().ToString().ToUpper()));
state.Add("PATIENT_PARTY", "1");
state.Add("PATIENT_AGEGROUP", ageCategory.Value);
return(state);
}
public void UpdateItem(AgeCategory updatedItem)
{
if (!ExistsItem(updatedItem.Name))
{
throw new RepositoryException("No age category found!\n");
}
Dictionary <String, String> mappedId = MapId(updatedItem.Name);
Dictionary <String, String> mappedObject = MapObject(updatedItem);
String updateQuery = QueryBuilder.CreateUpdateQuery(TableName, mappedId, mappedObject);
Int32 affectedRows = QueryBuilder.ExecuteNonQuery(updateQuery, mappedId);
if (affectedRows.Equals(0))
{
throw new RepositoryException("No age category updated!\n");
}
}
