# API ConCrédito #
Esta **API** (**A**pplication **P**rogramming **I**nterface) de ConCrédito, es la principal fuente de comunicación para aquellas aplicaciones, principalmente externas, que necesiten transmitir datos para la operatividad, análisis ó gestión sobre la empresa de una manera rápida, fácil y segura.

Se encuentra escrita en PHP y está construida sobre Laravel, un framework bastante versátil y potente, que en opinion compartida, ah sido el framework que rescató la manera de programar en PHP.

## Consideraciones ##
-------------------
El S.O. donde se ha montado todo es: **centOS 6.5** (64bits), sin embargo, no hay limitantes más allá de aquellas diferencias con el gestor de paquetes de instalación y otras cosas más que varían entre los sistemas operativos.

Para fines de este tutorial, todo estará enfocado a **centOS 6.5**, que no me gusta nada pero Abel no me quiso dejar el Ubuntu >.<, es un maldito!

## Requisitos aplicativos ##
-------------------
+ [Apache 2.2+](http://httpd.apache.org/)
    * [ModSecurity 2.9+](https://www.modsecurity.org)
    * [ModEvasive 1.10+](http://www.zdziarski.com/blog/?page_id=442)
- [Git 2.5+](https://git-scm.com/)
* [PHP 5.6+](http://php.net/downloads.php)
    * [PCntl](http://php.net/manual/es/book.pcntl.php)
* [Laravel 5.0](http://laravel.com)
* [Composer 1.0+](https://getcomposer.org/)
* [MySQL 5.5+](http://dev.mysql.com/downloads/repo/apt/)

## Instalación ##
-------------------
1) Instalar Apache si, y solo si, el repositorio cuenta con la versión compatible.
```bash
$ sudo yum install httpd
$ sudo service httpd start
```

2) Instalar MySQL si, y solo si, el repositorio cuenta con la versión compatible.
```bash
$ sudo yum install mysql mysql-server

# Establecer contraseña para root y otras configuraciones, seguir instrucciones...
# Prender el servicio si no lo esta: /etc/init.d/mysqld restart
$ sudo mysql_secure_installation
```

3) Instalar PHP
```bash
$ sudo rpm -Uvh https://mirror.webtatic.com/yum/el6/latest.rpm
# Instalar desde 0
$ sudo yum install yum-plugin-replace
$ sudo yum install php56w-opcache php56w-bcmath php56w-cli php56w-common php56w-dba \
php56w-dba php56w-devel php56w-embedded php56w-enchant php56w-fpm php56w-gd php56w-imap \
php56w-interbase php56w-intl php56w-ldap php56w-mbstring php56w-mcrypt php56w-mssql \
php56w-mysqlnd php56w-odbc php56w-pdo php56w-pecl-gearman php56w-pecl-geoip \
php56w-pecl-memcache php56w-pecl-xdebug php56w-pgsql php56w-process php56w-pspell mod_ssl \
php56w-recode php56w-snmp php56w-soap php56w-tidy php56w-xml php56w-xmlrpc

# Actualizar el php actual
$ sudo yum replace php-common --replace-with=php56w-common

# Instalar módulo PCntl
# Cambiar php-5.6.<version>.tar.gz por la actual, para este caso la más actual es 13
$ cd /usr/local
$ sudo wget http://be.php.net/distributions/php-5.6.<version>.tar.gz
$ sudo tar -xvzf php-5.6.<version>.tar.gz && cd php-5.6.<version>/ext/pcntl/
$ sudo phpize
$ sudo ./configure
$ sudo make
# Movemos el archivo compilado al directorio de los módulos de PHP, para conocer el <directorio-destino>:
$ php -i | grep extension_dir
# y entonces:
$ sudo cp modules/pcntl.so <directorio-destino>
```
4) Instalando GIT
```bash
$ yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel gcc perl-ExtUtils-MakeMaker

# Cambiar git-<version>.tar.gz por la actual, para este caso la más actual es 2.5.2
$ cd /usr/local
$ sudo wget https://www.kernel.org/pub/software/scm/git/git-<version>.tar.gz
$ sudo tar xzf git-<version>.tar.gz && cd git-<version>
$ sudo make prefix=/usr/local/git all
$ sudo make prefix=/usr/local/git install
$ sudo echo "export PATH=$PATH:/usr/local/git/bin" >> /etc/bashrc
$ Sudo source /etc/bashrc
```
5) Instalando ModEvasive
```bash
# Comprobar si el compilador de modulos de Apache2 esta instalado, debe aparecer el manual.
$ man apxs
# De lo contrario, lo instalamos con el siguiente comando:
$ sudo yum install httpd-devel

# A continuación instalamos ModSecurity
$ cd /usr/local
$ sudo wget http://www.zdziarski.com/projects/mod_evasive/mod_evasive_1.10.1.tar.gz
$ sudo tar -xvzf mod_evasive_1.10.1.tar.gz && cd mod_evasive_1.10.1
$ sudo apxs -cia mod_evasive20.c
```
6) Instalando ModSecurity
```bash
# Pre-requisitos...
$ sudo yum install gcc make automake autoconf libtool
$ sudo yum install pcre pcre-devel libxml2 libxml2-devel curl curl-devel httpd-devel

# Instalar G++
# Comprobar si "g++" se encuentra instalado:
$ g++ --version
# De lo contrario, a instalar según el sistema: escoger versión
$ yum search gcc | grep ++
#   Ej.
#       cc44-c++.x86_64 : C++ support for GCC
#       gcc44-objc++.x86_64 : Objective-C++ support for GCC
#       gcc.noarch : Various compilers (C, C++, Objective-C, ...)
#       gcc44.x86_64 : Various compilers (C, C++, Objective-C, ...)
$ sudo yum install gcc48-c++.x86_64

# Instalar CMAKE
$ cd /usr/local
$ sudo wget http://www.cmake.org/files/v3.2/cmake-3.2.3.tar.gz && tar -xvzf cmake-3.2.3.tar.gz && cd cmake-3.2.3
$ sudo ./configure
$ sudo make
$ sudo make install
# Crean un enlace simbolico en "/usr/bin" si no existe.
$ ln -s /usr/local/bin/cmake /usr/bin/

# Instalar YAJL
$ cd /usr/local
$ sudo git clone http://github.com/lloyd/yajl && cd yajl
$ sudo ./configure
$ sudo make
$ sudo make install

# Instalar ModSecurity
$ sudo cd /usr/local
$ sudo git clone https://github.com/SpiderLabs/ModSecurity && cd ModSecurity
$ sudo ./autogen.sh
$ sudo ./configure --with-yajl="/usr/local/lib /usr/local/include"
$ sudo make
$ sudo make install

# Antes de seguir, identificar el <directorio-apache> raíz, después:
$ sudo chmod 755 <direcorio-apache>/modules/mod_security2.so
# Identificar si el modulo YAJL esta cargado:
$ sudo ldd <direcorio-apache>/modules/mod_security2.so | grep liby
  - libyajl.so.2 => not found
# Si no, identificar el <directorio-librerias> (generalmente /lib64) y después:
$ sudo cp /usr/local/lib/libyajl* <directorio-librerias>
$ sudo ldd /etc/httpd/modules/mod_security2.so | grep liby
   # Debe aparecer mas o menos así:
   - libyajl.so.2 => /lib64/libyajl.so.2 (0x00007fb9f7159000)
```
7) Instalando Composer
```bash
$ sudo curl -sS https://getcomposer.org/installer | php -- --filename=composer --install-dir=/usr/bin
```
8) Instalando Laravel
```bash
$ sudo composer global require "laravel/installer=~1.1"
```

## Configuración ##
-------------------
1) Configurando ModSecurity
```bash
# Nos conectamos al servidor a configurar y empezamos:
$ scp -R <origen>:/path/to/api-server-config/httpd/* /etc/httpd
$ cd /etc/httpd/modsecurity-crs/custom_rules
$ sudo wget http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz && gzip -d GeoLiteCity.dat.gz
$ cd /etc/httpd/modsecurity-crs
$ for f in `ls base_rules/`; do sudo ln -s ../base_rules/$f activated_rules/$f; done
$ for f in `ls custom_rules/`; do sudo ln -s ../custom_rules/$f activated_rules/$f; done
$ cd /etc/httpd/conf.d
$ sudo ln -s ../modsecurity-crs/config/modsecurity.conf ./
```
2) Configurando Dominios (VirtualHost)
```bash
# Enlistamos todos los dominios disponibles.
$ ls -lh /etc/httpd/sites-available
# se configuran solo aquellos que apunten al servidor y se agregan '.conf' al nombre del archivo, ejemplo:
$ cd /etc/httpd/sites-enabled
$ ln -s ../sites-available/localhost.produccion ./localhost.conf
$ ln -s ../sites-available/api.concredito.com.mx ./api.concredito.com.mx.conf
```
3) Configurando Dominios (Directorios)
```bash
# Todas las carpetas deben estar situadas en la raíz de los documentos html, utilizaremos el ejemplo
# para el dominio de ASD (API Server Documents): asd.concredito.com.mx
$ sudo cd /var/www/html && mkdir asd.concredito.com.mx
# API ConCrédito: api.concredito.com.mx
$ sudo cd /var/www/html && mkdir api.concredito.com.mx
# etc, etc...
```
4) Configurando PHP
```bash
# Copiar el archivo de configuración:
$ scp <origen>:/path/to/api-server-config/php/php.ini /etc/
# Agregar 'PCNTL', entonces conocer <directorio-base> de configuraciones adicionales PHP:
$ php -i | grep 'additional .ini files'
# y copiar el archivo (ej.- <directorio-base> '/etc/php.d'):
$ scp <origen>:/path/to/api-server-config/php/pcntl.ini <directorio-base>
```
## Instalación y Configuración de API ConCrédito ##
-------------------
Creación de los directorios para el versionamiento:
```bash
$ sudo mkdir /var/www/api.versiones && cd /var/www/api.versiones
```

Clonando los repositorios y renombramos las carpetas
```bash
# API Laravel
$ sudo mkdir v1.0/ && cd $_
$ sudo git init && sudo git remote add origin git@gitlab.concredito.com.mx:innovacion/api-concredito.git
$ sudo git fetch origin dev && sudo git checkout dev
# API Viejita
$ sudo git clone https://concredito@bitbucket.org/suprem/apiconcredito.git v2
```

Permisos y accesos:
```bash
$ cd /var/www/html/api.concredito.com.mx

# version API v1.0:
$ sudo ln -s ../../api.versiones/v1.0/public ./v1.0
$ cd ../../api.versiones/
$ sudo chown apache:apache -R v1.0/
$ sudo chmod 777 -R v1.0/storage

# version API v2:
$ sudo ln -s ../../api.versiones/v2 ./v2
$ cd ../../api.versiones/
$ sudo chown apache:apache -R v2/
$ sudo chmod 777 -R v2/files/credenciales
$ sudo chmod 777 -R v2/files/seguroRC
```
## Actualización de API ConCrédito ##
-------------------
Actualizar de las fuentes
```bash
# Revisar para la versión API v1.0:
$ cd /var/www/api.versiones/v1.0/
$ sudo git checkout -- .            # Elimina todo lo que no esta versionado
$ sudo git pull origin dev

# Si se requiere actualizar ó agregar nuevas dependencias, namespace, entonces:
$ sudo composer self-update         # Actualizar composer
$ sudo composer update              # Actualiza las dependiencias del proyecto
$ sudo composer dump-autoload       # Actualiza los namespace

# Revisar para la versión API v2:
$ cd /var/www/api.versiones/v2/
$ sudo git pull origin master
```

Configuración del Environment
```bash
# Revisar para la versión API v1.0:
$ cd /var/www/api.versiones/v1.0
$ sudo vim .env.produccion
$ sudo cp .env.produccion .env

# Revisar para la versión API v2:
$ cd /var/www/api.versiones/v2
$ sudo vim libs/config.php.produccion
$ sudo cp libs/config.php.produccion libs/config.php
```
## Instalación Driver MongoDB ##
-------------------
Los pasos siguientes muestran la instalación del driver para MongoDB. Para ello es necesario descargar el proyecto <b>master</b> del driver de mongo:
```bash
# git clone https://github.com/mongodb/mongo-php-driver-legacy.git
```
Una vez descargado y descomprimido el driver, accedemos a su carpeta:
```bash
# cd mongo-php-driver-legacy
```

Configuramos y construimos:
```bash
# phpize
# ./configure
# make
# sudo make install
```
Ya instalado el driver, debemos indicar a php que está disponible, creando un archivo en:
```bash
# nano /etc/php.d/mongo.ini
```
Y pegamos la siguiente información
```bash
; Enable mongo extension
extension=mongo.so
```
Reiniciamos apache, y a disfrutar.
```bash
service httpd restart
```