Exemplo n.º 1
0
        /// <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);
        }
Exemplo n.º 2
0
 /// <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);
 }
Exemplo n.º 3
0
        /// <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);
        }
Exemplo n.º 4
0
        /// <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);
        }
Exemplo n.º 5
0
        /// <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);
        }
Exemplo n.º 6
0
        /// <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);
        }
Exemplo n.º 7
0
        /// <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);
        }
Exemplo n.º 8
0
        /// <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);
        }
Exemplo n.º 9
0
 /// <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);
     }
 }
Exemplo n.º 10
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);
        }
Exemplo n.º 11
0
        /// <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);
        }
Exemplo n.º 12
0
 private static string Crear(NotaSQL nota)
 {
     return(Crear(TablaNotas, nota));
 }
Exemplo n.º 13
0
 private static string CrearNotaMax(NotaSQL nota)
 {
     return(Crear(TablaNotasMax, nota));
 }
Exemplo n.º 14
0
 private static string CrearNota2048(NotaSQL nota)
 {
     return(Crear(TablaNotas2048, nota));
 }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
 private static string Actualizar(NotaSQL nota)
 {
     return(Actualizar(TablaNotas, nota));
 }