Hosting Windows, ASP.NET y SQL Server

Hoy les hablaré un poco sobre mi proyecto de Servidores de Hosting y que me motivó a emprender en este segmento.

Como programadores en estas tecnologías (si bien tenemos Azure) nos cuesta un poco de trabajo encontrar un hosting ya sea gratuito o barato para poder desplegar nuestros proyectos. El abuso con el que algunas empresas inflan los precios, revendedores que tardan tiempo en dar una respuesta a una incidencia me motivaron a ir emprendiendo en este nuevo segmento.

Inicié con un propio servidor rentado en la infraestructura de Softlayers. Al principio solo pensaba utilizarlo para mis proyectos personales y una que otra página web de amigos, pero después de recordar el martirio que es encontrar un hosting flexible decidí emprender para ofrecer mis servicios a estudiantes o programadores que aún no cuentan con el capital suficiente para poder pagar un hosting dedicado.

Así que se interesa :) puedes visitar mi página web: https://www.adagioti.com/Servicios/ConsultoriaTI
O directamente la tienda: https://ventas.adagioti.com/cart.php?gid=3

Para conocer más sobre los servicios que te ofrezco. 

Crear una conexion MySQL + NetCore (Ejemplo CRUD)

En esta entrada aprenderemos a crear una conexión entre MySQL y NetCore utilizando EntityFramework. 

Primer paso, abrimos una consola de comandos [ en mi caso CMD / Windows 10 ] y crearemos la estructura de la aplicación utilizando Yeoman 

En el interprete de comando escribimos la siguiente instrucción: 

yo aspnet 

Como nombre le pondré mysqltest para hacer referencia a que estaremos trabajando en hacer una prueba de conexión a MySQL 

Abrimos el folder de la aplicación con Visual Studio Code 

Buscamos el archivo Project.json y agregaremos las siguientes líneas de código: 

En el apartado Dependencias (Dependencies): 

"Microsoft.EntityFrameworkCore.InMemory": "1.0.1",    "Microsoft.EntityFrameworkCore": "1.0.1",    "MySql.Data.EntityFrameworkCore": "7.0.6-IR31",    "Microsoft.EntityFrameworkCore.Tools": { 

     "version": "1.0.0-preview2-final", 

     "type": "build"

    }

En el apartado tools agregaremos las siguientes líneas:

"Microsoft.EntityFrameworkCore.Tools": {
      "version": "1.0.0-preview2-final",
      "imports": [
        "portable-net45+win8+dnxcore50",
        "portable-net45+win8"
      ]
    } 

Después de realizar esta modificación, VSC nos preguntará que si deseamos restaurar las dependencias, eliges la opción Restore y esperamos a que las dependencias sean restauradas. El tiempo de restauración dependerá en gran medida de tu conexión a Internet.

Ahora abrimos el archivo appsettings.json y agregamos la siguiente cadena de conexión:

,

  "ConnectionStrings": {
    "DefaultConnection": "server=localhost;userid=tuusuario;pwd=tupassword;port=3306;database=mysqltest;sslmode=none;"
  },
  "Data": {
    "AuroraConnection": {
      "InMemoryProvider": false
    }
  }

Donde los apartados tuusuario y tupassword equivalen a tu usuario y contraseña local.

Ahora, procederemos a crear una carpeta con el nombre Entities y otra con el nombre Infraestructura.

Creamos una nueva entidad de nombre Persona dentro de la carpeta Entities

namespace mysqltest.Entities
{
    public class Persona {
        public int Id {get;set;}
        public string Nombre {get;set;}
        public string Telefon {get;set;}
        public string Direccion {get;set;}
    }
}

Ahora, dentro de la carpeta Infraestructure crearé una clase llamada MySqlContexto.cs que contendrá el contexto de la aplicación.

using Microsoft.EntityFrameworkCore;
using mysqltest.Entities;
namespace mysqltest.Infraestructura
{
    public class MySqlContexto: DbContext
    {
        public MySqlContexto(DbContextOptions<MySqlContexto> options )
        :base (options){}
        //Databaseset
        public DbSet<Persona> Personas {get;set;}
    }
} 

Ahora nos dirigimos al archivo Startup.cs y agregamos la siguiente línea de código


        public void ConfigureServices(IServiceCollection services)
        {
             string sqlConnectionString = Configuration["ConnectionStrings:DefaultConnection"];
            bool useInMemoryProvider = bool.Parse(Configuration["Data:AuroraConnection:InMemoryProvider"]);

            // Add framework services.
            services.AddDbContext<MySqlContexto>(options =>
            {
                switch (useInMemoryProvider)
                {
                    case true:
                        options.UseInMemoryDatabase();
                        break;
                    default:
                        options.UseMySQL(sqlConnectionString);
                        break;
                }
            });
            // Add framework services.
            services.AddMvc();
        }

Ahora abrimos el Terminal CTRL + ñ y ejecutaremos las siguientes instrucciones:

dotnet ef migrations add inicial

ahora ejecuta

dotnet ef database update

Este ultimo comando nos creará la estructura de la base de datos a partir de la entidad

Ahora le daremos funcionalidad a la aplicación, vamos a crear un controlador llamado PersonasController dentro de la carpeta Controller

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using mysqltest.Entities;
using mysqltest.Infraestructura;
namespace mysqltest.Controllers
{
    public class PersonasController : Controller
    {
        private readonly MySqlContexto _contexto;
        public PersonasController(MySqlContexto contexto)
        {
            _contexto = contexto;
        }
        //Retorna la información contenida en la base de datos
        public async Task<IActionResult> Index(){
            return View(await _contexto.Personas.ToListAsync());
        }
        //Detalles de la persona
        public async Task<IActionResult> Detalles(int id){
            if(id==null)
            {
                return NotFound();
            }
            var persona = await _contexto.Personas.SingleAsync(p=>p.Id == id);
            if(persona==null)
            {
                return NotFound();
            }
            return View(persona);
        }
      public IActionResult Create()
      {
          return View();
      }
      [HttpPost]
      [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> Create (Persona p)
        {
            if(ModelState.IsValid)
            {
                _contexto.Personas.Add(p);
                await _contexto.SaveChangesAsync();
                return RedirectToAction("Index");
            }
            return View(p);
        }
        public  async Task<IActionResult> Editar(int Id)
      {
          if(Id == null)
          {
              return NotFound();
          }
          var p = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id== Id);
          if(p== null)
          {
              return NotFound();
          }
          return View(p);
      }
      [HttpPost]
      [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> Editar (Persona p)
        {
         
          if(p.Id == 0)
          {
              return NotFound();
          }
          if(ModelState.IsValid){
              try{
                  _contexto.Update(p);
                  await _contexto.SaveChangesAsync();
              }catch(DbUpdateConcurrencyException)
              {
                  return RedirectToAction("Index");
              }
                  return RedirectToAction("Index");
          }
            return View(p);
        }
        public async Task<IActionResult> Borrar(int id)
        {
            if(id==null)
            {
                return NotFound();
            }
            var persona = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id == id);
            if(persona == null)
            {
                return NotFound();
            }
            return View(persona);
        }
        [HttpPost, ActionName("Borrar")]
        [ValidateAntiForgeryTokenAttribute]
        public async Task<IActionResult> DeleteConfirmed(int id)
        {
            var p = await _contexto.Personas.SingleOrDefaultAsync(per => per.Id == id);
            _contexto.Personas.Remove(p);
            await _contexto.SaveChangesAsync();
            return RedirectToAction("Index");  
        }
    }
}

Dentro de la carpeta Views crearemos un nuevo folder al que le pondremos por nombre Personas, dentro de la carpeta Personas creamos los siguiente archivos:

Index.cshtml,

@model IEnumerable<mysqltest.Entities.Persona>
@{
    ViewData["Title"] = "Inicio Personas";
}
<h2>Index</h2>
<p>
    <a asp-action="Create">Nuevo Registro</a>
</p>
<table class="table">
        <thead>
            <tr>
                <th>Nombre</th>
                <th>Dirección</th>
                <th>Teléfono</th>
                <th></th>
                </tr>
        </thead>
        <tbody>
            @foreach(var item in Model)
            {
                <tr>
                    <td>@Html.DisplayFor(modelItem=> item.Nombre)</td>
                    <td>@Html.DisplayFor(modelItem=> item.Direccion)</td>
                    <td>@Html.DisplayFor(modelItem=> item.Telefon)</td>
                    <td> <a asp-action="Editar" asp-route-id="@item.Id"> Editar</a> |<a asp-action="Borrar" asp-route-id="@item.Id"> Borrar</a></td>
                 </tr>
            }
        </tbody>
</table>

Create.cshtml,

@model mysqltest.Entities.Persona
@{
    ViewData["Title"] = "Crear un nuveo registro de Personas";
}
<h2>Nuevo registro</h2>
 @using (Html.BeginForm())
        {
           
                    @Html.AntiForgeryToken()
                    @Html.ValidationSummary(true)
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Nombre:</label>
                        <div class="col-sm-4">
                            @Html.TextBoxFor(model=>model.Nombre)
                        </div>
                    </div>
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Direccion</label>
                        <div class="col-sm-4">
                            @Html.TextAreaFor(model =>model.Direccion)
                        </div>
                    </div>
                    <div class="form-horizontal">
                        <label class="col-sm-2 control-label">Telefono</label>
                        <div class="col-sm-4">
                            @Html.TextBoxFor(model=>model.Telefon)
                        </div>
                    </div>
                   
                        <button type="submit" class="btn btn-success btn-rounded">Guardar</button>
        }

Borrar.cshtml

@model mysqltest.Entities.Persona
@{
    ViewData["Title"] = "Eliminar registro de Personas";
}
<div class="alert alert-danger fade in">
    <h4>Aurora confirmaciones</h4>
    <p>¿Estás completamente que quieres eliminar el siguiente elemento: @Html.DisplayFor(model => model.Nombre) del sistema? </p>
    <p>
        @using (Html.BeginForm())
        {
            @Html.AntiForgeryToken()
            <div class="form-actions no-color">
                <div class="btn-group-list pull-right">
                    <input type="submit" value="Eliminar" class="btn btn-rounded btn-danger " />
                </div>
            </div>
        }
    </p>
</div>

Descarga el código fuente desde mi repositorio Git Hub Descargar

Preparando el proyecto del Servicio Nacional del Empleo Unidad Lázaro Cárdenas.

Esta vez tengo la oportunidad de realizar un sistema para mejorar el servicio que brinda la oficina del Servicio Nacional del Empleo Unidad Lázaro Cárdenas.

El proyecto surge de una necesidad para automatizar la forma en la que se general los reportes, centralizar la información, acelerar el tiempo de atención del personal que va a consultar vacantes, así como también de las empresas que ofrecen una vacante.

Para este proyecto pretendo utilizar las siguientes Tecnologías.

Para el desarrollo

1. Microsoft NETCORE en su versión 1.0 
2. MySQL 5.5 (MariaDB) 
3. Visual Studio Code. 
4. Angular2 + TypeScript 
5. Windows 10. 

Despliegue 

1. Linux Ubuntu 16.04 64bits Virtualización VMWare. 

De aquí en adelante iré narrando todo el proceso de desarrollo de la Aplicación. 

1. Abriré una terminal y escribiré el siguiente comando yo aspnet asumiendo que tienes instalado Yeoman con Aspnetcore instalado. 

En la ventana de opciones elegiré Web Application Basic [ Without Membership And Authorization]

A continuación me pregunta con que framework web quiero trabajar, para el proyecto trabajaré con BootStrap 3.3.6

Posteriormente preguntará que nombre le queremos poner, en mi caso le pondre snelazaro

A continuación damos Enter para que nos cree la estructura del proyecto, a continuación obtendremos la estructura básica del proyecto.

Lo que ahora toca realizar es dotnet restore para restaurar las dependencias y dotnet run para poder ver el funcionamiento de la estructura en el navegador. 

Pero antes de ejecutar estos comandos incluiremos las siguientes dependencias con las que vamos a trabajar en todo el desarrollo de la aplicación. 

Estas entradas deberemos de incluirlas en nuestro archivo project.json apartado dependencies.

"Microsoft.AspNetCore.Identity": "1.0.0",
"Microsoft.AspNetCore.Mvc.TagHelpers": "1.0.1",
"Microsoft.EntityFrameworkCore.InMemory": "1.0.1",
"Microsoft.EntityFrameworkCore": "1.0.1",
"MySql.Data.Core": "7.0.4-IR-191",
     "MySql.Data.EntityFrameworkCore": "7.0.4-IR-191",
     "Microsoft.EntityFrameworkCore.Tools": {
      "version": "1.0.0-preview2-final",
      "type": "build"
    },

A continuación guardamos y ejecutamos el comando dotnet restore, con esto restauraremos todas las dependencias con las que queremos trabajar.

A continuación ejecutamos el comando dotnet run para comprobar que la aplicación fue creada con éxito, para ello escribimos en el navegador: http://localhost:5000 y nos deberá de presentar la pantalla de bienvenida a ASPNET CORE

En las siguientes entradas iremos diseñando la funcionalidad de la aplicación. 

Desarrollo Independiente - Proyecto Aurora [ Sistema de Inventarios ]

Recientemente regresé a mi ambiente natural que es el desarrollo de sistema y programación, aunque estoy mucho más orientado al ambiente de trabajo de Procesos, diseñar, planificar, verificar y mejora continua, siempre me ha gustado mantenerme al tanto de los avances en el área de desarrollo, no por algo en mi biblioteca personal cuento con uno de los que he considerado uno de los mejores libros que leí en la Universidad: Ingeniería de Software de Iam Sommerville en su 9 edición :).

Actualmente soy padre de una hermosa nena a la cual, en mis ratos libres le dedico mi tiempo, hoy estoy trabajando en un proyecto personal desarrollado en ASP.NET programado en C#, combinando el Framework Materializecss, BootStrap, jdatatables y Jquery. he de señalar que no soy un experto en esto del desarrollo, se me da más las áreas de análisis y diseño de sistemas, pero no me limito y siempre que puedo trato de meterle mano a esto.

Aurora, es un sistema en su concepción básica para la gestión de inventarios, la idea nace a raíz de que mi ex esposa entro a trabajar a una clínica en la cual no cuentan con un software que permita la automatización y el control de los medicamentos utilizados en la misma ¿vaya forma de aprovechar oportunidades? Bueno aquí les dejo mi primer avance.

Puestos

Gestión de Categoría de Empleados

Consiste en el módulo de creación de puestos, mismos que serán utilizados al momento de dar de alta al personal.


Por último, este sistema no persigue un fin de lucro, cuando ya tenga un 15% avanzado, o sea ya funcionen como deben de ser algunas partes, haré público el código fuente en mi cuenta Git

COPY, UNA ALTERNATIVA A DROPBOX PARA PEQUEÑAS EMPRESAS Y EQUIPOS DE TRABAJO

Comenzaré este artículo con una breve experiencia personal. 

En los establecimientos que he visitado, ya sea papelerías, negocios de venta de comida rápida, instituciones gubernamentales o negocios familiares siempre noto la cajita de Dropbox del lado del reloj y maravillado con la herramienta, pues en efecto puedes almacenar tus archivos y compartirlos con otras personas o colegas de trabajo facilita el intercambio de información en un abrir y cerrar de ojos, como una excelente alternativa al correo electrónico.

Minutas de Trabajo, reuniones y Experiencia

Hoy tuve la fortuna de participar en una capacitación que brinda la empresa en la que actualmente trabajo, mi participación estuvo centrada en la identificación de las necesidades de los usuarios en el apartado de la documentación y los servicios de soporte que actualmente brindamos sin embargo como experiencia personal puedo destacar lo siguiente:

Configuración de Arduino Uno R3 Windows 8

Hace bastante tiempo que no escribo en este blog, en realidad el trabajo y la escuela me consumieron por completo :S pero prometo colocar nuevamente entradas :)

En esta ocasión compartiré con ustedes una pequeña guía que escribí sobre la configuración del Arduino UNO R3 sobre Windows 8, la necesidad la tuve porque tengo un equipo nuevo que aún tiene garantía e instalarle Windows 7 supondría la perdida de la misma, según los términos de la misma espero que a más de uno le llegue a servir.




De igual forma les comparto el archivo de configuración que me funciono y un accesso directo a la descarga de la guía por si no la pueden ver.

Archivos de configuración: http://www.mediafire.com/?kcll29y3xcv7vrv
Guía en PDF: https://www.box.com/s/70mmqybn15ls4g3qu1p1

ACDC v1 Acid Demostration Calculator

Se trata de una calculadora básica diseñada para servidores que siguen la normativa Gravity, es decir “originales”, la formula y damage esta basado en las especificaciones proporcionadas por iRO-Wiki en el siguiente enlace:  http://irowiki.org/wiki/Acid_Bomb

Especificaciones:

Java Version “1.6.0.21” O superior
Pantalla: 800 x 600 pixeles o superior
Multiplataforma
Procesador 1.0 Ghz o Superior
Memoria 512 Ram o Superior.

Descargar enlace:http://depositfiles.com/files/gi91zqvto

Implementando interfaces en Java

Una de las ventajas de la programación orientada a objetos es la posibilidad de poder crear un código mucho más elegante, ordenado y reutilizable frente a la programación estructurada; esta vez vamos a hablar un poco de las interfaces utilizadas en la programación basada en Java; cabe de señalar que este mismo concepto se puede a aplicar a la programación en C++.
Definición Informal de una interfaz: según la Wikipedia es una colección de métodos abstractos y propiedades. En ella se especifica que es lo que se debe hacer pero no su implementación.
Cómo un ejemplo práctico realizare una pequeña interfaz que despliegue el mensaje “Hola Mundo”, el editor que utilizaré para este ejemplo es BlueJ.
Primero crearemos un nuevo proyecto al cual yo le he puesto interfaces, ustedes pueden optar por el nombre que quieran.

Ahora crearemos una interfaz (interface) a la cual yo le puse por nombre data, está interfaz incluye el siguiente código:

public interface data{ 
 public String holaMundo(String mensaje);
}

holaMundo, es el método que será implementado a futuro por otras clases, esta interfaz en su diseño almacenará información de datos dados por el usuario, pero en este ejemplo solo utilizaré un método para desplegar el mensaje; cabe de señalar que una interfaz puede incluir datos miembros los cuales deben de declararse como static o final.
Ahora creare una nueva clase la cuál ha de implementar los métodos de la interfaz, a esta clase yo le he puesto el nombre de “metodos”, está incluye el siguiente fragmento de código:

public class metodos implements data
{
  public metodos(){
    } 
   public String holaMundo(String mensaje){
        return mensaje;
    }
}

Está clase implementa los métodos de la interfaz llamada data, aquí se realizan las operaciones básicas de los métodos de la interfaz.
Por último crearemos la clase principal que controla el programa para ver nuestro método en función.
public class principal
{
   
    /**
     * Constructor for objects of class principal
     */
    public principal()
    {
      }
    public static void main (String [] arguments){
        metodos m= new metodos();
        System.out.println (m.holaMundo("Hola Mundo"));
    }
}
Como podemos observar, el uso de interfaces hace un poco más elegante el código ayudando de una forma a reutilizar las clases e interfaces en futuros programas, así nos ahorraremos líneas de código a futuro.

No es lo mismo estudiar para un examen de cálculo que programar.

Hace unos días, para ser exactos el día jueves 28 de octubre presentamos el examen de programación avanzada, ciertamente para algunos un examen común y corriente "facil" en el contexto, pero para otros su peor pesadilla. 

Escribo este artículo como una reflexión personal, centrándome en dos materias importantes, aunque con fines diferentes.

¿Por qué estudiar para un examen de programación es distinto que para uno de matemáticas?, aunque son afines tienen sus diferencias, en matemáticas los algoritmos para la resolución del problema ya están predefinidos, es, solamente seguir los pasos tal cual se te han indicado; programación difiere mucho, pues, para poder concebir un programa dispones de un sinfín de alternativas para poder estructurarlo, entonces ¿por qué a muchos se les dificulta entender los algoritmos cuándo son buenos en materias como álgebra o cálculo?, puedo deducir que tal vez no les guste la materia de programación o que simplemente no ponen empeño en entenderla, el intentar estudiar "programación" como se si tratase de una materia más dentro de la curricula de estudios, seguir los pasos tal cual el maestro los dio... supone un grave problema a la hora de la resolución del algoritmo, pues, para programar lo primero que siempre se debe tomar en cuenta es ¿qué se quiere hacer? o ¿qué se quiere solucionar?.

Muchas veces he observado que intentan solucionar el problema tal cual se determina, intentando seguir los pasos de alguien que ya tiene estructurado su cerebro de tal manera que, cuándo se le entrega un problema de programación ya sabe lo que tiene que hacer. Programar, no es directamente sentarse a escribir millones de líneas de código a lo loco, se trata de comprender la problemática, que variables hay en juego así como determinar la mejor solución, pero para determinar la mejor solución debes de esforzarte en estudiar y entender para que te va a servir a futuro lo que estas estudiando, esto significa que no solo estudies por estudiar para pasar un examen, se trata de comprender los conceptos, de saber de que se te esta hablando, que alguien lleve ya varios años programando no significa que tú no puedas aprender a hacerlo, pues se supone que la persona que te lleva ventaja en un momento en su vida estúbo como estas ahorita tú... aprendiendo, pero ¿qué marca la diferencia? tal vez esa persona dedico el tiempo suficiente para aprender, le cayo el 20 de que ya estaba en la Universidad en segundo año de Ingenieria en Sistemas, se volvio autodidacta, aprendio a resolver las cosas. 

¿Por qué estudiar programación?, a caso no vez lo que puedes crear con semejante arma "la mente", o quieres ser otro borreguito Facebookcero, twittero, MySpacero, Chateador, que solo le interesa pasar, obtener un título más, sumarse a la lista de "pseudo-titulados" que al final dicen no hay trabajo?, si tan solo abrieras la mente un poco, pensaras... bien, me lleva tantas horas resolver un problema de Cálculo... ¿por qué no lo programo?, así tanto ejercitas tu práctica como programador, como repasas en paralelo algo de cálculo o de otra materia. 

No esperes que alguien te enseñe a programar, pues programación es un arte, en la cual, el artista principal eres tú, donde esa arte se puede embellecer aplicando un poco de disciplina; esa disciplina implica ser autodidacta y el ser autodidacta te abre mucho más posibilidades de posicionarte en el campo profesional por el conocimiento adquirido.

for (int i=0; i<=3; i++)

{

  printw("Hola Mundo");  

}

do{

   printw("hola mundo");

  i++;

}while (i<=3);

Las barreras solo tu te las pones, programar no es lo mismo que derivar, la soltura para resolver un algoritmo es lo que hace de la programación una de las disciplinas más versátiles para explotar la imaginación y el C.I.