/// <summary>
/// Devuelve la nota con el ID indicado.
/// </summary>
/// <param name="id">El id de la nota a obtener.</param>
/// <returns>
/// Un objeto del tipo <see cref="NotaSQL"/> con la nota indicada.
/// O un objeto nuevo (ID = 0) si no existe en la base de datos.
/// </returns>
/// <remarks>Se busca la nota con ese ID esté o no eliminada o archivada.</remarks>
internal static NotaSQL Nota(int id)
{
var nota = new NotaSQL();
var sel = $"SELECT * FROM {TablaNotas} " +
$"WHERE ID = {id} " +
"ORDER BY ID";
var con = new SqlConnection(CadenaConexion);
try
{
con.Open();
var cmd = new SqlCommand(sel, con);
var reader = cmd.ExecuteReader();
while (reader.Read())
{
nota = AsignarNota(reader);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
finally
{
if (!(con is null))
{
con.Close();
}
}
return(nota);
}
/// <summary>
/// Comprobar las longitudes máximas (25/May/21)
/// </summary>
internal static NotaSQL ComprobarMaxTexto(NotaSQL nota)
{
if (UsarNotasMaxConfig == false)
{
nota.Texto = MaxTexto(nota.Texto, 2048);
}
nota.Grupo = MaxTexto(nota.Grupo, 255);
return(nota);
}
/// <summary>
/// Los grupos que hay asignados.
/// </summary>
/// <returns>Una colección de tipo string</returns>
/// <remarks>Aquí se tiene en cuenta si se están usando las notas locales o las remotas.</remarks>
public static List <Grupo> Grupos(UsuarioSQL usuario)
{
if (App.UsarNotasLocal)
{
NotasGrupos = App.Database.Notas(App.Database.GetNotesAsync());
}
else
{
//// Si el usuario es elGuille, mostrar todos los grupos
//// si no, solo los del usuario y todas las notas (estén o no archivadas o eliminadas)
//if (usuario.Email.ToLower().IndexOf("elguille.info@") > -1)
// colNotas = NotaSQL.NotasUsuario(0);
//else
// colNotas = NotaSQL.NotasUsuario(usuario.ID);
// Mostrar solo las notas del usuario logueado.
NotasGrupos = NotaSQL.NotasUsuario(usuario.ID);
}
// Primero añadir a la colección de tipo Dictionary
// para evitar repetidos
var gruposDict = new Dictionary <string, Grupo>();
foreach (var s in NotasGrupos)
{
if (!gruposDict.ContainsKey(s.Grupo))
{
gruposDict.Add(s.Grupo, new Grupo());
}
var g = gruposDict[s.Grupo];
g.Nombre = s.Grupo;
g.Usuario = usuario.Email;
g.Notas++;
if (s.Archivada)
{
g.NotasArchivadas++;
}
if (s.Eliminada)
{
g.NotasEliminadas++;
}
if (s.Favorita)
{
g.NotasFavoritas++;
}
}
var grupos = new List <Grupo>();
foreach (var gd in gruposDict.Keys)
{
grupos.Add(gruposDict[gd]);
}
return(grupos);
}
/// <summary>
/// Inserta una nueva nota en la tabla Notas.
/// </summary>
/// <param name="nota">La nota a añadir.</param>
/// <returns>El número de notas afectadas (o cero si no se pudo insertar).</returns>
internal static int Insert(NotaSQL nota)
{
if (nota is null)
{
return(0); // new Task<int>(() => 0);
}
nota = ComprobarMaxTexto(nota);
var msg = Crear(nota);
if (msg.StartsWith("ERROR"))
{
return(0); // new Task<int>(() => 0);
}
return(1); // new Task<int>(() => 1);
}
/// <summary>
/// Actualiza la nota en la tabla Notas.
/// </summary>
/// <param name="nota">La nota a actualizar.</param>
/// <returns>El número de notas afectadas (o cero si no se pudo actualizar).</returns>
internal static int Update(NotaSQL nota)
{
if (nota is null || nota.ID == 0)
{
return(0); // new Task<int>(() => 0);
}
nota = ComprobarMaxTexto(nota);
var msg = Actualizar(nota);
if (msg.StartsWith("ERROR"))
{
return(0); // new Task<int>(() => 0);
}
return(1); // new Task<int>(() => 1);
}
/// <summary>
/// Elimina la nota indicada.
/// En realidad no se elimina, se asigna true a Eliminada.
/// </summary>
/// <param name="nota">La nota a eliminar.</param>
/// <returns>El número de notas afectadas (o cero si no se pudo eliminar).</returns>
public static int Delete(NotaSQL nota)
{
if (nota is null || nota.ID == 0)
{
return(0); // new Task<int>(() => 0);
}
nota.Eliminada = true;
var msg = Actualizar(nota);
//var sel = $"ID = {nota.ID}";
//var msg = Borrar(sel);
if (msg.StartsWith("ERROR"))
{
return(0); // new Task<int>(() => 0);
}
return(1); // new Task<int>(() => 1);
}
/// <summary>
/// Copiar esta nota de tipo <see cref="Nota"/> a una del tipo <see cref="NotaSQL"/>.
/// </summary>
/// <returns>Una copia del tipo <see cref="NotaSQL"/>.</returns>
public NotaSQL ComoNotaRemota()
{
Nota note = this;
//return note;
var nota = new NotaSQL
{
//ID = note.ID,
Archivada = note.Archivada,
Eliminada = note.Eliminada,
Favorita = note.Favorita,
Grupo = note.Grupo,
Modificada = note.Modificada,
Notificar = note.Notificar,
Sincronizada = note.Sincronizada,
Texto = note.Texto,
idNota = note.idNota
};
return(nota);
}
/// <summary>
/// Copiar esta nota de tipo <see cref="NotaSQL"/> a una del tipo <see cref="Nota"/>.
/// </summary>
/// <returns>Una copia del tipo <see cref="Nota"/>.</returns>
public Nota ComoNotaLocal()
{
NotaSQL nota = this;
// Se copian todos los valores tal como está en esta nota.
// ya que al editarla se usa como NotaSQL aunque sea del tipo Nota.
var note = new Nota
{
//ID = nota.ID,
Archivada = nota.Archivada,
Eliminada = nota.Eliminada,
Favorita = nota.Favorita,
Grupo = nota.Grupo,
Modificada = nota.Modificada,
Notificar = nota.Notificar,
Sincronizada = nota.Sincronizada,
Texto = nota.Texto,
idNota = nota.idNota
};
return(note);
}
/// <summary>
/// Guarda o actualiza la nota indicada.
/// Si el ID no es cero, la actualiza, si es cero la crea.
/// </summary>
/// <param name="nota">La nota a guardar.</param>
/// <returns>
/// El número de notas afectadas (0 si no se guardó o 1 si se actualizó o creó correctamente).
/// </returns>
public static int GuardarNota(NotaSQL nota)
{
if (nota is null)
{
return(0); // new Task<int>(() => 0);
}
try
{
if (nota.ID == 0)
{
return(NotaSQL.Insert(nota));
}
else
{
return(NotaSQL.Update(nota));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return(0);
}
}
/// <summary>
/// Asigna un objeto a partir de los datos del SQLReader.
/// </summary>
/// <param name="reader">El SQLReader del que se sacará la información.</param>
/// <returns>Un objeto del tipo <see cref="UsuarioSQL"/>.</returns>
private static NotaSQL AsignarNota(SqlDataReader reader)
{
var nota = new NotaSQL();
var id = 0;
int.TryParse(reader["ID"].ToString(), out id);
nota.ID = id;
id = 0;
int.TryParse(reader["idUsuario"].ToString(), out id);
nota.idUsuario = id;
nota.Grupo = reader["Grupo"].ToString().TrimEnd();
nota.Texto = reader["Texto"].ToString().TrimEnd();
var fec = DateTime.Now;
DateTime.TryParse(reader["Modificada"].ToString(), out fec);
nota.Modificada = fec;
var valorBool = false;
bool.TryParse(reader["Archivada"].ToString(), out valorBool);
nota.Archivada = valorBool;
valorBool = false;
bool.TryParse(reader["Eliminada"].ToString(), out valorBool);
nota.Eliminada = valorBool;
valorBool = false;
bool.TryParse(reader["Favorita"].ToString(), out valorBool);
nota.Favorita = valorBool;
valorBool = false;
bool.TryParse(reader["Sincronizada"].ToString(), out valorBool);
nota.Sincronizada = valorBool;
valorBool = false;
bool.TryParse(reader["Notificar"].ToString(), out valorBool);
nota.Notificar = valorBool;
return(nota); // new Task<NotaSQL>(() => nota);
}
/// <sumary>
/// Crear un nuevo registro
/// En caso de error, devolverá la cadena de error empezando por ERROR:.
/// </sumary>
private static string Crear(string tabla, NotaSQL nota)
{
string msg;
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
SqlTransaction tran = null;
try
{
con.Open();
tran = con.BeginTransaction();
SqlCommand cmd = new SqlCommand();
cmd.CommandType = CommandType.Text;
cmd.Connection = con;
string sCommand;
sCommand = $"INSERT INTO {tabla} (idUsuario, Grupo, Texto, Modificada, Archivada, Eliminada, Favorita, Sincronizada, Notificar, idNota) VALUES(@idUsuario, @Grupo, @Texto, @Modificada, @Archivada, @Eliminada, @Favorita, @Sincronizada, @Notificar, @idNota) SELECT @@Identity";
cmd.CommandText = sCommand;
cmd.Parameters.AddWithValue("@idUsuario", nota.idUsuario);
cmd.Parameters.AddWithValue("@Grupo", nota.Grupo);
cmd.Parameters.AddWithValue("@Texto", nota.Texto);
cmd.Parameters.AddWithValue("@Modificada", nota.Modificada);
cmd.Parameters.AddWithValue("@Archivada", nota.Archivada);
cmd.Parameters.AddWithValue("@Eliminada", nota.Eliminada);
cmd.Parameters.AddWithValue("@Favorita", nota.Favorita);
cmd.Parameters.AddWithValue("@Sincronizada", nota.Sincronizada);
cmd.Parameters.AddWithValue("@Notificar", nota.Notificar);
cmd.Parameters.AddWithValue("@idNota", nota.idNota);
cmd.Transaction = tran;
int id = System.Convert.ToInt32(cmd.ExecuteScalar());
nota.ID = id;
// Si llega aquí es que todo fue bien,
// por tanto, llamamos al método Commit.
tran.Commit();
msg = "Se ha creado un Notas correctamente.";
}
catch (Exception ex)
{
msg = $"ERROR: {ex.Message}";
try
{
tran.Rollback();
}
catch (Exception ex2)
{
msg = $"ERROR: {ex2.Message}";
}
}
finally
{
if (!(con is null))
{
con.Close();
}
}
}
return(msg);
}
private static string Crear(NotaSQL nota)
{
return(Crear(TablaNotas, nota));
}
private static string CrearNotaMax(NotaSQL nota)
{
return(Crear(TablaNotasMax, nota));
}
private static string CrearNota2048(NotaSQL nota)
{
return(Crear(TablaNotas2048, nota));
}
private static string Actualizar(string tabla, NotaSQL nota)
{
// Actualiza los datos indicados
// El parámetro, que es una cadena de selección, indicará el criterio de actualización
string msg;
using (SqlConnection con = new SqlConnection(CadenaConexion))
{
SqlTransaction tran = null;
try
{
con.Open();
tran = con.BeginTransaction();
SqlCommand cmd = new SqlCommand();
cmd.CommandType = CommandType.Text;
cmd.Connection = con;
string sCommand;
sCommand = $"UPDATE {tabla} SET idUsuario = @idUsuario, Grupo = @Grupo, Texto = @Texto, Modificada = @Modificada, Archivada = @Archivada, Eliminada = @Eliminada, Favorita = @Favorita, Sincronizada = @Sincronizada, Notificar = @Notificar, idNota = @idNota WHERE (ID = @ID)";
cmd.CommandText = sCommand;
cmd.Parameters.AddWithValue("@ID", nota.ID);
cmd.Parameters.AddWithValue("@idUsuario", nota.idUsuario);
cmd.Parameters.AddWithValue("@Grupo", nota.Grupo);
cmd.Parameters.AddWithValue("@Texto", nota.Texto);
cmd.Parameters.AddWithValue("@Modificada", nota.Modificada);
cmd.Parameters.AddWithValue("@Archivada", nota.Archivada);
cmd.Parameters.AddWithValue("@Eliminada", nota.Eliminada);
cmd.Parameters.AddWithValue("@Favorita", nota.Favorita);
cmd.Parameters.AddWithValue("@Sincronizada", nota.Sincronizada);
cmd.Parameters.AddWithValue("@Notificar", nota.Notificar);
cmd.Parameters.AddWithValue("@idNota", nota.idNota);
cmd.Transaction = tran;
cmd.ExecuteNonQuery();
// Si llega aquí es que todo fue bien,
// por tanto, llamamos al método Commit.
tran.Commit();
msg = "Se ha actualizado una Nota correctamente.";
}
catch (Exception ex)
{
msg = $"ERROR: {ex.Message}";
try
{
tran.Rollback();
}
catch (Exception ex2)
{
msg = $"ERROR: {ex2.Message}";
}
}
finally
{
if (!(con is null))
{
con.Close();
}
}
}
return(msg);
}
private static string Actualizar(NotaSQL nota)
{
return(Actualizar(TablaNotas, nota));
}
