public TestViewModel(IAssayDataAccess assayDataAccess
, IDisciplineDataAccess disciplineDataAccess
, ISampleTypeDataAccess sampleTypeDataAccess
, IUnitDataAccess unitDataAccess
, IResultDataTypeDataAccess resultDataTypeDataAccess
, IMapper mapper)
{
this.TestList = new BindingList <TestModel>();
DisciplineList = new List <DisciplineModel>();
SampleTypesList = new List <SampleTypeModel>();
UnitList = new List <UnitModel>();
this.SelectedTest = new TestModel();
this.ResultDataTypes = new List <ResultDataTypeModel>();
//this.SelectedDataType = new ResultDataTypeModel();
//InitializeDemoData();
this.PropertyChanged += TestViewModel_PropertyChanged;
this._assayDataAccess = assayDataAccess;
this._disciplineDataAccess = disciplineDataAccess;
this._sampleTypeDataAccess = sampleTypeDataAccess;
this._unitDataAccess = unitDataAccess;
this._resultDataTypeDataAccess = resultDataTypeDataAccess;
this._mapper = mapper;
OnInitialize += TestViewModel_OnInitialize;
OnInitiateTestInsert += TestViewModel_OnInitiateTestInsert;
OnInitiateTestUpdate += TestViewModel_OnInitiateTestUpdate;
OnInitialize?.Invoke(this, EventArgs.Empty);
}
public UnitBusiness(
IUnitDataAccess materialDataAccess,
IMapper mapper,
IValidator <UnitApiModel> validator
)
{
_unitDataAccess = materialDataAccess;
_mapper = mapper;
_validator = validator;
}
public UnitValidation(
IUnitDataAccess unitDataAccess,
IUnitGroupDataAccess unitGroupDataAccess)
{
_unitDataAccess = unitDataAccess;
_unitGroupDataAccess = unitGroupDataAccess;
RuleSet(string.Join(",",
Enum.GetName(typeof(UnitRuleSet), UnitRuleSet.Create),
Enum.GetName(typeof(UnitRuleSet), UnitRuleSet.Update)),
() => {
RuleFor(unit => unit.Title).NotNull().NotEmpty().WithMessage($"{TitleName} do {entityName} não pode estar vazio");
RuleFor(unit => unit.Title).Length(TitleMin, TitleMax).WithMessage($"{TitleName} do {entityName} precisa ter entre {TitleMin} e {TitleMax} caracteres");
RuleFor(unit => unit.Title).Must(TitleNotAlreadyExists).WithMessage($"{TitleName} do {entityName} já existe");
RuleFor(unit => unit.Abbreviation).NotNull().NotEmpty().WithMessage($"{AbbreviationName} do {entityName} não pode estar vazio");
RuleFor(unit => unit.Abbreviation).Length(AbbreviationMin, AbbreviationMax).WithMessage($"{AbbreviationName} do {entityName} precisa ter entre {AbbreviationMin} e {AbbreviationMax} caracteres");
RuleFor(unit => unit.Abbreviation).Must(AbbreviationNotAlreadyExists).WithMessage($"{AbbreviationName} do {entityName} já existe");
RuleFor(unit => unit.IdGroup).GreaterThan(0).WithMessage($"{IdGroupName} do {entityName} não pode estar vazio");
RuleFor(unit => unit.IdGroup).Must(IdGroupAlreadyExists).WithMessage($"{IdGroupName} do {entityName} não existe");
When(unit => unit.ReferenceUnit.HasValue && unit.ReferenceUnit.Value != 0, () =>
{
RuleFor(unit => unit.ReferenceUnit.Value).Must(IdAlreadyExists).WithMessage($"{ReferenceUnitName} do {entityName} não existe");
RuleFor(unit => unit.ReferenceValue).GreaterThan(0).WithMessage($"{ReferenceValueName} do {entityName} tem que ser maior que zero");
}).Otherwise(() =>
{
RuleFor(unit => unit.ReferenceValue).Equal(1).WithMessage($"{ReferenceValueName} do {entityName} precisa ser 1.0 caso não tenha unidade de referência");
});
});
RuleSet(string.Join(",",
Enum.GetName(typeof(UnitRuleSet), UnitRuleSet.Delete),
Enum.GetName(typeof(UnitRuleSet), UnitRuleSet.Update)),
() => {
RuleFor(unit => unit.Id).GreaterThan(0).WithMessage($"{IdName} do {entityName} não pode estar vazio");
RuleFor(unit => unit.Id).Must(IdAlreadyExists).WithMessage($"{IdName} do {entityName} não existe");
});
}
public MaterialValidation(
IUnitDataAccess unitDataAccess,
IMaterialDataAccess materialDataAccess)
{
_unitDataAccess = unitDataAccess;
_materialDataAccess = materialDataAccess;
RuleSet(string.Join(",",
Enum.GetName(typeof(MaterialRuleSet), MaterialRuleSet.Create),
Enum.GetName(typeof(MaterialRuleSet), MaterialRuleSet.Update)),
() => {
RuleFor(material => material.Name).NotNull().NotEmpty().WithMessage($"{NameName} da {entityName} não pode estar vazio");
RuleFor(material => material.Name).Length(NameMin, NameMax).WithMessage($"{NameName} da {entityName} precisa ter entre {NameMin} e {NameMax} caracteres");
When(material => !string.IsNullOrEmpty(material.Brand), () =>
{
RuleFor(material => material.Brand).Length(BrandMin, BrandMax).WithMessage($"{BrandName} da {entityName} precisa ter entre {BrandMin} e {BrandMax} caracteres");
});
RuleFor(material => material.Price).GreaterThan(0).WithMessage($"{PriceName} da {entityName} precisa ser diferente de zero e positivo");
RuleFor(material => material.Quantity).GreaterThan(0).WithMessage($"{QuantityName} da {entityName} precisa ser diferente de zero e positivo");
RuleFor(material => material.IdUnit).GreaterThan(0).WithMessage($"{IdUnitName} da {entityName} não pode estar vazio");
RuleFor(material => material.IdUnit).Must(IdUnitAlreadyExists).WithMessage($"{IdUnitName} da {entityName} não existe");
When(material => !string.IsNullOrEmpty(material.Note), () =>
{
RuleFor(material => material.Brand).Length(NoteMin, NoteMax).WithMessage($"{NoteName} da {entityName} precisa ter entre {BrandMin} e {BrandMax} caracteres");
});
});
RuleSet(string.Join(",",
Enum.GetName(typeof(MaterialRuleSet), MaterialRuleSet.Delete),
Enum.GetName(typeof(MaterialRuleSet), MaterialRuleSet.Update)),
() => {
RuleFor(material => material.Id).GreaterThan(0).WithMessage($"{IdName} da {entityName} não pode estar vazio");
RuleFor(material => material.Id).Must(IdAlreadyExists).WithMessage($"{IdName} da {entityName} não existe");
});
}
