public async Task <Response> Update(ModelDTO model)
{
Response response = new Response();
ModelValidator validate = new ModelValidator();
ValidationResult result = validate.Validate(model);
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
response.Errors.Add("Property " + failure.PropertyName + " failed validation. Error was: " + "(" + failure.ErrorMessage + ")");
}
return(response);
}
else
{
try
{
return(response = await _iModelRepository.Update(model));
}
catch (Exception ex)
{
_log.Error(ex + "\nStackTrace: " + ex.StackTrace);
response.Errors.Add("DataBase error, contact the system owner");
return(response);
}
}
}
public async Task UpdateAsync(int id, ModelDTO modelDTO)
{
var model = mapper.Map <Model>(modelDTO);
model.Id = id;
await unitOfWork.Models.UpdateAsync(model);
}
public ServiceResult ModelAdd(ModelDTO dto)
{
Model model = new Model();
DTOtoModel(dto, model);
ServiceResult result;
try
{
var user = Singleton.Uow.GetRepository <Model>().Add(model);
if (user == true)
{
result = new ServiceResult("İşlem başarılı", ResultState.Success);
}
else
{
result = new ServiceResult("İşlem başarısız", ResultState.Danger);
}
}
catch (Exception)
{
result = new ServiceResult("Hata gerçekleşti", ResultState.Error);
}
return(result);
}
public frmPrincipal(string linkXML, bool multiProgressBar)
{
//Preencher Model com valores padrão
Model = new ModelDTO();
Model.UrlXML = linkXML;
Model.HashValidacao = ViewMessagesEnum.Padrao_HashValidacao.GetDescription();
Model.TextoBotaoGO = ViewMessagesEnum.Padrao_TextoBotaoGO.GetDescription();
Model.TituloForm = ViewMessagesEnum.Padrao_TituloForm.GetDescription();
//On Download Progress Changed
DownloadProgressChangedEventHandler = DownloadProgressChanged;
//On Download Completed
DownloadFileCompletedEventHandler = DownloadFileCompleted;
InitializeComponent();
//Esconde a progressBarPrincipal se multiProgressBar = false
progressBarPrincipal.Visible = labelProgressPrincipal.Visible = multiProgressBar;
bwInicio = new BackgroundWorker();
bwInicio.DoWork += bwInicio_DoWork;
bwInicio.RunWorkerCompleted += bwInicio_RunWorkerCompleted;
bwBanners = new BackgroundWorker();
bwBanners.DoWork += bwBanners_DoWork;
bwVerificarAtualizacoes = new BackgroundWorker();
bwVerificarAtualizacoes.DoWork += bwVerificaAtualizacoes_DoWork;
}
public void ModelUpdateApplyHelper_MultipleFieldUpdate()
{
var old = new Model();
var initial = JsonSerializer.Serialize(old);
var update = new ModelDTO
{
Flag = true,
};
Assert.NotEqual(update.Flag, old.Flag);
var(changes, description, fields) = ModelUpdateApplyHelper.ApplyUpdateRequestToModel(old, update);
Assert.True(changes);
Assert.NotNull(description);
Assert.NotEmpty(description);
Assert.NotEqual(JsonSerializer.Serialize(old), initial);
Assert.Contains(nameof(Model.SomeField), description);
Assert.DoesNotContain(nameof(Model.Id), description);
Assert.Contains(nameof(Model.Flag), description);
Assert.NotNull(fields);
Assert.Contains(nameof(Model.SomeField), fields);
Assert.DoesNotContain(nameof(Model.Id), fields);
Assert.Contains(nameof(Model.Flag), fields);
Assert.Equal(update.SomeField, old.SomeField);
Assert.Equal(update.Flag, old.Flag);
}
public async Task <ActionResult> Delete(ModelInsertViewModel viewModel)
{
Response response = new Response();
var configuration = new MapperConfiguration(cfg =>
{
cfg.CreateMap <ModelInsertViewModel, ModelDTO>();
});
IMapper mapper = configuration.CreateMapper();
ModelDTO dto = mapper.Map <ModelDTO>(viewModel);
response = await _service.Delete(dto.ID);
//Se funcionou, redireciona pra página inicial
if (response.Success)
{
return(RedirectToAction("Index", "Model"));
}
else
{
ViewBag.ErrorMessage = response.Errors;
return(this.View());
}
}
public async Task <Response> Update(ModelDTO model)
{
Response response = new Response();
try
{
using (var context = _context)
{
context.Models.Update(model);
int nAffectedRows = await context.SaveChangesAsync();
if (nAffectedRows == 1)
{
response.Success = true;
return(response);
}
else
{
response.Errors.Add("Edição não executada");
return(response);
}
}
}
catch (Exception ex)
{
//response.Errors.Add("Erro no banco de dados contate o administrador");
throw ex;
}
}
public IActionResult UpdateModel([FromBody] ModelDTO modelDTO)
{
_logger?.LogInformation($"Inicio del servicio: [PUT] https://localhost:5001/api/models ");
try{
ModelMapper modelMapper = MapperFactory.CreateModelMapper();
Entity entity = modelMapper.CreateEntity(modelDTO);
_logger?.LogInformation($" Se transformó de DTO a Entity ");
UpdateModelCommand command = CommandFactory.CreateUpdateModelCommand((Model)entity);
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
if (command.GetResult())
{
return(Ok("La modificación fue realizada exitosamente"));
}
else
{
return(StatusCode(400));
}
} catch (RequiredAttributeException ex) {
_logger?.LogWarning("Atributo requerido: " + ex.Message);
return(StatusCode(400, ex.Message));
} catch (ModelNotFoundException ex) {
_logger?.LogWarning("Modelo con Id : " + ex.ModelId + "no encontrado");
return(StatusCode(404, ex.Message + ex.ModelId));
} catch (BrandNotFoundException ex) {
_logger?.LogWarning("La marca con Id : " + ex.BrandId + "no encontrado");
return(StatusCode(404, ex.Message + ex.BrandId));
} catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
public IActionResult AddModel([FromBody] ModelDTO modelDTO)
{
_logger?.LogInformation($"Inicio del servicio: [Post] https://localhost:5001/api/models ");
try {
ModelMapper modelMapper = MapperFactory.CreateModelMapper();
Entity model = modelMapper.CreateEntity(modelDTO);
_logger?.LogInformation($" Se transformó de DTO a Entity ");
AddModelCommand command = CommandFactory.CreateAddModelCommand((Model)model);
_logger?.LogInformation($" Ejecución del comando ");
command.Execute();
return(Ok("ok " + command.GetResult()));
} catch (RequiredAttributeException ex) {
_logger?.LogWarning("Atributo requerido: " + ex.Message);
return(StatusCode(400, ex.Message));
} catch (BrandNotFoundException ex) {
_logger?.LogWarning("La marca con Id : " + ex.BrandId + "no encontrado");
return(StatusCode(404, ex.Message + ex.BrandId));
} catch (UniqueAttributeException ex) {
_logger?.LogWarning(ex.Message);
return(StatusCode(500, ex.Message));
} catch (InternalServerErrorException ex) {
_logger?.LogError("Error: " + ex.Ex.Message);
return(StatusCode(500, ex.Message));
} catch (Exception) {
_logger?.LogError("Error inesperado");
return(StatusCode(400));
}
}
private void initBaseData()
{
userNameLabel.Text = dataFormDTO.userData.username;
carViewController = new CarViewController();
modelDTO = new ModelDTO();
crud = new ModelCrud(dataFormDTO.db);
comboBoxData = new ComboBoxDataInit(dataFormDTO.db);
comboBoxData.addCompanies(cbCompany);
comboBoxData.addCarTypes(cbType);
comboBoxData.addColours(cbColour);
comboBoxData.addCarModels(cbModel);
comboBoxData.addCarEngines(cbEngine);
comboBoxData.addCarEngineTypes(cbEngineType);
comboBoxData.addCarTransmissoins(cbTransmission);
cbAutoTrans.Items.AddRange(new string[] { "нет", "да" });
cbAutoTrans.SelectedIndex = 0;
}
public int guardarOIQx(OIQuirurgicaModel orden, List <string> cirugia, List <string> dx
, List <string> equipo, List <SuministroModel> suministro)
{
IOrdenIQxService _service = new OrdenIQxService();
var anexos = ModelDTO.archivosDTO(orden.anexos);
var suministros = suministro ?? new List <SuministroModel>();
return(_service.guardarOrden(ModelDTO.ordenIQx(orden), cirugia, dx, equipo, ModelDTO.SuministroDTO(suministros), anexos));
}
public async Task Update(ModelDTO entity, UserDTO user)
{
if (user.Name == null)
{
return;
}
database.ModelRepository.Update(mapper.Map <Model>(entity));
await database.Save();
}
public ActionResult <ModelVM> AddModel([FromBody] ModelDTO modelDTO)
{
var model = _mapper.Map <Model>(modelDTO);
_modelService.AddModel(model);
_modelService.SaveChanges();
_log.Save(User.Identity.Name, "Dodano model", GetType().Name);
return(Ok());
}
public ActionResult RemoveModel(int id)
{
ModelDTO model = new ModelDTO {
Id = id
};
modelService.DeleteModel(model);
return(RedirectToAction("Models", new RouteValueDictionary(new { controller = "Model", action = "Models", brandId = TempData["BrandId"] })));
}
public void DTOtoModel(ModelDTO dto, Model model)
{
model.Id = Guid.NewGuid();
model.ModelName = dto.ModelName;
model.ModelYear = dto.ModelYear;
model.UpdatedDate = DateTime.Today;
model.UpdatedUser = Session.CurrentUser.Id;
model.CreatedDate = DateTime.Today;
model.CreatedUser = Session.CurrentUser.Id;
model.BrandId = dto.BrandId;
}
public async Task <IActionResult> Create([FromForm] ModelDTO model)
{
userDTO = new UserDTO {
Name = User.Identity.Name
};
if (service.Add(model, userDTO) != null)
{
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> CreateContactAsync([FromBody] ModelDTO model)
{
if (ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await modelService.CreateAsync(model);
return(Ok());
}
public int guardarCarta(CartaGarantiaModel carta, PlanSaludModel plan, PacienteModel paciente, List <string> procedimientos, string usuario, string equipo, ArchivoModel archivo)
{
ICartaGarantiaService cartaserv = new CartaGarantiaService();
var cartaps = ModelDTO.cartaDTO(carta, plan, paciente);
int result = cartaserv.guardarCarta(cartaps, usuario, equipo,
ModelDTO.beneficiosDTO(plan.beneficios)
, procedimientos, ModelDTO.archivoDTO(archivo));
return(result);
}
public void AddModelTests()
{
// Arrange
var modelController = this.CreateModelController();
ModelDTO modelDTO = new ModelDTO();
// Act
var result = modelController.AddModel(modelDTO);
// Assert
Assert.IsInstanceOf <ActionResult <ModelVM> >(result);
}
public async Task <ModelDTO> Add(ModelDTO entity, UserDTO user)
{
if (user.Name == null)
{
return(null);
}
entity.CreatorId = database.EmployeeRepository.GetByName(user.Name);
database.ModelRepository.Add(mapper.Map <Model>(entity));
await database.Save();
return(new ModelDTO {
});
}
public static ModelDTO ChangePathImage(this ModelDTO item)
{
try
{
item.PicturePath = item.PicturePath.Substring(item.PicturePath.IndexOf(@"\Cont"),
item.PicturePath.Length - item.PicturePath.IndexOf(@"\Cont"))
.Replace("\\", "/");
return(item);
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// INSERT
/// </summary>
public void InsertModel(ModelDTO modelDto)
{
var dbContext = new RentAVehicleDB();
Model model = _mapper.Map <Model>(modelDto);
model.Id = Guid.NewGuid();
model.BrandId = model.Brand.Id;
dbContext.Models.Add(model);
dbContext.SaveChanges();
}
public void UpdateModelTests()
{
// Arrange
var modelController = this.CreateModelController();
int id = 0;
ModelDTO modelDTO = new ModelDTO();
// Act
var result = modelController.UpdateModel(modelDTO,
id);
// Assert
Assert.IsInstanceOf <ActionResult>(result);
}
public static Model ToDomain(ModelDTO modelDto)
{
return(new Model()
{
LocationId = modelDto.LocationId,
Identificador = modelDto.Identificador,
Longitude = modelDto.Longitude,
Latitude = modelDto.Latitude,
Altitude = modelDto.Altitude,
Accuracy = modelDto.Accuracy,
Bearing = modelDto.Bearing,
Speed = modelDto.Speed,
Data = modelDto.Data
});
}
public bool VerificaAtualizacoes(IView view, ModelDTO model)
{
bool atualizado = false;
using (var util = new UtilAssembly())
{
var versaoAtual = util.AssemblyVersion;
atualizado = (model.HashValidacao.Equals(versaoAtual));
if (!atualizado)
{
Atualizar(view, model);
}
}
return(atualizado);
}
public async Task <int> guardaFAT(AtencionTmModel fat)
{
return(await Task.Run(() =>
{
IFATService _fatService = new FATService();
var fatDTO = ModelDTO.faTDTO(fat);
int i = _fatService.guardaFAT(fatDTO);
TeleconsultaViewModel tele = new TeleconsultaViewModel();
tele.guardaDiagnostico(fat.dx, fat.idAtencion);
tele.guardaMedicamentos(fat.medicinas, fat.idAtencion);
tele.guardaServicio(fat.laboratorio, fat.idAtencion, "LAB");
tele.guardaServicio(fat.radiologia, fat.idAtencion, "RAD");
return i;
}));
}
public ActionResult UpdateModel([FromBody] ModelDTO modelDTO, int id)
{
var uMark = _modelService.FindById(id);
if (uMark == null)
{
return(NotFound());
}
_mapper.Map(modelDTO, uMark);
_modelService.UpdateModel(uMark);
_modelService.SaveChanges();
_log.Save(User.Identity.Name, "Edytowano model", GetType().Name);
return(Ok());
}
public ActionResult AddModel()
{
ModelDTO dt = new ModelDTO();
using (MOBILESHOPEntities dbcontext = new MOBILESHOPEntities())
{
//Brand
dt.brandList = dbcontext.mb_brand_detail.AsEnumerable().Select(x => new BrandDTO
{
id = x.brand_key,
BrandName = x.brand_name
}).ToList();
};
return(PartialView("AddModel", dt));
}
public ActionResult AddOrUpdateModel(ModelDTO dto)
{
try
{
if (ModelState.IsValid)
{
using (MOBILESHOPEntities dbcontext = new MOBILESHOPEntities())
{
if (dto.id == 0)
{
mb_model_detail mbModel = new mb_model_detail()
{
model_name = dto.modelName,
model_brand_key = dto.Brand
};
dbcontext.mb_model_detail.Add(mbModel);
dbcontext.SaveChanges();
return(Json(new { key = true, value = "model added successfully" }, JsonRequestBehavior.AllowGet));
}
else
{
var model = dbcontext.mb_model_detail.Find(dto.id);
if (model != null)
{
model.model_name = dto.modelName;
model.model_brand_key = dto.Brand;
dbcontext.SaveChanges();
return(Json(new { key = true, value = "Model updated successfully" }, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(new { key = true, value = "Model not found" }, JsonRequestBehavior.AllowGet));
}
}
};
}
else
{
return(Json(new { key = false, value = "Please enter correct data" }, JsonRequestBehavior.AllowGet));
}
}
catch (Exception)
{
return(Json(new { key = false, value = "Unable to save the Model" }, JsonRequestBehavior.AllowGet));
}
}
public List <ModelDTO> CreateModelDTOs()
{
List <ModelDTO> modelDTOList = new List <ModelDTO>();
var models = GetModels();
foreach (Model model in models)
{
ModelDTO modelDTO = new ModelDTO
{
ModelKey = model.ModelKey,
ModelName = model.ModelName
};
modelDTOList.Add(modelDTO);
}
return(modelDTOList);
}
