private async void NewCriteriaValidatedInModal(object sender, CustomEventArgs e)
{
try
{
HomeRankerService.InsertCriteria(e.Criteria);
var newCriteria = new CriteriaViewModel
{
Criteria = e.Criteria
};
var existingIndex = Criterias.IndexOf(newCriteria);
if (existingIndex != -1)
{
newCriteria.RateValue = Criterias[existingIndex].RateValue;
Criterias[existingIndex] = newCriteria;
}
else
{
Criterias.Add(newCriteria);
}
Criterias.Sort();
}
catch (Exception ex)
{
await Shell.Current.DisplayAlert("Error", ex.Message, "Ok");
}
finally
{
AddCriteriaModalPage.CriteriaValidated -= this.NewCriteriaValidatedInModal;
}
}
/// <summary>
/// Validate information value in criteria logic.
/// </summary>
/// <param name="model">The criteria information value.</param>
/// <returns></returns>
public ResultViewModel ValidateData(CriteriaViewModel model)
{
var result = new ResultViewModel();
if (model.CriteriaGroups.Count == 0)
{
result = UtilityService.InitialResultError(MessageValue.CriteriaKpiGroupEmpty, (int)HttpStatusCode.BadRequest);
return(result);
}
int totalScore = model.CriteriaGroups.Sum(x => x.MaxScore);
if (totalScore != 100)
{
result = UtilityService.InitialResultError(MessageValue.CriteriaOverScore, (int)HttpStatusCode.BadRequest);
return(result);
}
foreach (var item in model.CriteriaGroups)
{
if (item.CriteriaItems.Count > 0)
{
int scoreGroup = item.CriteriaItems.Sum(x => x.MaxScore);
if (scoreGroup > item.MaxScore || scoreGroup < item.MaxScore)
{
result = UtilityService.InitialResultError(MessageValue.CriteriaItemScoreGreatethanScoreGroup,
(int)HttpStatusCode.BadRequest);
break;
}
}
}
return(result);
}
public async Task SearchCars_ShouldReturnCarsAccordingCriteria(bool radio, bool cond, CarType type, int expected)
{
// Arrange
var ctx = Container.Resolve <IDbContext>();
await ctx.Database.EnsureDeletedAsync();
var cars = new List <Car> {
new Sedan(true, true), new Sedan(true, false), new Sedan(false, true), new Sedan(false, false),
new Sport(true, true), new Sport(true, false), new Sport(false, true), new Sport(false, false),
new Van(true, true), new Van(true, false), new Van(false, true), new Van(false, false)
};
ctx.Cars.AddRange(cars);
await ctx.SaveChangesAsync();
var filter = new CriteriaViewModel {
Radio = radio, Conditioning = cond, Type = type, PriceFrom = null, PriceTo = null
};
// Act
var results = await Container.Resolve <ISearchCarService>().SearchCarsAsync(filter);
// Assert
Assert.AreEqual(expected, results.Count());
}
public async Task <IEnumerable <HotelViewModel> > GetHotels(CriteriaViewModel criteriaViewModel)
{
var criteria = Mapper.Map <CriteriaViewModel, Criteria>(criteriaViewModel);
criteria.SearchRooms = new List <SearchRoom> {
Mapper.Map <CriteriaViewModel, SearchRoom>(criteriaViewModel)
};
return(Mapper.Map <IEnumerable <Hotel>, IEnumerable <HotelViewModel> >(await _cangoorooBookingService.GetHotels(criteria)));
}
public void Init()
{
Load <Estimator>();
Load <CriteriaGroup>();
Load <Criterion>();
crit = new CriteriaViewModel();
}
/// <summary>
/// Set other default false when update this criteria is true.
/// </summary>
/// <param name="isDefault"></param>
private void SetIsDefault(CriteriaViewModel model)
{
if (model.IsDefault)
{
var data = _unitOfWork.GetRepository <Criteria>().GetCache(x => x.CreateByPurchaseOrg == _token.PurchasingOrg[0] &&
x.IsDefault != null && x.IsDefault.Value).FirstOrDefault();
if (data != null && data.Id != model.Id)
{
data.IsDefault = false;
_unitOfWork.GetRepository <Criteria>().Update(data);
}
}
}
/// <summary>
/// Get Max total score calculate for a2 type.
/// </summary>
/// <param name="weightingKey">The weighting key.</param>
/// <param name="levelPoint">The maximun level point.</param>
/// <param name="criteria">The criteria and maxscore.</param>
/// <returns></returns>
private int GetMaxTotalScore(string weightingKey, int levelPoint, CriteriaViewModel criteria)
{
int result = 0;
if (string.Equals(weightingKey, "A2", StringComparison.OrdinalIgnoreCase))
{
foreach (var item in criteria.CriteriaGroups)
{
result = result + (item.MaxScore * levelPoint);
}
}
return(result);
}
public IActionResult Save([FromBody] CriteriaViewModel model)
{
var response = _criteria.ValidateData(model);
if (response.IsError)
{
return(BadRequest(response));
}
else
{
return(Ok(_criteria.Save(model)));
}
}
public async Task <IEnumerable <HotelViewModel> > GetRamdomHotels(int quantity)
{
var criteria = new CriteriaViewModel
{
DestinationId = 1010106,
NumNights = 2,
CheckinDate = DateTime.Now.AddDays(10).ToString("yyyy-MM-dd"),
NumAdults = 1,
ChildAges = new int[] { 5 },
Quantity = 1
};
return(await GetHotels(criteria));
}
public async Task <IEnumerable <RoomViewModel> > GetRooms(CriteriaViewModel criteriaViewModel)
{
var hotels = await GetHotels(criteriaViewModel);
var rooms = new List <RoomViewModel>();
foreach (var hotel in hotels)
{
foreach (var room in hotel.Rooms)
{
rooms.Add(room);
}
}
return(rooms.OrderBy(r => r.SellingPricePerRoom.Value).ToList());
}
/// <summary>
/// Insert new criteria group.
/// </summary>
/// <param name="model">The criteria information value.</param>
/// <returns></returns>
public ResultViewModel Save(CriteriaViewModel model)
{
var result = new ResultViewModel();
using (TransactionScope scope = new TransactionScope())
{
var criteria = _mapper.Map <CriteriaViewModel, Criteria>(model);
this.SetIsDefault(model);
criteria.CreateBy = _token.EmpNo;
criteria.CreateDate = DateTime.Now;
criteria.CreateByPurchaseOrg = _token.PurchasingOrg[0];
_unitOfWork.GetRepository <Criteria>().Add(criteria);
_unitOfWork.Complete();
this.SaveCriteriaGroup(criteria.Id, model.CriteriaGroups);
_unitOfWork.Complete(scope);
}
this.ReloadCacheCriteria();
return(result);
}
/// <summary>
/// Update grade group.
/// </summary>
/// <param name="model">The grade information value.</param>
/// <returns></returns>
public ResultViewModel Edit(CriteriaViewModel model)
{
var result = new ResultViewModel();
using (TransactionScope scope = new TransactionScope())
{
this.SetIsDefault(model);
var criteria = _unitOfWork.GetRepository <Criteria>().GetCache(x => x.Id == model.Id).FirstOrDefault();
criteria.CriteriaName = model.CriteriaName;
criteria.IsDefault = model.IsDefault;
criteria.LastModifyBy = _token.EmpNo;
criteria.LastModifyDate = DateTime.Now;
_unitOfWork.GetRepository <Criteria>().Update(criteria);
this.EditCriteriaGroup(criteria.Id, model.CriteriaGroups);
_unitOfWork.Complete(scope);
}
this.ReloadCacheCriteria();
return(result);
}
public void Should_Success_Instantiate()
{
var score = new Score();
CriteriaViewModel viewModel = new CriteriaViewModel()
{
Id = 1,
Code = "Code",
Group = "Group",
Index = 1,
Name = "Name",
Score = score
};
Assert.Equal(1, viewModel.Id);
Assert.Equal("Code", viewModel.Code);
Assert.Equal("Group", viewModel.Group);
Assert.Equal("Name", viewModel.Name);
Assert.Equal(1, viewModel.Index);
Assert.Equal(score, viewModel.Score);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Q))
{
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
CriteriaViewModel _CriteriaViewModel = new CriteriaViewModel()
{
Id = "0"
};
Debug.Log("_CriteriaViewModel------- " + _CriteriaViewModel.Id);
DataManager.Instance.OnSetCurCriteriaModel(_CriteriaViewModel);
MachineView.SetActive(true);
_IMachineList.OnReFreshList();
ScanningView.SetActive(false);
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
}
}
public IActionResult Edit([FromBody] CriteriaViewModel model)
{
IActionResult response;
if (_criteria.IsUse(model.Id))
{
response = BadRequest(UtilityService.InitialResultError(string.Format(MessageValue.IsUseMessageFormat, MessageValue.CriteriaMessage),
(int)System.Net.HttpStatusCode.BadRequest));
}
else
{
var validate = _criteria.ValidateData(model);
if (validate.IsError)
{
response = BadRequest(validate);
}
else
{
response = Ok(_criteria.Edit(model));
}
}
return(response);
}
public void OnSetCurCriteriaModel(CriteriaViewModel _CurCriteriaModel)
{
CurDataSelectState.CurCriteriaModel = _CurCriteriaModel;
CurDataSelectState.CriteriaId = _CurCriteriaModel.Id;
}
public async Task <ActionResult> Index(CriteriaViewModel criteriaViewModel)
{
var rooms = await _cangoorooBookingAppService.GetRooms(criteriaViewModel);
return(View(rooms.Take(16)));
}
