Site is under maintenance mode. Please wait few min!
Saltar al contenido

Cómo instalar R en Ubuntu 14.04

marzo 4, 2020

 

Introducción

para recibir el pago por bienes y servicios proporcionados, las empresas deben enviar facturas a sus clientes para informarles de los servicios que se le cobrará por. En aquel entonces, la gente tenía las facturas en papel que dieron a los clientes cuando en contacto con ellos por sus servicios. Con el advenimiento y el avance de la tecnología, las personas ahora son capaces de enviar facturas electrónicas a sus clientes.

En este tutorial se va a construir una aplicación de facturación usando Vue y NodeJS. Esta aplicación va a realizar funciones tales como crear, enviar, editar y eliminar una factura. Requisitos

Para seguir a través del artículo de manera adecuada, necesitará lo siguiente:

  • nodo instalado en su máquina
  • Node Package Manager (NPM) instalado en su máquina

Ejecutar el siguiente nodo para verificar que es instalado en su máquina:

node --version

    nodo

  • –version

Ejecutar lo siguiente para verificar que la NGP está instalado en su máquina:

npm --version

  • NPM –version

Si obtiene los números de versión como resultado entonces’ re listo para proceder.

Paso 1 – Configuración del servidor

Ahora que tenemos todos los requisitos establecidos, el siguiente paso es crear el servidor back-end para la aplicación. El servidor back-end mantendrá la conexión a la base de datos.

de inicio mediante la creación de una carpeta para albergar el nuevo proyecto:

mkdir invoicing-app

  • mkdir facturación aplicación

inicializarlo como un proyecto del nudo:

cd invoicing-app && npm init

  • cd facturación aplicación && NPM init

Para el servidor de funcionar apropiadamente, hay algunos paquetes de nodos que necesitan ser instalados. Se pueden instalar mediante la ejecución de este comando:

npm install --save express body-parser connect-multiparty sqlite3 bluebird path umzug bcrypt

  • NPM instalar sqlite3 –save expresa cuerpo-analizador de conexión-multipartidista pájaro azul umzug ruta bcrypt

Este comando instala los siguientes paquetes:

  • bcrypt al usuario hash de contraseñas
  • expresar al poder de nuestra aplicación web sqlite3
  • para crear y mantener la base de datos ruta
  • a rutas de archivos se resuelven dentro de nuestra aplicación
  • Bluebird utilizar promesas al escribir migraciones
  • umzug como corredor tarea para ejecutar nuestro cuerpo- migraciones de bases de datos
  • analizador y connect-multipartidista forma de manejar solicitudes entrantes

Crear un archivo server.js que albergará la lógica de la aplicación:

touch server.js

  • toque server.js

En el archivo server.js, importar los módulos necesarios y crear una aplicación expresa:

const express = require('express')
const bodyParser = require('body-parser');
const sqlite3 = require('sqlite3').verbose();
const PORT = process.env.PORT || 3128;

const app = express();
app.use(bodyParser.urlencoded({extended: false}));
app.use(bodyParser.json());

[...]

Crear un / a prueba de ruta que las obras de servidor:

[...]

app.get('/', function(req,res){
res.send("Welcome to Invoicing App");
});

app.listen(PORT, function(){
console.log(`App running on localhost:${PORT}`);
});

app.listen () le dice el servidor el puerto de escucha para las rutas entrantes. Para iniciar el servidor, ejecute lo siguiente en el directorio del proyecto: servidor de nodo

node server

Su aplicación comenzará ahora a escuchar las peticiones entrantes.

Paso 2 – Creación y la conexión a base de datos mediante SQLite

Para una aplicación de facturación, se necesita una base de datos para almacenar las facturas existentes. SQLite va a ser el cliente de base de datos de elección para esta aplicación.

de inicio mediante la creación de una carpeta de base de datos: mkdir

mkdir database

A continuación, se mueven en el nuevo directorio y crear un archivo de base de datos:

cd database && touch InvoicingApp.db

  • base de datos de CD && toque InvoicingApp.db

En la base de datos directorio, ejecute el cliente sqlite3:

invoicing-app/database/ sqlite3

  • facturación aplicación / base de datos / sqlite3

Abrir la base de datos InvoicingApp.db:

.open InvoicingApp.db

  • .open InvoicingApp.db

Ahora que la base de datos ha sido seleccionado, lo siguiente es crear las tablas necesarias.

Esta aplicación va a utilizar tres tablas: Usuarios

  • – Este contendrá los datos de usuario (ID, nombre, correo electrónico, company_name, contraseña)
  • Facturas – Almacenar los datos de una factura (id, nombre, pagado, user_id)
  • transacciones

  • – Singular transacciones que se unen para hacer una factura (nombre, precio, invoice_id)

Dado que se han identificado las tablas necesarias, el siguiente paso es ejecutar las consultas para crear las tablas.

migraciones se utilizan para realizar un seguimiento de los cambios en una base de datos como la aplicación crece. Para ello, cree un migraciones carpeta en el directorio de base de datos.

mkdir migrations

  • migraciones mkdir

Este albergarán todos los archivos de migración.

Ahora, crear un archivo en la carpeta 1.0.js migraciones. Esta convención de nomenclatura es hacer un seguimiento de los cambios más recientes.

cd migations && touch 1.0.js

  • cd migations && toque 1.0.js

En el archivo 1.0.js, primero importar los módulos de nodo:

"use strict";
const Promise = require("bluebird");
const sqlite3 = require("sqlite3");
const path = require('path');

[...]

Entonces, la idea ahora es exportar una función hasta que se ejecutará cuando el archivo de migración y se ejecuta una función a revertir los cambios en la base de datos.

[...]
module.exports = {
up: function() {
return new Promise(function(resolve, reject) {
/* Here we write our migration function */
let db = new sqlite3.Database('./database/InvoicingApp.db');
// enabling foreign key constraints on sqlite db
db.run(`PRAGMA foreign_keys = ON`);

[...]

En la función de arriba, la conexión se realiza primero en la base de datos. A continuación, las claves externas están habilitadas en la base de datos SQLite. En SQLite, claves externas son desactivados por defecto para permitir la compatibilidad hacia atrás, por lo que las claves externas tienen que ser habilitado en cada conexión.

A continuación, especifique las consultas para crear las tablas:

[...]
db.serialize(function() {
db.run(`CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT,
email TEXT,
company_name TEXT,
password TEXT
)`);

db.run(`CREATE TABLE invoices (
id INTEGER PRIMARY KEY,
name TEXT,
user_id INTEGER,
paid NUMERIC,
FOREIGN KEY(user_id) REFERENCES users(id)
)`);

db.run(`CREATE TABLE transactions (
id INTEGER PRIMARY KEY,
name TEXT,
price INTEGER,
invoice_id INTEGER,
FOREIGN KEY(invoice_id) REFERENCES invoices(id)
)`);
});
db.close();
});
},
[...]

La función serialize () se utiliza para especificar que las consultas serán corrió de forma secuencial y no simultáneamente.

Posteriormente, las consultas para revertir los cambios también se especifican en la función de abajo ():

[...]

down: function() {
return new Promise(function(resolve, reject) {
/* This runs if we decide to rollback. In that case we must revert the `up` function and bring our database to it's initial state */
let db = new sqlite3.Database("./database/InvoicingApp.db");
db.serialize(function() {
db.run(`DROP TABLE transactions`);
db.run(`DROP TABLE invoices`);
db.run(`DROP TABLE users`);
});
db.close();
});
}
};

Una vez creados los archivos de migración, el siguiente paso que se está ejecutando para hacer los cambios en la base de datos. Para ello, cree una carpeta scripts de la raíz de la aplicación: secuencias de comandos mkdir

mkdir scripts

A continuación, crear un archivo llamado migrate.js:

cd scripts && touch migrate.js

  • cd guiones && migrate.js táctiles

Agregue la siguiente en el fichero de migrate.js:

const path = require("path");
const Umzug = require("umzug");

let umzug = new Umzug({
logging: function() {
console.log.apply(null, arguments);
},
migrations: {
path: "./database/migrations",
pattern: /.js$/
},
upName: "up",
downName: "down"
});

[...]

en primer lugar, los módulos de nodos necesarios son importados. A continuación, un nuevo objeto umzug se crea con las configuraciones. La ruta y el patrón de los guiones de las migraciones también se especifican. Para obtener más información sobre las configuraciones, diríjase a la página umzug GitHub.

Para también dan algunos detallado retroalimentación, crear una función para registrar sucesos como se muestra a continuación y, finalmente, ejecutar la función para ejecutar las consultas de bases de datos que se especifican en las migraciones carpeta:

[...]

function logUmzugEvent(eventName) {
return function(name, migration) {
console.log(`${name} ${eventName}`);
};
}

// using event listeners to log events
umzug.on("migrating", logUmzugEvent("migrating"));
umzug.on("migrated", logUmzugEvent("migrated"));
umzug.on("reverting", logUmzugEvent("reverting"));
umzug.on("reverted", logUmzugEvent("reverted"));

// this will run your migrations
umzug.up().then(console.log("all migrations done"));

Ahora, para ejecutar la secuencia de comandos, vaya a su terminal y en el directorio raíz de la aplicación, ejecute:

~/invoicing-app node scripts/migrate.js up

  • ~ / facturación aplicación guiones nodo / migrate.js hasta

verá una salida similar a la siguiente:

Output all migrations done
== 1.0: migrating =======
1.0 migrating

Paso 3 – Creación de Rutas de aplicación

ahora que la base de datos se establece de manera adecuada hacia arriba, el siguiente paso es volver al archivo server.js y crear las vías de aplicación. Para esta aplicación, las siguientes rutas estarán disponibles:

Para registrar un nuevo usuario, se hará una petición posterior a la / registrarse vía de su servidor. Esta ruta se verá así: se hace

[...]
const bcrypt = require('bcrypt')
const saltRounds = 10;
[...]

app.post('/register', function(req, res){
// check to make sure none of the fields are empty
if( isEmpty(req.body.name) || isEmpty(req.body.email) || isEmpty(req.body.company_name) || isEmpty(req.body.password) ){
return res.json({
'status' : false,
'message' : 'All fields are required'
});
}
// any other intendend checks

[...]

una comprobación para ver si alguno de los campos están vacíos y si los datos enviados partidos todas las especificaciones. Si se produce un error, un mensaje de error se envía al usuario como una respuesta. Si no es así, la contraseña es hash y los datos son luego almacenados en la base de datos y se envía una respuesta al usuario informándole que están registrados.

bcrypt.hash(req.body.password, saltRounds, function(err, hash) {
let db = new sqlite3.Database("./database/InvoicingApp.db");
let sql = `INSERT INTO users(name,email,company_name,password) VALUES('${
req.body.name
}','${req.body.email}','${req.body.company_name}','${hash}')`;
db.run(sql, function(err) {
if (err) {
throw err;
} else {
return res.json({
status: true,
message: "User Created"
});
}
});
db.close();
});
});

Si un usuario intenta existentes para iniciar sesión en el sistema utilizando la ruta / entrada, que necesitan para facilitar su dirección de correo electrónico y contraseña. Una vez que lo hagan, la ruta controla la solicitud de la siguiente manera:

[...]

app.post("/login", function(req, res) {
let db = new sqlite3.Database("./database/InvoicingApp.db");
let sql = `SELECT * from users where email='${req.body.email}'`;
db.all(sql, [], (err, rows) => {
if (err) {
throw err;
}
db.close();
if (rows.length == 0) {
return res.json({
status: false,
message: "Sorry, wrong email"
});
}

[...]

se realiza una consulta a la base de datos para buscar el registro del usuario con un correo electrónico en particular. Si el resultado devuelve una matriz vacía, entonces significa que el usuario no existe, y se envía una respuesta que informa al usuario del error.

Si los datos de rendimientos de usuario consulta la base de datos, se realiza una comprobación adicional para ver si la contraseña introducida coincide con la contraseña de la base de datos. Si lo hace, entonces se envía una respuesta con los datos del usuario.

[...]
let user = rows[0];
let authenticated = bcrypt.compareSync(req.body.password, user.password);
delete user.password;
if (authenticated) {
return res.json({
status: true,
user: user
});
}
return res.json({
status: false,
message: "Wrong Password, please retry"
});
});
});

[...]

Cuando se prueba la ruta, recibirá ya sea un resultado exitoso o fracasado. El

/ ruta factura se encarga de la creación de una factura. Datos que se pasa a la ruta incluirá el ID de usuario, nombre de la factura, y el estado de la factura. También incluirá las transacciones singulares para compensar la factura.

Las asas servidor la solicitud de la siguiente manera:

[...]
app.post("/invoice", multipartMiddleware, function(req, res) {
// validate data
if (isEmpty(req.body.name)) {
return res.json({
status: false,
message: "Invoice needs a name"
});
}
// perform other checks

[...]

En primer lugar, los datos enviados al servidor son validados. A continuación, se realiza una conexión a la base de datos para las consultas posteriores.

[...]
// create invoice
let db = new sqlite3.Database("./database/InvoicingApp.db");
let sql = `INSERT INTO invoices(name,user_id,paid) VALUES(
'${req.body.name}',
'${req.body.user_id}',
0
)`;
[...]

La consulta INSERT necesario para crear la factura está escrito y luego ejecutado. Posteriormente, las transacciones singulares se insertan en la tabla de transacciones con el invoice_id como clave externa para hacer referencia a ellos.

[...]
db.serialize(function() {
db.run(sql, function(err) {
if (err) {
throw err;
}
let invoice_id = this.lastID;
for (let i = 0; i < req.body.txn_names.length; i++) { let query = `INSERT INTO transactions(name,price,invoice_id) VALUES( '${req.body.txn_names[i]}', '${req.body.txn_prices[i]}', '${invoice_id}' )`; db.run(query); } return res.json({ status: true, message: "Invoice created" }); }); }); [...]

Una vez que esto se ejecuta, la factura se ha creado correctamente.

En el registro de la base de datos SQLite, el siguiente resultado se obtiene:

sqlite> select * from invoices;
1|Test Invoice New|2|0
sqlite> select * from transactions;
1|iPhone|600|1
2|Macbook|1700|1

Ahora, cuando un usuario desea ver todas las facturas creadas, el cliente deberá realizar una solicitud GET a la / / factura / user: vía ID. El user_id se pasa como un parámetro de ruta. La solicitud se maneja como sigue:

[...]
app.get("/invoice/user/:user_id", multipartMiddleware, function(req, res) {
let db = new sqlite3.Database("./database/InvoicingApp.db");
let sql = `SELECT * FROM invoices LEFT JOIN transactions ON invoices.id=transactions.invoice_id WHERE user_id='${req.params.user_id}'`;
db.all(sql, [], (err, rows) => {
if (err) {
throw err;
}
return res.json({
status: true,
transactions: rows
});
});
});

[...]

Una consulta se ejecuta a buscar todas las facturas y las transacciones relacionadas con la factura que pertenece a un usuario particular.

a buscar una factura específica, una petición GET se hace con la user_id y invoice_id a la / factura / usuario / {user_id} / {} invoice_id ruta. La solicitud se maneja como sigue:

[...]

app.get("/invoice/user/:user_id/:invoice_id", multipartMiddleware, function(req, res) {
let db = new sqlite3.Database("./database/InvoicingApp.db");
let sql = `SELECT * FROM invoices LEFT JOIN transactions ON invoices.id=transactions.invoice_id WHERE user_id='${
req.params.user_id
}' AND invoice_id='${req.params.invoice_id}'`;
db.all(sql, [], (err, rows) => {
if (err) {
throw err;
}
return res.json({
status: true,
transactions: rows
});
});
});

// set application port
[...]

Una consulta se corrió a buscar una sola factura y las transacciones relacionadas con la factura que pertenece al usuario.

Conclusión

En este tutorial, configurar el servidor con todas las rutas necesarias para una aplicación de facturación de peso ligero.