public static Periodo FromViewModel(PeriodoViewModel vm)
{
var periodo = new Periodo();
ViewModelHelper.MapModel(vm, periodo);
return(periodo);
}
public async Task <ActionResult> Create(PeriodoViewModel model)
{
if (ModelState.IsValid)
{
if (await db.Periodo.AnyAsync(p => model.Periodo.FechaIni <= p.FechaFin && model.Periodo.FechaFin >= p.FechaIni))
{
ModelState.AddModelError("", "Date Range is overlaping with other Period.");
}
if (!ModelState.Values.Any(ms => ms.Errors.Count > 0))
{
if (model.Revisiones != null)
{
model.Periodo.PeriodoRevisiones = model.Revisiones;
}
db.Periodo.Add(model.Periodo);
await db.SaveChangesAsync();
AddLog("", model.Periodo.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
}
if (model.Revisiones == null)
{
model.Revisiones = new List <PeriodoRevision>();
}
return(View(model));
}
public async System.Threading.Tasks.Task SaveUpdate()
{
RequestPeriodoSave periodoToBeSave = new RequestPeriodoSave
{
Id = 10993,
Codigo = "C" + DateTime.Now.ToString("ddMMyyHHmmss"),
Descricao = "D_" + DateTime.Now.ToString("ddMMyy HHmmss"),
TopologiaId = 1,
};
HttpResponseMessage response = await _clientCall.Save(_baseController + "Save/", JsonConvert.SerializeObject(periodoToBeSave));
Assert.IsTrue(response.IsSuccessStatusCode);
if (response.IsSuccessStatusCode)
{
var retorno = await response.Content.ReadAsStringAsync();
PeriodoViewModel periodoRetornoJson = JsonConvert.DeserializeObject <PeriodoViewModel>(JObject.Parse(retorno)["data"].ToString());
Periodo periodo = _unitOfw.PeriodoRepository.Get(y => y.Id == periodoToBeSave.Id).FirstOrDefault();
Assert.AreEqual(periodoToBeSave.Id, periodoRetornoJson.Id);
Assert.AreEqual(periodoToBeSave.TopologiaId, periodo.TopologiaId);
Assert.AreEqual(periodoToBeSave.TopologiaId, periodoRetornoJson.TopologiaId);
Assert.AreEqual(periodoToBeSave.Codigo, periodo.Codigo);
Assert.AreEqual(periodoToBeSave.Codigo, periodoRetornoJson.Codigo);
Assert.AreEqual(periodoToBeSave.Descricao, periodo.Descricao);
Assert.AreEqual(periodoToBeSave.Descricao, periodoRetornoJson.Descricao);
}
}
// GET: Periodo/Create
public ActionResult Create()
{
var periodo = new PeriodoViewModel();
periodo.Inicio = DateTime.Today;
return(View(periodo));
}
public IActionResult Post([FromBody] RequestPeriodoSave model)
{
try
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState.GenerateValidation()));
}
if (!model.Id.HasValue || model.Id == 0)
{
List <Periodo> periodoList = _periodoBO.InsertMultiplePeriodos(model.Quantidade, model.Descricao, model.TopologiaId);
List <PeriodoViewModel> retorno = _mapper.Map <List <PeriodoViewModel> >(periodoList);
BaseViewModel <List <PeriodoViewModel> > baseObj = new BaseViewModel <List <PeriodoViewModel> >(retorno, "Periodo Saved Successfully!", "");
return(Ok(baseObj));
}
else
{
if (_unitOfw.PeriodoRepository.Count(y => y.Id == model.Id) == 0)
{
BaseViewModel <string> notFound = new BaseViewModel <string>("Periodo Not Found!", false);
return(NotFound(notFound));
}
if (_unitOfw.PeriodoRepository.Count(y => y.Codigo == model.Codigo && y.TopologiaId == model.TopologiaId && y.Id != model.Id) > 0)
{
BaseViewModel <string> already = new BaseViewModel <string>("Código Already!", false);
return(BadRequest(already));
}
Periodo tobeSave = _unitOfw.PeriodoRepository.Get(y => y.Id == model.Id).FirstOrDefault();
tobeSave.Codigo = model.Codigo;
tobeSave.Descricao = model.Descricao;
bool retorno = _unitOfw.ValoresUpdate((int)model.Id, model.TopologiaId, model.Codigo, tobeSave.TipoEntidadeId);
if (retorno)
{
_unitOfw.PeriodoRepository.Update(tobeSave);
}
PeriodoViewModel saved = _mapper.Map <PeriodoViewModel>(tobeSave);
BaseViewModel <PeriodoViewModel> baseObj = new BaseViewModel <PeriodoViewModel>(saved, "Periodo Saved Successfully!", "");
return(Ok(baseObj));
}
}
catch (Exception ex)
{
BaseViewModel <Exception> msg = new BaseViewModel <Exception>(ex, null, "");
return(BadRequest(msg));
}
}
public async Task <IActionResult> CadastrarPeriodo([FromBody, SwaggerParameter("Informações de cadastro do período.", Required = true)] PeriodoViewModel model)
{
var entrada = new PeriodoEntrada(
base.ObterIdUsuarioClaim(),
model.Nome,
model.DataInicio.Value,
model.DataFim.Value);
return(new ApiResult(await _periodoServico.CadastrarPeriodo(entrada)));
}
public List <PeriodoViewModel> Get()
{
try
{
var periodos = context.Periodos.OrderBy(p => p.Inicio).ToList();
return(PeriodoViewModel.FromPeriodoList(periodos));
}
catch (Exception e)
{
return(new List <PeriodoViewModel>());
}
}
public async Task <IActionResult> AlterarPeriodo(
[FromQuery, SwaggerParameter("ID do período.", Required = true)] int idPeriodo,
[FromBody, SwaggerParameter("Informações para alteração de um período.", Required = true)] PeriodoViewModel model)
{
var entrada = new PeriodoEntrada(
base.ObterIdUsuarioClaim(),
model.Nome,
model.DataInicio.Value,
model.DataFim.Value);
return(new ApiResult(await _periodoServico.AlterarPeriodo(idPeriodo, entrada)));
}
public async Task <ActionResult> Edit(PeriodoViewModel model)
{
if (ModelState.IsValid)
{
if (await db.Periodo.AnyAsync(p => p.Id != model.Periodo.Id && model.Periodo.FechaIni <= p.FechaFin && model.Periodo.FechaFin >= p.FechaIni))
{
ModelState.AddModelError("", "Date Range is overlaping with other Period.");
}
if (!ModelState.Values.Any(ms => ms.Errors.Count > 0))
{
db.Entry(model.Periodo).State = EntityState.Modified;
if (model.Revisiones != null)
{
foreach (var revision in model.Revisiones)
{
revision.PeriodoId = model.Periodo.Id;
if (revision.Id == 0)
{
db.PeriodoRevision.Add(revision);
}
else
{
db.Entry(revision).State = EntityState.Modified;
}
}
}
if (model.RevisionesId != null)
{
var revisionesRemove = await db.PeriodoRevision
.Where(pr => model.RevisionesId.Contains(pr.Id))
.ToListAsync();
db.PeriodoRevision.RemoveRange(revisionesRemove);
}
await db.SaveChangesAsync();
AddLog("", model.Periodo.Id, model);
return(RedirectToAction("Index", GetReturnSearch()));
}
}
if (model.Revisiones == null)
{
model.Revisiones = new List <PeriodoRevision>();
}
return(View(model));
}
public PeriodoViewModel Get(int id)
{
try
{
var p = context.Periodos.First(p => p.Id == id);
return(PeriodoViewModel.FromPeriodo(p));
}
catch (Exception e)
{
return(null);
}
}
public ActionResult Create(PeriodoViewModel vm)
{
try
{
var periodo = Periodo.FromViewModel(vm);
service.Add(periodo);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public ActionResult Edit(int id, PeriodoViewModel vm)
{
var periodo = Periodo.FromViewModel(vm);
try
{
service.Update(id, periodo);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View(periodo));
}
}
public async System.Threading.Tasks.Task Get()
{
HttpResponseMessage response = await _clientCall.Detail(_baseController + "Detail/" + 1);
Assert.IsTrue(response.IsSuccessStatusCode);
var retorno = await response.Content.ReadAsStringAsync();
PeriodoViewModel periodoResponse = JsonConvert.DeserializeObject <PeriodoViewModel>(JObject.Parse(retorno)["data"].ToString());
Periodo periodoFromDataBase = _unitOfw.PeriodoRepository.Get(y => y.Id == periodoResponse.Id).FirstOrDefault();
Assert.AreEqual(periodoResponse.Id, periodoFromDataBase.Id);
Assert.AreEqual(periodoResponse.Descricao, periodoFromDataBase.Descricao);
Assert.AreEqual(periodoResponse.Codigo, periodoFromDataBase.Codigo);
Assert.AreEqual(periodoResponse.TopologiaId, periodoFromDataBase.TopologiaId);
}
public PeriodoViewModel Add(Periodo periodo)
{
if (periodo.Fin != null)
{
if (periodo.Fin <= periodo.Inicio)
{
throw new Exception("La fecha de fin debe ser posterior a la fecha de inicio.");
}
periodo.ProximaFechaPosible = ((DateTime)periodo.Fin).AddDays(21);
periodo.Duracion = Convert.ToInt32(((DateTime)periodo.Fin).Subtract(periodo.Inicio).TotalDays + 1);
}
context.Periodos.Add(periodo);
context.SaveChanges();
var periodoViewModel = PeriodoViewModel.FromPeriodo(periodo);
return(periodoViewModel);
}
public async Task <IActionResult> Create([Bind("Id,NomePeriodo")] PeriodoViewModel periodoViewModel)
{
if (!ModelState.IsValid)
{
return(View(periodoViewModel));
}
var periodo = _mapper.Map <Periodo>(periodoViewModel);
await _periodoService.Adicionar(periodo);
if (!OperacaoValida())
{
return(View(periodoViewModel));
}
return(RedirectToAction("Index"));
}
public IHttpActionResult Post(PeriodoViewModel periodo)
{
if (ModelState.IsValid)
{
try
{
var periodoModel = Mapper.Map <Periodo>(periodo);
periodoLogic.AddPeriodo(periodoModel);
return(Ok(PeriodoSucceedMessages.RegistroPeriodoExitoso));
}catch (InvalidOperationException e)
{
return(BadRequest(e.Message));
}
}
else
{
return(BadRequest(ControllerRequestErrorMessages.InvalidRequestInformation));
}
}
public IActionResult Get(int id)
{
try
{
PeriodoViewModel retorno = _mapper.Map <PeriodoViewModel>(_unitOfw.PeriodoRepository.Get(y => y.Id == id).FirstOrDefault());
if (retorno == null)
{
BaseViewModel <string> notFound = new BaseViewModel <string>("Periodo Not Found!");
return(NotFound(notFound));
}
BaseViewModel <PeriodoViewModel> baseObj = new BaseViewModel <PeriodoViewModel>(retorno, "Periodo Retrieved Successfully!", "");
return(Ok(baseObj));
}
catch (Exception ex)
{
throw;
}
}
public PeriodoViewModel Update(int id, Periodo nuevoPeriodo)
{
var periodoViewModel = new PeriodoViewModel();
if (context.Periodos.Any(p => p.Id == id))
{
if (nuevoPeriodo.Fin != null)
{
if (nuevoPeriodo.Fin <= nuevoPeriodo.Inicio)
{
throw new Exception("La fecha de fin debe ser posterior a la fecha de inicio.");
}
nuevoPeriodo.ProximaFechaPosible = ((DateTime)nuevoPeriodo.Fin).AddDays(21);
nuevoPeriodo.Duracion = Convert.ToInt32(((DateTime)nuevoPeriodo.Fin).Subtract(nuevoPeriodo.Inicio).TotalDays + 1);
}
context.Periodos.Update(nuevoPeriodo);
context.SaveChanges();
periodoViewModel = PeriodoViewModel.FromPeriodo(nuevoPeriodo);
}
return(periodoViewModel);
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,NomePeriodo")] PeriodoViewModel periodoViewModel)
{
if (id != periodoViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(periodoViewModel));
}
var periodo = _mapper.Map <Periodo>(periodoViewModel);
await _periodoService.Atualizar(periodo);
if (!OperacaoValida())
{
return(View(periodoViewModel));
}
return(RedirectToAction("Index"));
}
