public bool VlozitAutora(AutorModel autor)
{
bool success = false;
DataCheck dataCheck = new();
if (autor.Jmeno != null && dataCheck.AutorAlreadyExists(autor.Jmeno) == false)
{
string connectionString = ConnectionString.GetConnectionString();
string sqlStatement = "insert into dbo.Autori(Jmeno) VALUES(@jmeno)";
SqlConnection connection = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand(sqlStatement);
cmd.Parameters.Add("@jmeno", System.Data.SqlDbType.VarChar, 75).Value = autor.Jmeno;
cmd.Connection = connection;
connection.Open();
cmd.ExecuteNonQuery();
connection.Close();
success = true;
}
return(success);
}
// GET: Autor/Create
public ActionResult Create()
{
AutorModel autor = new AutorModel();
autor.Nome = Environment.UserName.ToString();
return(View(autor));
}
// TODO: criar injeção de depencia
public static async Task <List <AutorModel> > GetAutores()
{
List <AutorModel> Autores = new List <AutorModel>();
#region Mock
AutorModel autor1 = new AutorModel
{
Id = 1,
Nome = "Jonh",
SobreNome = "Tolkien"
};
AutorModel autor2 = new AutorModel
{
Id = 2,
Nome = "Bernard",
SobreNome = "Cornwell"
};
#endregion
Autores.Add(autor1);
Autores.Add(autor2);
return(Autores);
}
public ActionResult AgregarAutor(AutorModel autor)
{
var bd = new bdVentaLibrosDataContext();
var autorIngresado = new AutorModel
{
apellidoAutor = autor.apellidoAutor,
nombreAutor = autor.nombreAutor
};
if (AutorExiste(autorIngresado.apellidoAutor, autorIngresado.nombreAutor))
{
TempData["Message"] = "Ya existe un autor con esos datos";
}
else
{
Autores nuevoAutor = new Autores
{
apellidos = autor.apellidoAutor,
nombres = autor.nombreAutor
};
bd.Autores.InsertOnSubmit(nuevoAutor);
bd.SubmitChanges();
TempData["Message"] = "Autor agregado!";
}
return(RedirectToAction("AgregarAutor"));
}
// GET: Autor/Details/5
public ActionResult Details(int id)
{
string requestUrl = "/api/" + _CONTROLLER + "/" + id;
HttpResponseMessage response = client.GetAsync(requestUrl, HttpCompletionOption.ResponseHeadersRead).Result;
if (response.IsSuccessStatusCode)
{
var data = response.Content.ReadAsStringAsync().Result;
AutorModel model = JsonConvert.DeserializeObject <AutorModel>(data);
if (model != null)
{
return(View(model));
}
else
{
return(NotFound());
}
}
else
{
return(View());
}
}
public AutorModel GetById(int id)
{
using var sqlConnection = new SqlConnection(ConnectionString);
sqlConnection.Open();
var command = sqlConnection.CreateCommand();
command.CommandType = CommandType.Text;
command.CommandText = "SELECT Id, Nacionalidade, Nascimento, Nome, UltimoNome, QuantidadeLivrosPublicados FROM Autor WHERE Id = @id;";
command.Parameters
.Add("@id", SqlDbType.Int)
.Value = id;
var reader = command.ExecuteReader();
var canRead = reader.Read();
if (!canRead)
{
return(null);
}
var autor = new AutorModel
{
Id = reader.GetFieldValue <int>(0),
Nacionalidade = reader.GetFieldValue <string>(1),
Nascimento = reader.GetFieldValue <DateTime>(2),
Nome = reader.GetFieldValue <string>(3),
UltimoNome = reader.GetFieldValue <string>(4),
QuantidadeLivrosPublicados = reader.GetFieldValue <int>(5)
};
return(autor);
}
public AutoresGet GetAutores(int isbn)
{
AutoresGet result = new AutoresGet();
if (isbn == 654321 || isbn == 123456)
{
AutorModel autorMock = new AutorModel()
{
IdAutor = 1,
Nome = "Homero",
SobreNome = string.Empty
};
result.Autores.Add(autorMock);
}
if (result.Autores.Count == 0)
{
result.StatusCode = 204;
}
else
{
result.StatusCode = 200;
}
return(result);
}
public async Task <Result <AutorModel> > UpdateAutorAsync(Guid autorId, AutorModel autorModel)
{
Guard.Against.NullOrEmpty(autorId, "AutorId");
var autor = await _repositorio.GetByIdAsync(autorId);
if (autor is null)
{
_logger.LogWarning("Não foi encontrado autor com id igual a '{0}'", autorId);
return(Result <AutorModel> .NotFound());
}
autor.Nome = !string.IsNullOrEmpty(autorModel.Nome) && autor.Nome != autorModel.Nome ? autorModel.Nome : autor.Nome;
autor.Sobrenome = !string.IsNullOrEmpty(autorModel.Sobrenome) && autor.Sobrenome != autorModel.Sobrenome ? autorModel.Sobrenome : autor.Sobrenome;
autor.Email = !string.IsNullOrEmpty(autorModel.Nome) && autor.Email != autorModel.Email ? autorModel.Email : autor.Email;
autor.Bio = autor.Bio != autorModel.Bio ? autorModel.Bio : autor.Bio;
autor.Avatar = autor.Avatar != autorModel.Avatar ? autorModel.Avatar : autor.Avatar;
autor.DataAtualizacao = DateTime.Now;
var validator = new AutorValidator();
var resultValidation = validator.Validate(autor);
if (!resultValidation.IsValid)
{
_logger.LogWarning("Atualização do autor não passou na validação. Erros: {0}", resultValidation.Errors.ToJson());
return(Result <AutorModel> .Invalid(resultValidation.AsErrors()));
}
await _repositorio.UpdateAsync(autor);
_logger.LogInformation("Autor foi atualizado com sucesso");
return(Result <AutorModel> .Success(
_mapper.Map <AutorModel>(autor)));
}
// GET: AutorController/Delete/5
public ActionResult Delete(int id)
{
Autor autor = _autorService.Obter(id);
AutorModel autorModel = _mapper.Map <AutorModel>(autor);
return(View(autorModel));
}
public static async Task <AutorModel> Get(int id)
{
AutorResponseGet responseGet = null;
AutorModel autorResultado = null;
var uri = new Uri(string.Format("{0}/Autores/{1}", urlBase, id));
using (var cliente = new HttpClient())
{
HttpResponseMessage response = await cliente.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
// Retornou com sucesso
var responseString = await response.Content.ReadAsStringAsync();
responseGet = JsonConvert.DeserializeObject <AutorResponseGet>(responseString);
// Se não houve erro, extrai o resultado
if (responseGet != null && responseGet.IndicadorErro == 0)
{
autorResultado = responseGet.Autores.FirstOrDefault();
}
}
}
return(autorResultado);
}
public async Task <IActionResult> Crear([FromBody] AutorModel model)
{
try
{
if (ModelState.IsValid)
{
var result = await _service.Crear(AutorConvert.toEntity(model));
if (result != null)
{
return(Ok(AutorConvert.toModel(result)));
}
else
{
return(BadRequest("Error creando el Autor!!"));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
throw e;
}
}
public async Task <ActionResult <AutorModel> > PostAutorModel(AutorModel autorModel)
{
_context.Autor.Add(autorModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAutorModel", new { id = autorModel.Id }, autorModel));
}
public ActionResult <AutorModel> Get(int id)
{
Autor autor = _autorService.Obter(id);
AutorModel autorModel = _mapper.Map <AutorModel>(autor);
return(autorModel);
}
public IActionResult SaveNew(AutorModel autorModel)
{
Autor autor = new Autor()
{
Ime = autorModel.Ime,
Prezime = autorModel.Prezime,
Email = autorModel.Email,
Biografija = autorModel.Biografija
};
Autori.Insert(autor);
Autori.Save();
/* implement later
* foreach (int knjigaId in autorModel.Knjige)
* {
* AutorKnjiga.Insert(new AutorKnjiga()
* {
* Autor = autor,
* Knjiga = Knjige.Get(knjigaId)
* });
* }
* Save();*/
return(RedirectToAction("Index"));
}
public AutoresGet GetAutores(int idEditora)
{
AutoresGet result = new AutoresGet();
AutorModel autorMock = new AutorModel()
{
IdAutor = 1,
Nome = "Homero",
SobreNome = string.Empty
};
AutorModel autorMock1 = new AutorModel()
{
IdAutor = 2,
Nome = "Paulo",
SobreNome = "Coelho"
};
if (idEditora == 1)
{
result.Autores.Add(autorMock);
result.Autores.Add(autorMock1);
}
if (result.Autores.Count == 0)
{
result.StatusCode = 204;
}
else
{
result.StatusCode = 200;
}
return(result);
}
public static async Task <List <AutorModel> > GetAutor(int id)
{
List <AutorModel> Autores = new List <AutorModel>();
if (id == 1)
{
AutorModel autor1 = new AutorModel
{
Id = 1,
Nome = "Jonh",
SobreNome = "Tolkien"
};
Autores.Add(autor1);
}
else if (id == 2)
{
AutorModel autor2 = new AutorModel
{
Id = 2,
Nome = "Bernard",
SobreNome = "Cornwell"
};
Autores.Add(autor2);
}
return(Autores);
}
public IActionResult Delete(AutorModel autorModel)
{
var autorToRemove = Autores.FirstOrDefault(x => x.Id == autorModel.Id);
Autores.Remove(autorToRemove);
return(RedirectToAction(nameof(Index)));
}
public void Post([FromBody] AutorModel autorModel)
{
if (ModelState.IsValid)
{
var autor = _mapper.Map <Autor>(autorModel);
_autorService.Inserir(autor);
}
}
public IActionResult Index()
{
var autorModel = new AutorModel();
autorModel.Id = 1;
autorModel.Nome = "Felipe Andrade";
return(View(autorModel));
}
public AutorModel Create(AutorModel autorModel)
{
autorModel.Id = Id;
Autores.Add(autorModel);
//TODO: auto-increment Id e atualizar para o retorno
return(autorModel);
}
public void Put(int id, [FromBody] AutorModel autorModel)
{
if (ModelState.IsValid)
{
var autor = _mapper.Map <Autor>(autorModel);
autor.IdAutor = id;
_autorService.Editar(autor);
}
}
public Autor TransformarAutorModelEmAutor(AutorModel autorModel)
{
var autor = new Autor();
autor.Id = autorModel.Id;
autor.Nome = autorModel.Nome;
return(autor);
}
public void Create(AutorModel autor)
{
try
{
collection.InsertOne(autor);
Console.WriteLine("Autor Criado");
}
catch (Exception ex) { throw ex; }
}
public AutorModel TransformarAutorEmAutorModel(Autor autor)
{
var autorModel = new AutorModel();
autorModel.Id = autor.Id;
autorModel.Nome = autor.Nome;
return(autorModel);
}
public ActionResult Create(AutorModel autorModel)
{
if (ModelState.IsValid)
{
var autor = _mapper.Map <Autor>(autorModel);
_autorService.Inserir(autor);
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Edit(int id, AutorModel autorModel)
{
if (ModelState.IsValid)
{
var autor = _mapper.Map <Autor>(autorModel);
_autorService.Editar(autor);
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Index()
{
var autorModel = new AutorModel();
autorModel.Id = 1;
autorModel.Nome = "Tao Hansen";
return(View(autorModel));
}
public AutorModel EditAutor(AutorModel autor, AutorModel autorEdit)
{
autor.Id = autorEdit.Id;
autor.Nome = autorEdit.Nome;
autor.UltimoNome = autorEdit.UltimoNome;
autor.Nacionalidade = autorEdit.Nacionalidade;
autor.QuantidadeLivrosPublicados = autorEdit.QuantidadeLivrosPublicados;
return(autor);
}
private AutorViewModel MontarView(AutorModel autor)
{
var view = new AutorViewModel();
view.id = autor._id.ToString();
view.Nome = autor.nome;
return(view);
}
public Autor ObterEntidadeAutor(AutorModel autorModel)
{
Autor autor = new Autor
{
Nome = autorModel.Nome
};
return(autor);
}
