miércoles, 4 de septiembre de 2019

TypeScript: Interfaces

Las interfaces en TS se declaran de la siguiente manera:

TS
interface Xmen{
nombre:String,
poder:string
}

function enviarMision(xmen : Xmen) {
console.log(`Enviando a ${xmen.nombre}`);
}

function enviarCuartel(xmen: Xmen) {
console.log(`Enviando al cuartel a ${xmen.nombre}`);
}

let wolverine:Xmen = {
nombre: "Wolverine",
poder: "Regeneracion"
};

enviarMision(wolverine);
enviarCuartel(wolverine);

JS
function enviarMision(xmen) {
console.log("Enviando a " + xmen.nombre);
}
function enviarCuartel(xmen) {
console.log("Enviando al cuartel a " + xmen.nombre);
}
var wolverine = {
nombre: "Wolverine",
poder: "Regeneracion"
};
enviarMision(wolverine);
enviarCuartel(wolverine);



























Typescript - Inicio y configuracion

Para crear un proyecto de typescript dentro de VSC se crea la carpeta y a continuación se crea un archivo por ejemplo "app.ts".

A continuación se detallan los comandos básicos:

tsc app.ts: compila el archivo d ts y lo convierte en un archivo de javascript .js

tsc app -w: sirve para que VSC este a la escucha del archivo en cuestion y con simplemente guardarlo, VSC compile y genere el js automaticamente.

tsc -init: sirve para que VSC entienda que la carpeta es un proyecto de ts y este a la escucha de todos los cambios.

tsc: con este comando dentro la carpeta se compilaran todos los archivos de ts que se encuentren dentro de la misma.


A cntinuación se detallan los tipos de variables de typescript:



Cadenas multilinea con ``, con lo que este encerrado en es signo se leera como una sola linea:

let nombre:string = "Juan";
let apellido:string = "Perez";
let edad:number = 32;

let texto = `Hola, ${nombre} ${apellido} (${edad})`;

console.log(texto);

Esto se mostrara de la siguiente manera en javascript:

var texto = "Hola, \n" + nombre + " " + apellido + " \n(" + edad + ")";

Adicional en ts se pueden hacer operaciones dentro de las plecas:

TS
function getNombre() {
return "Jhosef";
}

let texto2:string = `La respuesta es: ${2+2}`;

let nombre = `El nombre es: ${getNombre()}`;

console.log(texto2);
console.log(nombre);

JS
function getNombre() {
return "Jhosef";
}
var texto2 = "La respuesta es: " + (2 + 2);
var nombre = "El nombre es: " + getNombre();
console.log(texto2);
console.log(nombre);

A continuación se detalla la declaración de parámetros requeridos, por defecto y opcionales en ts, es importante mencionar que para la llamada de la función es imperativo que se declaren en orden los mismos.

TS
function activar( quien:string, objeto:string = "batiseñal", momento?:string ) {
let mensaje:string;

if(momento) {
mensaje = `${quien}, activo la ${objeto} a las ${momento}`;
} else {
mensaje = `${quien}, activo la ${objeto}`;
}
console.log(mensaje);
}

activar("Gordon", "batiseñal");

JS
function activar(quien, objeto, momento) {
if (objeto === void 0) { objeto = "batiseñal"; }
var mensaje;
if (momento) {
mensaje = quien + ", activo la " + objeto + " a las " + momento;
}
else {
mensaje = quien + ", activo la " + objeto;
}
console.log(mensaje);
}
activar("Gordon", "batiseñal");

FUNCIONES DE FLECHA:

TS
let miFuncion = function(a:any) {
return a;
}
//funcion de flecha
let miFuncionF = (a:any) => a;

//funcion con 2 parametros

let miFuncion2 = function(a:number, b:number) {
return a + b;
}
//funcion con parametros
let miFuncion2F = (a:number, b:number) => a + b;


//funcion de flecha que devuelve un valor
let miFuncion3 = function(nombre:string) {
nombre = nombre.toUpperCase();
return nombre;
}

let miFuncion3F = (nombre:string)=> {
nombre = nombre.toUpperCase();
return nombre;
}

JS

var miFuncion = function (a) {
return a;
};
//funcion de flecha
var miFuncionF = function (a) { return a; };
//funcion con 2 parametros
var miFuncion2 = function (a, b) {
return a + b;
};
//funcion con parametros
var miFuncion2F = function (a, b) { return a + b; };
//funcion de flecha que devuelve un valor
var miFuncion3 = function (nombre) {
nombre = nombre.toUpperCase();
return nombre;
};
var miFuncion3F = function (nombre) {
nombre = nombre.toUpperCase();
return nombre;
};

var hulk = {
nombre: "Bruce",
smash: function () {
var _this = this;
setTimeout(function () { return console.log(_this.nombre + " smash!!!"); }, 1500);
}
};
hulk.smash();

A continuacion se muestra una destructuracion de objetos:

let avenger = {
nombre: "Steve",
clave: "Capitan America",
poder: "Droga"
}

let {nombre, clave, poder} = avenger;

console.log(nombre);

SINTAXIS DE LAS PROMESAS

//promesas: son asincronicas y se ejecutan el caso de que algo salga biien o mal
var prom1 = new Promise(function(resolve, reject) {
setTimeout(function() {
console.log("La funcion finalizo correctamente");
resolve();
}, 1500);
});
prom1.then(function() {
console.log("la funcion termino bien");
}, function() {
console.error("esto termino mal");
});


















lunes, 2 de septiembre de 2019

Ajax BeginForm()

Ajax Begin form es la sintaxis integrada pr Asp.Net MVC para el manejo de peticiones ajax hacia el servidor.

A continuación se muestra unos ejemplos de uso de ajax.BeginForm():

Primero mediante nuget es necesario descargar la librería "jquery.unobtrusive-ajax.min.js" e incluirla a nivel global y local en el documento en cuestión.

Se procede a crear el documento donde se plasma la sintaxis de como llamar a un Ajax.BeginForm:


<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Ajax Begin Form</title>
</head>
<body>
    <div>
        <h3>1. Ejemplo Con Ajax Form</h3>

        @using (Ajax.BeginForm("Duplicador", "Home", null, new AjaxOptions()
        {
            HttpMethod = "POST",
            InsertionMode = InsertionMode.Replace,
            UpdateTargetId = "spanDuplicado"
        }))
        {
            <input type="number" data-val="true" data-val-required="Campo requerido" name="cantidad" class="form-control" /> <input style="margin-top: 10px; margin-bottom: 10px;" type="submit" value="Duplicar" class="btn btn-primary" />
        }

        Resultado: <span id="spanDuplicado"></span>



    </div>

    @section Scripts{
    <script src="~/Scripts/jquery.unobtrusive-ajax.min.js" type="text/javascript"></script>
    }

</body>
</html>

Se crea el método Post que recibe la petición y devuelve la respuesta:

[HttpPost]
public ActionResult Duplicador(int cantidad)
{
    var duplicado = cantidad * 2;

    return Json(duplicado);
}


A continuación se detalla un ejemplo ajax con mas opciones del metodo BeginForm():

Dentro del metodo Ajax.BeginForm se detallan los metodos adicionales que se pueden utilizar

@using (Ajax.BeginForm("Duplicador", "Home", null, new AjaxOptions()
        {
            HttpMethod = "POST",
            InsertionMode = InsertionMode.Replace,
            UpdateTargetId = "spanDuplicado",
            LoadingElementId = "loading",
            Confirm = "Estas seguro que deseas duplicar el número?",
            OnBegin = "onBegin",
            OnSuccess = "onSuccess",
            OnComplete = "onComplete",
            OnFailure = "onFailure"
        }))
        {
            <input type="number" data-val="true" data-val-required="Campo requerido" name="cantidad" class="form-control" />
            <div id="loading" style="display:none;">cargando</div>
            <input style="margin-top: 10px; margin-bottom: 10px;" type="submit" value="Duplicar" class="btn btn-primary" />
        }

        Resultado: <span id="spanDuplicado"></span>

Este es el resultado, siendo que las funciones on, llaman a métodos de console.log:











$.Get en Ajax con Asp net MVC

El metodo get sirve para obtener informacion desde el servidor y refrejarla en la pantalla, pudiendo o no enviar parametros de entrada.

A continuación se muestra eun ejemplo de $.get en el ccual se obtiene un listado de personas.

Se crea el html y el método get que hará la petición al servidor.

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Obtener listado de personas</title>
</head>
<body>
    <div style="margin-top: 20px">
        <input type="number" id="Edad" value="0" class="form-control" />
        <br />
        <input type="button" id="obtenerListado" class="btn btn-primary" value="Obtener Listado" />
    </div>

    <div id="resultado" style="margin-top: 10px;"></div>

    @section Scripts{
        <script>
            $(function () {
                $("#obtenerListado").click(function () {
                    var url = "@Url.Action("ObtenerPersona", "Home")";
                    var Edad = $("#Edad").val();
                    var data = { Edad: Edad };

                    $.get(url, data).done(function (data) {
                        $("#resultado").html(data);
                    });
                });
            });
        </script>
    }

</body>

Se crea un método en el servidor que recibe la petición y genera una vista parcial que formatea y devuelve el resultado.

[HttpGet]
public ActionResult ObtenerPersona(int Edad = 0)
{
    var persona = new List<Persona> {
        new Persona{ Nombre = "Carlos Flores", Edad = 30},
        new Persona{ Nombre = "Jhosef Flores", Edad = 29},
        new Persona{ Nombre = "Jenny Fonseca", Edad = 26},
        new Persona{ Nombre = "Camila Ramirez", Edad = 10},
        new Persona{ Nombre = "Marjeory Galvez", Edad = 52},
        new Persona{ Nombre = "David Flores", Edad = 30},
    };

    if(Edad > 0)
    {
        persona = persona.Where(x => x.Edad >= Edad).ToList();
    }

    return PartialView("_ObtenerPersonaParcial", persona);
}

Se crea la vista que recibe y formatea la información.

@model IEnumerable<JavaScriptEsencial.Models.Persona>

<table class="table table-bordered table-striped">
    <tr>
        <td>@Html.DisplayNameFor(model => model.Nombre)</td>
        <td>@Html.DisplayNameFor(model => model.Edad)</td>
    </tr>
    @foreach (var persona in Model)
    {
        <tr>
            <td>@Html.DisplayFor(model => persona.Nombre)</td>
            <td>@Html.DisplayFor(model => persona.Edad)</td>
        </tr>
    }
</table>

Se muestra el resultado final donde al dar clic se muestra el listado de usuarios.





AJAX - Metodo Post - ASP.NET MVC

El metodo post de Ajax en asp.net mvc sirve para enviar informacion al servidor y recibir una respuesta que se puede mostrar al cliente, unicamente refrescando parte de la pagina.

A continuacion se uestra un ejemplo en el cual el usuario envia nombre y edad y el servidor valida que la edad sea mayor o igual a 18, si es asi devuelva la respuesta "Ok", caso contrario devuelve un error.

Se crea el contenido html y el contenido ajax para llamar al metodo del controlador del servidor.

<!DOCTYPE html>

<html>

<head>
    <meta name="viewport" content="width=device-width" />
    <title>Crear persona meediante Ajax</title>
</head>
<body>
    <div class="container-fluid">
        <div class="row">
            <div class="col-lg-12">
                <h3>Crear Una Persona</h3>
                <form action="/" method="post">
                    <div class="col-lg-12" style="margin-bottom: 20px;">
                        <div>
                            <span>Ingresa tu nombre: </span>
                            <input type="text" id="nombre" class="form-control" required="required" />
                        </div>
                        <div>
                            <span>Ingresa tu edad: </span>
                            <input type="number" id="edad" class="form-control" required />
                        </div>
                        <div>
                            <input style="margin-top: 10px;" type="button" ID="guardarPersona" value="Guardar Persona" class="btn btn-primary" />
                        </div>
                    </div>
                </form>
                
            </div>
            <div class="col-lg-12">
                <div id="resp" class="jumbotron"></div>
            </div>
        </div>
    </div>

    @section Scripts{

    <script>
        $(function () {
            $("#guardarPersona").click(function () {

                var url = "@Url.Action("CrearPersona", "Home")";

                var nombre = $("#nombre").val();
                var edad = $("#edad").val();
                var data = { Nombre: nombre, Edad: edad };

                $(document).ajaxStart(function () {

                    $("#resp").html("Cargando...");
                });

                $.post(url, data).done(function (data) {

                    $("#resp").html(data.Mensaje);
                }).fail(function (response) {
                    $("#resp").html(response.responseText);
                    });
            });
        });
    </script>
    }

</body>

</html>


Se crea la función post que recibirá la data y que la procesara.

[HttpPost]
public JsonResult CrearPersona(Persona persona)
{
    var resp = new BaseMensaje();

    try

    {
        if(persona.Nombre == null || persona.Edad <= 0)
        {
            throw new ApplicationException("Algun elemento de la persona se encuentra vacio");
        }

        if(persona.Edad < 18)

        {
            throw new ApplicationException("La edad de la persona debe ser mayor o igual a 18 años");
        }

        resp.OK = true;

        resp.Mensaje = "Transacción realizada correctamente";

    } catch(Exception ex)

    {
        resp.OK = false;
        resp.Mensaje = ex.Message;
    }

    return Json(resp);

}

martes, 27 de agosto de 2019

Tareas - Task

A continuación se detalla la manera de crear tareas, ademas con expresiones lambda:

En proyecto es un WPF

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    void CreateTask()
    {
        //Creando una tarea desde el delegado Action
        Task T;
        var Code = new Action(ShowMessage);

        T = new Task(Code);

        //Creando tarea desde un delegado anónimo
        Task T2 = new Task(delegate {
            MessageBox.Show("Ejecutando una tarea desde un delegado anónimo");
        });

        //Creando una tarea desde una expresion lambda delegada
        Task T3 = new Task(delegate { ShowMessage(); });

        //Creando una tarea desde una expresion lambda
        Task T3_1 = new Task(()=> { ShowMessage(); });

        //Expresion lambda con un metodo anonimo
        Task T4 = new Task(()=> { MessageBox.Show("Ejecutando la tarea 4"); });

        //Expresion lambda con bloque de codigo
        Task T5 = new Task(()=> {
            DateTime currentDate = DateTime.Today;
            DateTime startDate = currentDate.AddDays(30);
            MessageBox.Show($"Tarea 5. Fecha calculada: {startDate}");
        });

        //Expresion lambda con parametros
        Task T6 = new Task((message)=>MessageBox.Show(message.ToString()), "Expresion lambda con parametros");
    }

    void ShowMessage()
    {
        MessageBox.Show($"Ejecutando el metodo {MethodBase.GetCurrentMethod().ToString()}");
    }
}

miércoles, 21 de agosto de 2019

Claves foraneas en Code First

Las claves foraneas son relaciones entre tablas que guardan relacion mediante un Id

A continuacion se muestra una relacion de clave foranea entre las clases "BlogPost" y "Comentario"

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web;

namespace EFCodeFirst.Models
{
    public class BlogPost
    {
        public int Id { get; set; }
        [Required]
        [StringLength(200)]
        [Display(Name = "Título")]
        public string Titulo { get; set; }
        [Required]
        [StringLength(500)]
        public string Contenido { get; set; }
        [Required]
        [StringLength(150)]
        public string Autor { get; set; }
        [Required]
        [Display(Name = "Fecha De Publicación")]
        public DateTime Publicacion { get; set; }
        public List<Comentario> Comentarios { get; set; }
    }
}

Clase Comentario.cs

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace EFCodeFirst.Models
{
    public class Comentario
    {
        public int Id { get; set; }
        public int Contenido { get; set; }
        public int Autor { get; set; }
        public int BlogPostId { get; set; }

        [ForeignKey("BlogPostId")]
        public BlogPost BlogPost { get; set; }
    }
}

De esta manera tanto las clases "BlogPost" como "Comentario" se unifican y pueden relacionar y consultar su data entre si.


Para vincular y relacionar post con comentarios hacemos lo siguiente:

Modificamos la clase "BlogPostRepository.cs" donde se observa que con include se incluye "Comentarios"


using System.Data.Entity;

namespace EFCodeFirst.Services
{
    public class BlogPostRepository
    {
        public List<BlogPost> ObtenerTodos()
        {
            using ( var db = new BlogContext() )
            {
                return db.BlogPosts.Include(x => x.Comentarios).ToList();
            }
        }
    }
}

En la clase "BlogPostController.cs" se muestra que dentro de la variable comentario estamos guardando el primer comentario del primer post

// GET: BlogPost
public ActionResult Index()
{
    var model = _repo.ObtenerTodos();
    var comentario = model[0].Comentarios[0];

    return View(model);
}











Code First con ASP.NET MVC y SQL SERVER

A continuacion se detalla la manera de crear una base de datos de tipo CodeFirst

1. Crear el proyecto de tipo ASP.NET MVC.

2. Una vez creado el proyecto, dentro de la carpeta Models creamos el modelo, en este caso "BlogPost.cs"


using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace EFCodeFirst.Models
{
    public class BlogPost
    {
        public int Id { get; set; }
        public string Titulo { get; set; }
        public string Contenido { get; set; }
        public string Autor { get; set; }
        public DateTime Publicacion { get; set; }
    }
}

3. Igualmente en la carpeta Modelo creamos en DBContext que es que va hacer el crud con la base de datos.

Es importante tomar en cuenta que dentro de esta clase de deben crear los objetos DbSet que se encargaran de mapear las clases y convertirlas en tablas de la DB

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;

namespace EFCodeFirst.Models
{
    public class BlogContext: DbContext
    {
        public BlogContext() : base(nameOrConnectionString: "Contexto")
        {

        }

        public DbSet<BlogPost> BlogPosts { get; set; }
    }
}

4. Posterior a ello en el Web Config del aplicativo pegamos la cadena de conexion hacia a base de datos.

</configSections>
<connectionStrings>
  <add name="Contexto" connectionString="Data Source=EDPMER-V21-120\MSSQLSERVER01;Initial Catalog=EFCodeFirst;Integrated Security=True; Application Name=EntityFramework;" providerName="System.Data.SqlClient" />
</connectionStrings>


5. Posterior a ello vamos a /Herramientas/Administrador de paquetes Nuget/Consola de administracioon de paquetes.

6. Una vez abierta verificamos que el proyecto predeterminado sea en el cual queremos hacer el Code First.

7. Posterior a ello digitamos el comando: enable-migrations -Force, lo que creara una carpeta llamada "Migrations" que contendra la clase "Configuration".

8. Dentro de la clase cambiamos el parametro AutomaticMigrationsEnabled a true.



9. posterior a ello en la consola de nuget, preseleccionando nuestro proyecto digitamos el comando: update-database, y si todo ha salido de manera correcta se creara en sql server la base de datos.


------------------------

ACTUALIZAR CAMBIOS EN LA BASE DE DATOS

Posterior a cambiar la estructura de una tabla y querer ejecutar el comando "update-database" se presenta un error que indica que la data se puede dañar.

Para esto existen 2 opciones de solucion:

1. den tro de Migrations/Configuration.cs, dentro del constructor al final del metodo ponemos los siguiente, que hara que el error desaparezca, pero es peligroso:

AutomaticMigrationDataLossAllowed = true;

2. digitamos el comando update-database -Force lo cual forzara a que se actualice el esquema, lo cual seria lo correcto.












Vistas Parciales

Son partes de vistas que se pueden incluir en una vista general Html, ademas de que pueden recibir parámetros.

A continuación se muestra un ejemplo de paso de parámetros, entre una clase, una vista principal y vista parcial con parámetros:

Se declara la clase, se llenan los objetos y se envía la información a la vista principal:

public class Persona1
    {
        public string Nombre { get; set; }
        public int Edad { get; set; }
    }

se crean los objetos y se devuelve a la vista principal

[HttpGet]
        public ActionResult Index2()
        {
            var personas = new List<Persona1>
            {
                new Persona1
                {
                    Nombre = "Carlos",
                    Edad = 30
                },
                new Persona1
                {
                    Nombre = "Jhosef",
                    Edad = 22
                }
            };

            ViewBag.MiListado = personas;

            return View();
        }

En la vista principal se llama a la vista parcial, pasandole el objeto


@{
    Layout = null;
}

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Index2</title>
</head>
<body>
    <div>
        @Html.Partial("_ListadoPersonas", (List<WebApplication2.Controllers.Persona1>)ViewBag.MiListado)
    </div>
</body>
</html>

En la vista parcial se lee la informacion enviada

@model List<WebApplication2.Controllers.Persona1>

@foreach (var persona in Model)
{
    <div><strong>Nombre: </strong>@persona.Nombre (@persona.Edad)</div>
}







Begin Form ASP.NET MVC

@BeginForm() : sirve para iniciarlizar formularios en asp.net.

En su forma basica a continuacion se detalla la manera en la cual mediante una clase "Estudiante.cs" se puede instanciar un formulario de tipo get y post

EJEMPLO:

Se crea la clase "Estudiante"con validaciones dentro del "HomeController.cs"

public class Estudiante
    {
        [Display(Name = "Ingresa un nombre")]
        [Required(ErrorMessage = "El campo nombre es requerido")]
        public string Nombre { get; set; }

        [Display(Name = "Ingresa tu apellido")]
        [Required(ErrorMessage = "El campo apellido es requerido")]
        public string Apellido { get; set; }

        [Display(Name = "Ingresa la edad")]
        [Required(ErrorMessage = "El campo edad es requerido")]
        public int Edad { get; set; }
    }

Posterior a ello se crea la vista dento del index1 de "HomeController.cs"

@model WebApplication2.Controllers.Estudiante

@{
//Layout = null;
}

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Index1</title>
</head>
<body>
    <h3>@ViewBag.Nombre</h3>
    <div>
        @using (Html.BeginForm())
        {
            <div>
                @Html.LabelFor(model => model.Nombre)
                @Html.EditorFor(model => model.Nombre)
            </div>
            <div>
                @Html.LabelFor(model => model.Apellido)
                @Html.EditorFor(model => model.Apellido)
            </div>
            <div>
                @Html.LabelFor(model => model.Edad)
                @Html.EditorFor(model => model.Edad)
            </div>

            <input type="submit" value="Enviar Información" />
        }
    </div>
</body>
</html>

Echo esto, se observa los metodos GET y POST de index1 que son los que revuelven toda la lógica de este manejo.

[HttpGet]
        public ActionResult Index1()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Index1(Estudiante estudiante)
        {
            ViewBag.Nombre = $"Bienvenido, {estudiante.Nombre} {estudiante.Apellido}";

            estudiante.Edad = 99;

            return View();
        }

Este metodo tiene as siguientes sobrecargas
@Html.BeginForm("ActionName", "Controller", "Metodo")