public static DiluicaoAmostra Map(DiluicaoAmostra diluicaoAmostra, DilutionSampleDto dilutionSampleDto)
{
diluicaoAmostra.Id = dilutionSampleDto.Id;
diluicaoAmostra.Homogeneizador = dilutionSampleDto.Homogenizer;
diluicaoAmostra.Micropipeta = dilutionSampleDto.Micropipette;
diluicaoAmostra.Pipeta = dilutionSampleDto.Pipette;
diluicaoAmostra.Agitador = dilutionSampleDto.Shaker;
diluicaoAmostra.Placa = dilutionSampleDto.Board;
diluicaoAmostra.Outros = dilutionSampleDto.Others;
diluicaoAmostra.AguaDiluicaos = new List <AguaDiluicao>();
diluicaoAmostra.Ponteiras = new List <Ponteira>();
diluicaoAmostra.Local = (int)dilutionSampleDto.Location.Code;
foreach (var x in dilutionSampleDto.Points)
{
var ponteira = new Ponteira();
ponteira.Codigo = (int)x.Code;
ponteira.Valor = x.Value;
diluicaoAmostra.Ponteiras.Add(ponteira);
}
foreach (var x in dilutionSampleDto.WaterDilutions)
{
var aguadiluicao = new AguaDiluicao();
aguadiluicao.Codigo = (int)x.Code;
aguadiluicao.Valor = x.Value;
diluicaoAmostra.AguaDiluicaos.Add(aguadiluicao);
}
return(diluicaoAmostra);
}
public async Task <IList <DilutionSampleDto> > Execute(int?sampleId)
{
IList <DiluicaoAmostra> diluicaoAmostras = new List <DiluicaoAmostra>();
IList <DilutionSampleDto> sampleDtos = new List <DilutionSampleDto>();
if (sampleId > 0)
{
DiluicaoAmostra diluicaoAmostra = await _diluicaoAmostraRepository.GetByID((int)sampleId);
if (diluicaoAmostra != null)
{
diluicaoAmostras.Add(diluicaoAmostra);
}
}
else
{
diluicaoAmostras = await _diluicaoAmostraRepository.Get();
}
if (diluicaoAmostras.Count() == 0)
{
throw new AppError("Não foi encontrado nenhum cliente.", 404);
}
foreach (DiluicaoAmostra x in diluicaoAmostras)
{
sampleDtos.Add(DiluicaoAmostraMapToDilutionSampleDto.Map(new DilutionSampleDto(), x));
}
return(sampleDtos.OrderBy(s => s.Id).ToList());
}
public static DilutionSampleDto Map(DilutionSampleDto dilutionSampleDto, DiluicaoAmostra diluicaoAmostra)
{
dilutionSampleDto.Id = diluicaoAmostra.Id;
dilutionSampleDto.Homogenizer = diluicaoAmostra.Homogeneizador;
dilutionSampleDto.Micropipette = diluicaoAmostra.Micropipeta;
dilutionSampleDto.Pipette = diluicaoAmostra.Pipeta;
dilutionSampleDto.Shaker = diluicaoAmostra.Agitador;
dilutionSampleDto.Board = diluicaoAmostra.Placa;
dilutionSampleDto.Others = diluicaoAmostra.Outros;
dilutionSampleDto.WaterDilutions = new List <WaterDilutionDto>();
dilutionSampleDto.Points = new List <PointDto>();
dilutionSampleDto.Sample = AmostraMapToSampleDto.Map(new SampleDto(), diluicaoAmostra.fkAmostra);
foreach (var x in diluicaoAmostra.Ponteiras)
{
var point = new PointDto((EnumPoints)x.Codigo);
point.Value = (int)x.Valor;
dilutionSampleDto.Points.Add(point);
}
foreach (var x in diluicaoAmostra.AguaDiluicaos)
{
var waterDilution = new WaterDilutionDto((EnumWaterDilution)x.Codigo);
waterDilution.Value = (int)x.Valor;
dilutionSampleDto.WaterDilutions.Add(waterDilution);
}
return(dilutionSampleDto);
}
public async Task <DilutionSampleDto> Execute(DilutionSampleDto dilutionSampleDto)
{
DiluicaoAmostra diluicaoAmostra = DilutionSampleDtoMapToDiluicaoAmostra.Map(new DiluicaoAmostra(), dilutionSampleDto);
if (diluicaoAmostra == null)
{
throw new AppError("Informe uma solicitação válida.");
}
_diluicaoAmostraRepository.Save(diluicaoAmostra);
await _diluicaoAmostraRepository.Commit();
return(dilutionSampleDto);
}
public async Task <IList <AssayDto> > Execute(int sampleDilutionId)
{
IList <AssayDto> assayDtos = new List <AssayDto>();
DiluicaoAmostra diluicaoAmostra = new DiluicaoAmostra();
diluicaoAmostra = await _diluicaoAmostraRepository.GetByID((int)sampleDilutionId);
if (diluicaoAmostra == null)
{
throw new AppError("Não foi encontrada nenhuma Diluição para essa amostra.", 404);
}
foreach (EnsaiosPorAmostra x in diluicaoAmostra.fkAmostra.EnsaiosPorAmostras)
{
AssayDto assay = EnsaioMapToAssayDto.Map(new AssayDto(), x.fkEnsaio);
assay.sample = AmostraMapToSampleDto.Map(new SampleDto(), diluicaoAmostra.fkAmostra);
assayDtos.Add(assay);
}
return(assayDtos.OrderBy(assay => assay.Description).ToList());
}
public async Task <IList <ExperimentDto> > Execute(int?experimentId, int?sampleDilutionId)
{
IList <Experimento> experiments = new List <Experimento>();
IList <ExperimentDto> experimentDtos = new List <ExperimentDto>();
DiluicaoAmostra diluicaoAmostra = new DiluicaoAmostra();
if (sampleDilutionId > 0)
{
diluicaoAmostra = await _diluicaoAmostraRepository.GetByID((int)sampleDilutionId);
experiments = await _experimentoRepository.Get(x => x.fkDiluicaoAmostraId == diluicaoAmostra.Id);
foreach (Experimento x in experiments)
{
experimentDtos.Add(ExperimentoMapToExperimentDto.Map(new ExperimentDto(), x));
}
return(experimentDtos);
}
if (experimentId > 0)
{
Experimento experiment = await _experimentoRepository.GetByID((int)experimentId);
if (experiment != null)
{
experiments.Add(experiment);
}
}
else
{
experiments = await _experimentoRepository.Get();
}
foreach (Experimento x in experiments)
{
experimentDtos.Add(ExperimentoMapToExperimentDto.Map(new ExperimentDto(), x));
}
return(experimentDtos.OrderBy(e => e.Id).ToList());
}
public async Task <DilutionSampleDto> Execute(DilutionSampleDto dilutionSampleDto, int?sampleId)
{
if (sampleId <= 0)
{
throw new AppError("Informe uma solicitação válida.");
}
Amostra amostra = await _AmostraRepository.GetByID((int)sampleId);
if (amostra == null)
{
throw new AppError("Informe uma solicitação válida.");
}
DiluicaoAmostra diluicaoAmostra = DilutionSampleDtoMapToDiluicaoAmostra.Map(new DiluicaoAmostra(), dilutionSampleDto);
diluicaoAmostra.fkAmostra = amostra;
diluicaoAmostra.fkAmostraId = amostra.Id;
_DiluicaoAmostraRepository.Insert(diluicaoAmostra);
await _DiluicaoAmostraRepository.Commit();
dilutionSampleDto.Id = diluicaoAmostra.Id;
return(dilutionSampleDto);
}
public async Task <ExperimentDto> Execute(ExperimentDto experimentDto, int?dilutionSampleId)
{
if (dilutionSampleId <= 0)
{
throw new AppError("Informe uma diluição válida.");
}
DiluicaoAmostra dilutionSample = await _dilutionSampleRepository.GetByID((int)dilutionSampleId);
if (dilutionSample == null)
{
throw new AppError("Informe uma diluição válida.");
}
Experimento experimento = ExperimentDtoMapToExperimento.Map(new Experimento(), experimentDto);
experimento.fkDiluicaoAmostra = dilutionSample;
experimento.fkDiluicaoAmostraId = dilutionSample.Id;
_experimentoRepository.Insert(experimento);
await _experimentoRepository.Commit();
return(experimentDto);
}
