private async Task <AutorDTO> getAutorDTO(string numeA, string prenumeA)
{
Service1Client pc = new Service1Client();
AutorDTO autor = await pc.getAutorDTOAsync(numeA, prenumeA);
if (autor == null)
{
return(null);
}
return(autor);
}
public async Task <ActionResult> Put(int id, [FromBody] AutorDTO autorDTO)
{
var autor = mapper.Map <Autor>(autorDTO);
autorDTO.Id = id;
context.Entry(autorDTO).State = EntityState.Modified;
await context.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult <AutorDTO> > Get(int id)
{
var autor = await context.Autores.FirstOrDefaultAsync(x => x.Id == id);
if (autor == null)
{
return(NotFound());
}
AutorDTO autorDTO = mapper.Map <AutorDTO>(autor);
return(autorDTO);
}
private AutorDTO CreateLinksForAuthor(AutorDTO autor)
{
IEnumerable <Buch> buecher = _repository.GetBuchIDsVonAutor(autor.ID);
foreach (Buch buch in buecher)
{
autor.Buecher.Add("http://localhost:5000/api/books/" + buch.ID.ToString());
}
return(autor);
}
public AoRealizarAjusteAutor AjusteAutor(int id, [FromBody] AutorDTO autor)
{
var ajusteAutor = new AjusteAutor
{
AutorId = autor.AutorId,
Nome = autor.Nome,
Sobrenome = autor.Sobrenome,
Email = autor.Email
};
return(registrarAutor.Realizar(ajusteAutor));
}
private AutorDTO MapAutor(Autor autor)
{
AutorDTO dto = new AutorDTO();
dto.ID = autor.ID;
dto.LAND = autor.LAND;
dto.LEBENSALTER = autor.LEBENSALTER;
dto.NACHNAME = autor.NACHNAME;
dto.ORT = autor.ORT;
dto.VORNAME = autor.VORNAME;
return(dto);
}
public FormCadastroRegistrarAutor(AutorDTO autor)
{
InitializeComponent();
if (autor != null)
{
AutorId = autor.AutorId;
txtNome.Text = autor.Nome;
txtSobrenome.Text = autor.Sobrenome;
txtEmail.Text = autor.Email;
panelMenu.Visible = false;
this.Height -= panelMenu.Height;
}
}
public static AutorDTO fromModelToDto(Autor model)
{
if (model == null)
{
return(null);
}
AutorDTO autorDto = new AutorDTO();
autorDto.autorId = model.autorId;
autorDto.nume = model.nume;
autorDto.prenume = model.prenume;
return(autorDto);
}
public ActionResult Cadastro(AutorDTO autor, string origem)
{
ViewBag.Mensagem = "";
ViewBag.Problemas = null;
ViewBag.Origem = origem;
if (autor.AutorId > 0)
{
var ajusteAutor = new AjusteAutor
{
AutorId = autor.AutorId,
Nome = autor.Nome,
Sobrenome = autor.Sobrenome,
Email = autor.Email
};
var retornoAoRelizarAjusteAutor = registrarAutor.Realizar(ajusteAutor);
if (retornoAoRelizarAjusteAutor.AlterouComSucesso || retornoAoRelizarAjusteAutor.Problemas.Count <= 0)
{
ViewBag.Mensagem = "Autor ajustado com sucesso.";
}
else
{
ViewBag.Mensagem = retornoAoRelizarAjusteAutor.Mensagem;
ViewBag.Problemas = retornoAoRelizarAjusteAutor.Problemas;
}
}
else
{
var novoAutor = new NovoAutor
{
Nome = autor.Nome,
Sobrenome = autor.Sobrenome,
Email = autor.Email
};
var retornoAoRelizarNovoAutor = registrarAutor.Realizar(novoAutor);
if (retornoAoRelizarNovoAutor.AutorId > 0)
{
autor.AutorId = retornoAoRelizarNovoAutor.AutorId;
if (string.IsNullOrEmpty(origem))
{
return(RedirectToAction(nameof(Index)));
}
}
ViewBag.Mensagem = retornoAoRelizarNovoAutor.Mensagem;
ViewBag.Problemas = retornoAoRelizarNovoAutor.Problemas;
}
return(View(autor));
}
public void AddBook([FromBody] BookModel book, string count)
{
CarteDTO carte = new CarteDTO();
AutorDTO autor = new AutorDTO();
GenDTO gen = new GenDTO();
carte.titlu = book.title;
autor.nume = book.authorFirstName;
autor.prenume = book.authorLastName;
carte.AutorDto = autor;
gen.descriere = book.gender;
carte.GenDto = gen;
service.BuyBooksAsync(carte, short.Parse(count));
}
public ActionResult Edit(AutorDTO autor)
{
try
{
if (ModelState.IsValid)
{
autorBLL.Editar(autor);
return(RedirectToAction("Index"));
}
return(View(autor));
}
catch
{
return(View(autor));
}
}
public ActionResult Create(AutorDTO autor)
{
try
{
if (ModelState.IsValid)
{
autorBLL.Inserir(autor);
return(RedirectToAction("Index"));
}
return(View(autor));
}
catch (Exception)
{
return(View(autor));
}
}
public async Task <IActionResult> Post(AutorDTO autorDto)
{
//if (!ModelState.IsValid) return BadRequest(ModelState);
var autor = _mapper.Map <Autor>(autorDto);
if (TryValidateModel(autor))
{
_repository.Autor.Add(autor);
await _repository.SaveAsync();
var autorCreatedDto = _mapper.Map <AutorDTO>(autor);
return(CreatedAtAction(nameof(Get), new { id = autorCreatedDto.AutorId }, autorCreatedDto));
}
return(BadRequest(ModelState));
}
public IActionResult Create([FromBody] AutorDTO autorDTO)
{
try
{
var respAutorDTO = _autorservice.Insert(autorDTO);
return(Ok(respAutorDTO));
}
catch (ApplicationException ex)
{
return(BadRequest(ex));
}
catch (Exception ex)
{
//Logguear ex
return(BadRequest("Ha ocurrido un error inesperado"));
}
}
public Retorno.AoRealizarLocalizaAutor Realizar(Operacao.LocalizaAutor localizaAutor)
{
var retorno = new Retorno.AoRealizarLocalizaAutor();
var retornoAoLocalizarEmRepositorioAutor = repAutor.Localizar(localizaAutor.AutorId);
if (retornoAoLocalizarEmRepositorioAutor.Problemas.Count > 0)
{
retorno.Mensagem = "Não foi possível localizar o autor.";
retorno.Problemas.AddRange(retornoAoLocalizarEmRepositorioAutor.Problemas);
}
else
{
retorno.Autor = AutorDTO.Fabricar(retornoAoLocalizarEmRepositorioAutor.Autor);
}
return(retorno);
}
public async Task <ActionResult> Edit(int id, [Bind("Id,Name,Description,Image")] AutorDTO autorDTO)
{
if (id != autorDTO.Id)
{
return(NotFound());
}
var autor = _Mapper.Map <Autor>(autorDTO);
autor.Id = id;
_context.Entry(autor).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
private List <LibroDTO> MapAutorDTOLibros(Autor autor, AutorDTO autorDTO)
{
var resultado = new List <LibroDTO>();
if (autor.AutoresLibros == null)
{
return(resultado);
}
foreach (var autorLibro in autor.AutoresLibros)
{
resultado.Add(new LibroDTO()
{
Id = autorLibro.LibroId,
Titulo = autorLibro.Libro.Titulo
});
}
return(resultado);
}
// PUT api/values/5
public IHttpActionResult Put(int id, [FromBody] AutorDTO value)
{
var insert = Mapper.Map <Autor>(value);
using (var db = new LibraryExampleEntities())
{
var toChange = db.Autors.FirstOrDefault(x => x.Id == id);
if (toChange is null)
{
return(NotFound());
}
toChange.Name = value.Name;
toChange.Surname = value.Surname;
toChange.Description = value.Description;
db.SaveChanges();
}
return(Ok(insert));
}
public async Task <ActionResult <AutorDTO> > Create([Bind("Id,Name,Description,Image")] AutorDTO autorDTO)
{
if (!ModelState.IsValid)
{
return(View(autorDTO));
}
//_context.Add(autorDTO);
//await _context.SaveChangesAsync();
//return RedirectToAction(nameof(Index));
//return View(autorDTO);
var autor = _Mapper.Map <Autor>(autorDTO);
await _context.Autores.AddAsync(autor);
await _context.SaveChangesAsync();
var AutorDTO = _Mapper.Map <AutorDTO>(autor);
return(View(AutorDTO));
}
public ActionResult Cadastro(int id, string origem)
{
ViewBag.Mensagem = "";
ViewBag.Problemas = null;
ViewBag.Origem = origem;
var model = new AutorDTO();
if (id > 0)
{
var retornoAoRealizarLocalizaAutor = registrarAutor.Realizar(new LocalizaAutor {
AutorId = id
});
ViewBag.Mensagem = retornoAoRealizarLocalizaAutor.Mensagem;
ViewBag.Problemas = retornoAoRealizarLocalizaAutor.Problemas;
model = retornoAoRealizarLocalizaAutor.Autor;
}
return(View(model));
}
public RetornoBase <List <AutorDTO> > Realizar(Operacao.ListaAutoresDisponiveis listaAutoresDisponiveis)
{
var retorno = new RetornoBase <List <AutorDTO> >();
var aoListarAutoresDisponiveis = repLivro.ListarAutoresDisponiveis(listaAutoresDisponiveis.LivroId);
if (aoListarAutoresDisponiveis.Problemas.Count > 0)
{
retorno.Mensagem = "Não foi possível listar os autores disponíveis.";
retorno.Problemas.AddRange(aoListarAutoresDisponiveis.Problemas);
}
else
{
retorno.Valor = new List <AutorDTO>();
foreach (var autor in aoListarAutoresDisponiveis.Valor)
{
retorno.Valor.Add(AutorDTO.Fabricar(autor));
}
}
return(retorno);
}
public Retorno.AoRealizarListaAutores Realizar(Operacao.ListaAutores listaAutores)
{
var retorno = new Retorno.AoRealizarListaAutores();
var retornoAoListarDeRepositorioAutor = repAutor.Listar();
if (retornoAoListarDeRepositorioAutor.Problemas.Count > 0)
{
retorno.Mensagem = "Não foi possível listar os autores.";
retorno.Problemas.AddRange(retornoAoListarDeRepositorioAutor.Problemas);
}
else
{
retorno.Autores = new List <AutorDTO>();
foreach (var autor in retornoAoListarDeRepositorioAutor.Autores)
{
retorno.Autores.Add(AutorDTO.Fabricar(autor));
}
}
return(retorno);
}
public async Task GenerarEnlaces(AutorDTO autorDTO)
{
var esAdmin = await EsAdmin();
var Url = ConstruirURLHelper();
autorDTO.Enlaces.Add(new DatoHATEOAS(
enlace: Url.Link("obtenerAutor", new { id = autorDTO.Id }),
descripcion: "self",
metodo: "GET"));
if (esAdmin)
{
autorDTO.Enlaces.Add(new DatoHATEOAS(
enlace: Url.Link("actualizarAutor", new { id = autorDTO.Id }),
descripcion: "autor-actualizar",
metodo: "PUT"));
autorDTO.Enlaces.Add(new DatoHATEOAS(
enlace: Url.Link("borrarAutor", new { id = autorDTO.Id }),
descripcion: "self",
metodo: "DELETE"));
}
}
public async Task <IActionResult> AddNewAsync(AutorDTO autorDTO)
{
try
{
var exist = this.bibliotecaContext.Autors.FirstOrDefault(a => a.Nombre == autorDTO.Nombre);
if (exist != null)
{
return(this.BadRequest(new { error = $"Ya existe un autor con el nombre {autorDTO.Nombre}" }));
}
await this.bibliotecaContext.Autors.AddAsync(new Autor
{
Edad = autorDTO.Edad,
Nombre = autorDTO.Nombre,
});
await this.bibliotecaContext.SaveChangesAsync();
return(this.Ok());
}
catch (Exception)
{
return(this.BadRequest());
}
}
private void GenerarEnlaces(AutorDTO autor)
{
autor.Enlaces.Add(new Enlace(urlHelper.Link("ObtenerAutor", new { id = autor.Id }), rel: "self", metodo: "GET"));
autor.Enlaces.Add(new Enlace(urlHelper.Link("ActualizarAutor", new { id = autor.Id }), rel: "update-author", metodo: "PUT"));
autor.Enlaces.Add(new Enlace(urlHelper.Link("BorrarAutor", new { id = autor.Id }), rel: "delete-author", metodo: "DELETE"));
}
public void update(AutorDTO data)
{
string query = string.Format($@"UPDATE TBL_Autor SET nome = '{data.Nome}', idade = '{data.Idade}') WHERE id = {data.Id};");
database.execCommand(query);
}
public void Inserir(AutorDTO autor)
{
contexto.Autor.Add(autor);
contexto.SaveChanges();
}
public void Editar(AutorDTO autor)
{
contexto.Entry(autor).State = EntityState.Modified;
contexto.SaveChanges();
}
public void Deletar(AutorDTO autor)
{
contexto.Entry(autor).State = EntityState.Deleted;
contexto.SaveChanges();
}
public bool PodeExcluir(AutorDTO autorFiltro)
{
return(!contexto.Livro.Any(x => x.Autor.IDAutor == autorFiltro.IDAutor));
}