Model could not be loaded while executing query [Phalcon Framework]

i get some trouble when using model query for execute in phalcon framework like this sample and the result :

$query = new Query(
“SELECT * FROM Campaign”,
$this->getDI()
);

Model ‘Campaign’ could not be loaded
#0 [internal function]: Phalcon\Mvc\Model\Manager->load(‘Campaign’, true)
#1 [internal function]: Phalcon\Mvc\Model\Query->_prepareSelect()
#2 [internal function]: Phalcon\Mvc\Model\Query->parse()
#3 /var/www/html/gamanads/app/controllers/AdspaceController.php(185): Phalcon\Mvc\Model\Query->execute()
#4 [internal function]: Vokuro\Controllers\AdspaceController->offerwallAction()
#5 [internal function]: Phalcon\Dispatcher->callActionMethod(Object(Vokuro\Controllers\AdspaceController), ‘offerwallAction’, Array)
#6 [internal function]: Phalcon\Dispatcher->_dispatch()
#7 [internal function]: Phalcon\Dispatcher->dispatch()
#8 /var/www/html/gamanads/public/index.php(41): Phalcon\Mvc\Application->handle()
#9 {main}

how i solve this problem is just, get full path for the model in models folder like this.

$query = new Query(
“SELECT * FROM Vokuro\Models\Campaign”,
$this->getDI()
);

and, taraaaaaa…. works very well.

thankyou.

Memulai Pembuatan Aplikasi Web dengan Express.js (1): Instalasi dan Pengenalan

Express.js adalah satu web framework paling populer di dunia Node.js. Dokumentasinya yang lengkap dan penggunaannya yang cukup mudah, dapat membuat kita mengembangkan berbagai produk seperti aplikasi web ataupun RESTful API. Express.js pun dapat digunakan menjadi pijakan untuk membangun web framework yang lebih kompleks seperti, Sails.js, MEAN (MongoDB, Express.js, Angular.js, Node.js) dan MERN (MongoDB, Express.js, React.js, Node.js). Express.js dibuat oleh TJ Holowaychuk dan sekarang dikelola oleh komunitas.

Beberapa keunggulan yang dimiliki oleh Express.js antara lain:

  • Dukungan pembuatan middleware
  • Dukungan terhadap berbagai HTTP verb seperti POST, GET, PUT, DELETE, OPTION, HEAD, dan lainnya
  • Sudah terpasang template engine Jade
  • manajemen file statik seperti CSS dan Javascript
  • Sangat bebas untuk dikostumisasi

Di tutorial bagian pertama ini, Anda akan mengenal bagaimana cara kita menggunakan Express.js yang paling dasar dan berbagai teknik dasar yang akan kita pelajari untuk membuat sebuah aplikasi web. Selamat menikmati tutorial ini :D.

Instalasi

Untuk menggunakan Express.js, pastikan Anda memasang Node.js terlebih dahulu dan pastikan NPM sudah dapat digunakan. Tutorial ini dibuat dengan menggunakan Node.js versi 5.10.1 dan NPM versi 3.8.5. Melalui konsol atau terminal silahkan eksekusi perintah berikut. Pastikan pilih folder yang Anda sukai:

$ npm install express -g
$ express demo
$ npm install
$ npm start

Sekarang mari kita lihat halaman pertama yang dihasilkan oleh Express.js di web browser. Silahkan akses URL http://localhost:3000/, bentuknya akan seperti ini:

Selection_001

Melihat Struktur Folder Express.js

Saat pertama kali dibuat, Express.js memiliki struktur folder seperti berikut:

  • bin, di dalamnya terdapat sebuah file yang bernama www dimana file tersebut akan dieksekusi saat menjalankan perintah “npm start”
  • node_modules, di dalamnya terdapat berbagai folder librarylibrary Node.js yang dipasang melalui node package manager atau NPM
  • public, kita dapat menaruh berbagai file CSS, Javascript, atau gambar di dalam folder ini.
  • routes, di dalamnya terdapat berbagai file yang berisi action yang diterima oleh routing yang kita definisikan. Dapat menerima request berupa GET, POST, PUT, DELETE, OPTION, dan HEAD
  • views, di dalamnya terdapat berbagai file jade atau html yang digunakan oleh routes untuk menampilkan halaman
  • app.js, file utama Express.js yang berisi penggunaan package utama dan konfigurasi utama
  • npm-debug.log, file yang berisi hasil debug atau error yang dicatat oleh Express.js selama running
  • package.json, berisi struktur JSON yang mendefinisikan profil proyek dan dependensi paket apa saja yang dibutuhkan aplikasi yang kita kembangkan. NPM akan melacak dependensi dengan melihat file ini

Melihat File – File Penting Express.js

Sekarang mari kita intip contoh isi file app.js. Di dalamnya Anda akan melihat penggunaan library tertentu dengan menggunakan require() kemudian memasangnya di Express.js dengan menggunakan use(), kemudian untuk mengatur variabel global digunakan set():

var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');

var routes = require('./routes/index');
var users = require('./routes/users');

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);
app.use('/users', users);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err
    });
  });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}
  });
});


module.exports = app;

Lanjut, kita lihat juga isi file dari package.json yang didalamnya terdapat konfigurasi file mana yang akan dieksekusi oleh “npm start”, kemudian ada juga daftar dependency yang digunakan oleh aplikasi yang kita kembangkan beserta versinya:

{
  "name": "demo",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "start": "node ./bin/www"
  },
  "dependencies": {
    "body-parser": "~1.13.2",
    "cookie-parser": "~1.3.5",
    "debug": "~2.2.0",
    "express": "~4.13.1",
    "jade": "~1.11.0",
    "morgan": "~1.6.1",
    "serve-favicon": "~2.3.0"
  }
}

Sedangkan file bin/www berisi kode untuk menjalankan aplikasi dengan default port dan konfigurasi informasi lainnya saat runtime:

#!/usr/bin/env node

/**
 * Module dependencies.
 */

var app = require('../app');
var debug = require('debug')('demo:server');
var http = require('http');

/**
 * Get port from environment and store in Express.
 */

var port = normalizePort(process.env.PORT || '3000');
app.set('port', port);

/**
 * Create HTTP server.
 */

var server = http.createServer(app);

/**
 * Listen on provided port, on all network interfaces.
 */

server.listen(port);
server.on('error', onError);
server.on('listening', onListening);

/**
 * Normalize a port into a number, string, or false.
 */

function normalizePort(val) {
  var port = parseInt(val, 10);

  if (isNaN(port)) {
    // named pipe
    return val;
  }

  if (port >= 0) {
    // port number
    return port;
  }

  return false;
}

/**
 * Event listener for HTTP server "error" event.
 */

function onError(error) {
  if (error.syscall !== 'listen') {
    throw error;
  }

  var bind = typeof port === 'string'
    ? 'Pipe ' + port
    : 'Port ' + port;

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case 'EACCES':
      console.error(bind + ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind + ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}

/**
 * Event listener for HTTP server "listening" event.
 */

function onListening() {
  var addr = server.address();
  var bind = typeof addr === 'string'
    ? 'pipe ' + addr
    : 'port ' + addr.port;
  debug('Listening on ' + bind);
}

Mengenal Template Engine Jade

Misal kita temukan sebuah file bernama layout.jade:

doctype html
html
  head
    title= title
    link(rel='stylesheet', href='/stylesheets/style.css')
  body
    block content

Kemudian layout tersebut digunakan oleh index.jade:

extends layout

block content
  h1= title
  p Welcome to #{title}

Maka bila kita bayangkan, hasilnya akan menjadi seperti ini namun tanpa harus mengetik ulang bagian tertentu di file berbeda yang menggunakan layout.jade:

doctype html
html
  head
    title= title
    link(rel='stylesheet', href='/stylesheets/style.css')
  body
    h1= title
    p Welcome to #{title}

Templating dengan menggunakan Jade mungkin agak aneh dan tidak lazim, karena kita tidak menggunakan penutup atau pembuka tag HTML. Untuk menyatakan bahwa sebuah elemen berada di dalam elemen lain, kita berikan dahulu satu tab dibawah elemen yang akan berisi elemen lain. Kemudian ada sintaks extends dan block yang berarti bahwa kita menggunakan template layout.jade sebagai wadah untuk index.jade. Lalu Jade akan mencari posisi block content dan mengisinya dengan elemen yang ada di index.jade.

Selain itu untuk mencetak variabel kita gunakan sintaks #{nama_variabel}. Sedangkan untuk menggunakan atribut HTML pada suatu elemen, kita gunakan tanda “(” dan “)” dengan mengisi atribut yang akan digunakan. Sebagai contoh mari kita lihat contoh berikut:

// contoh 1
html:

<h1>Hello World</h1>

jade:

h1 Hello World

// contoh 2
html:

<table id="table-mahasiswa" class="table table-hovered" border="1" style="display:inline-block;padding:50px;">
    <tbody>
        <tr>
            <td>1</td>
            <td>hello</td>
            <td>world</td>
        </tr>
    </tbody>
</table>

jade:

table(border="1", style="display:inline-block;padding:50px;")#table-mahasiswa.table.table-hovered
    tbody
        tr
            td 1
            td hello
            td world

Untuk memudahkan pembuatan file Jade, Anda dapat menggunakan konverter http://html2jade.com tapi tentu saja hasil konversinya harus diperiksa dahulu, karena Jade sangat sensitif terhadap perbedaan penggunaan spasi dan tab. Jade mengharuskan kita hanya menggunakan salah satu jenis tab apakah hanya menggunakan spasi atau tab. Tidak boleh dicampur.

Routing di Express.js

OK, sekarang kita coba buka file index.js yang ada di folder routes:

var express = require('express');
var router = express.Router();

/* DEMO 0 - halaman index */
router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });
});


module.exports = router;

Anda dapat melihat dalam setiap file routes harus menggunakan modul Express.js terlebih dahulu, kemudian membuat instance Router() dan barulah kita dapat mendefinisikan URL apa lalu ditangani oleh aksi apa. Aksi yang kita lewatkan ke dalam routes harus menerima variabel request, response, dan next. Anda dapat menampilkan template Jade yang ada di folder views dengan menggunakan render() yang dimiliki oleh objek response. Pada kode diatas, objek response ditangkap oleh parameter res, maka kita panggil render() melalui res.render() kemudian tentukan file* Jade mana yang akan kita tampilkan, dan kita dapat melewatkan beberapa variabel dengan diapit tanda “{” dan “}”.

Untuk route ini, file index.jade akan ditampilkan dan diberikan sebuah nilai berupa title yang berisi “Express”:

extends layout

block content
  h1= title
  p Welcome to #{title}

Bila kita akses url http://localhost:3000/ maka akan muncul tampilan berikut:

Selection_001

Mengirim Variabel ke Template

Masih di file index.js. Sekarang kita coba tambah parameter yang dilewatkan ke sebuah template bernama demo1.jade. Kita akan melewatkan sebuah pesan bernama message dan sebuah objek bernama user:

/* DEMO 1 - render template */
router.get('/demo1', function(req, res, next) {
  res.render(
                'demo1', 
                { 
                    message: 'Lorem ipsum sit dolor amet', 
                    user: {name:'suyono', email:'suyono@example.com', website: 'http://www.suyono.com'} 
                }
            );
});

Seperti yang Anda lihat, kita lewatkan dua buah variabel dan variabel user memiliki struktur lebih detail di dalamnya. Bila akan kita tampilkan di demo1.jade maka kodenya akan seperti berikut:

extends layout

block content
  p message: #{message}
  p user.name: #{user.name}
  p user.email: #{user.email}
  p user.website: #{user.website}

Bila kita akses url http://localhost:3000/demo1 maka akan muncul tampilan berikut:

Selection_002

Menerima Parameter URL

Masih di file index.js. Sekarang kita coba lagi teknik lainnya yang cukup penting. Kita akan menggunakan parameter URL dalam sebuah route. Untuk menandai bahwa sebuah segmen adalah parameter maka harus kita kurung dengan tanda “(:” dan “)” barulah didalamnya tulis nama parameternya. Untuk menangkapnya di dalam kode, Anda dapat memanggil req.params.nama_variabel sesuai dengan nama parameter yang ditentukan:

/* DEMO 2 - parameter di URL */
router.get('/demo2/(:id)/(:category)', function (req, res, next){
    res.render('demo2', 
                        { 
                            id: req.params.id, 
                            category: req.params.category, 
                        }
                );
});

Sekarang akan kita tampilkan di file demo2.jade. Buat file tersebut di dalam folder views:

extends layout

block content
  p id: #{id}
  p category: #{category}

Bila kita akses url http://localhost:3000/demo2/1/food maka akan muncul tampilan berikut:

Selection_003

Menampilkan Response JSON

Masih di file index.js. Tidak berbeda jauh dengan menampilkan sebuah file template. Sekarang kita akan tampilkan langsung sebuah objek Javascript dan ditampilkan sebagai response JSON dengan menggunakan json():

/* DEMO 3 - menampilkan respon JSON */
router.get('/demo3', function(req, res, next) {
  res.json({ 
                message: 'Lorem ipsum sit dolor amet', 
                user: {name:'suyono', email:'suyono@example.com', website: 'http://www.suyono.com'} 
        });
});

Bila kita akses url http://localhost:3000/demo3 maka akan muncul tampilan berikut:

Selection_004

Menerima Request POST

Masih di file index.js. Sekarang kita akan mencoba menampilkan sebuah form dan mengirimnya melalui metode POST. Pertama kita buat dahulu route untuk menampilkan form. Kemudian buatlah route untuk menangkap hasil kiriman POST:

/* DEMO 4 - menerima request method POST dari form */
router.get('/demo4/', function (req, res, next){
  res.render('demo4');
});

router.post('/demo4/', function (req, res, next){
  res.json(
            {
              message: "request POST is executed",
              data: { 
                username: req.param('username'), 
                email: req.param('email'), 
                website: req.param('website'), 
                phone: req.param('phone'), 
              }
            }
        );
});

Pada kode diatas, untuk menangkap hasil kiriman POST, maka kita gunakan req.param(‘nama_variabel’), berbeda dengan cara menangkap kiriman GET dimana kita memanggil req.params.nama_variabel. Hati – hati jangan sampai tertukar yah.

Sekarang kita coba buat form nya dengan menggunakan template Jade. Silahkan buat sebuah file dengan nama demo4.jade di folder views:

extends layout

block content
    h3 Demo Form
    form(action='/demo4', method='post')
        input(type='text', name='username', placeholder='username')
        br
        br
        input(type='text', name='email', placeholder='email')
        br
        br
        input(type='text', name='website', placeholder='website')
        br
        br
        input(type='text', name='phone', placeholder='phone')
        br
        br
        input(type='submit', value='Submit')

Bila kita akses url http://localhost:3000/demo4 maka akan muncul tampilan berikut:

Selection_005

Selection_006

Menerima Request PUT

Berbeda dengan POST dan GET, kita akan mencoba metode PUT dalam Express.js, metode ini hanya dapat ditangkap oleh request yang membutuhkan metode PUT. Jadi bila diakses langsung dari web browser akan sulit dilakukan karena belum ada dukungan untuk metode ini. Namun kita dapat menggunakan Curl atau Postman untuk mencoba mengakses route yang bermetode PUT. Metode ini biasa digunakan untuk membangun RESTful API.

Sekarang mari kita buat route dengan URL /demo5 yang akan menampilkan sebuah JSON yang dikirimkan oleh client:

/* DEMO 5 - menerima request method PUT */
router.put('/demo5/', function (req, res, next){
  res.json(
            {
              message: "request PUT is executed",
              data: { 
                username: req.param('username'), 
                email: req.param('email'), 
                website: req.param('website'), 
                phone: req.param('phone'), 
              }
            }
        );
});

Bila kita gunakan POSTMAN untuk mengakses route tersebut maka akan muncul response seperti pada gambar:

Selection_008

Menerima Request DELETE

Kita akan mengerjakan bagian ini di file index.js. Hampir sama dengan PUT, DELETE pun saat ini belum didukung oleh web browser. Kita akan buat sebuah route bermetod DELETE dan mempunyai URL /demo6 yang akan menampilkan sebuah response JSON:

/* DEMO 6 - menerima request method DELETE */
router.delete('/demo6/', function (req, res, next){
  res.json(
            {
              message: "request DELETE is executed"
            }
        );
});

Bila kita gunakan POSTMAN untuk mengakses route tersebut maka akan muncul response seperti pada gambar:

Selection_009

Melakukan Redirect ke URL lain

Masih di file yang sama, proses redirect tentu saja dibutuhkan bila kita sudah melakukan suatu proses, ingin dikembalikan ke halaman asal atau ke halaman tertentu. Kita akan membuat sebuah route dengan URL /demo7 yang akan melakukan redirect dengan menggunakan res.redirect() ke URL /demo7_result:

/* DEMO 7 - redirect url */
router.get('/demo7', function (req, res, next){
    res.redirect('/demo7_result');
});

router.get('/demo7_result', function (req, res, next){
    res.render('demo7');
});

Berikut adalah views dari URL /demo7_result. Silahkan buat template berikut dengan nama demo7.jade dan simpan di folder views:

extends layout

block content
  p Hasil redirect dari /demo7

Bila kita akses url http://localhost:3000/demo7 maka akan muncul tampilan berikut:

Selection_007

Penutup

Sebagai awalan, semoga tutorial ini dapat cukup dipahami untuk lanjut ke tutorial Express.js berikutnya yang akan mengenal lebih dalam bagaimana membuat aplikasi web dengan Express.js dan MongoDB. Untuk mempelajari Node.js dan Express.js ini, Anda memerlukan kemauan tinggi dan harus mencari resource sendiri. Karena masih sedikit perguruan tinggi atau SMK yang mau mengajarkan Node.js ataupun Express.js. Semoga bermanfaat :D.

 

credit : https://www.codepolitan.com/

Express : Fast, unopinionated, minimalist web framework for node.

var express = require(express)
var app = express()
 
app.get(/, function (req, res) {
  res.send(Hello World)
})
 
app.listen(3000)

Installation

$ npm install express

Features

  • Robust routing
  • Focus on high performance
  • Super-high test coverage
  • HTTP helpers (redirection, caching, etc)
  • View system supporting 14+ template engines
  • Content negotiation
  • Executable for generating applications quickly

Docs & Community

PROTIP Be sure to read Migrating from 3.x to 4.x as well as New features in 4.x.

Security Issues

If you discover a security vulnerability in Express, please see Security Policies and Procedures.

Quick Start

The quickest way to get started with express is to utilize the executable express(1) to generate an application as shown below:

Install the executable. The executable’s major version will match Express’s:

$ npm install -g express-generator@4

Create the app:

$ express /tmp/foo && cd /tmp/foo

Install dependencies:

$ npm install

Start the server:

$ npm start

Philosophy

The Express philosophy is to provide small, robust tooling for HTTP servers, making it a great solution for single page applications, web sites, hybrids, or public HTTP APIs.

Express does not force you to use any specific ORM or template engine. With support for over 14 template engines via Consolidate.js, you can quickly craft your perfect framework.

Examples

To view the examples, clone the Express repo and install the dependencies:

$ git clone git://github.com/expressjs/express.git –depth 1
$ cd express
$ npm install

Then run whichever example you want:

$ node examples/content-negotiation

Tests

To run the test suite, first install the dependencies, then run npm test:

$ npm install
$ npm test

How to Install Latest Nodejs & Npm on Ubuntu 16.04 & 14.04

Node.js is a platform built on Chrome’s JavaScript runtime for easily building fast, scalable network applications. Latest version node.js ppa is maintaining by its official website. We can add this PPA to Ubuntu 16.04 LTS (Trusty Tahr) and 14.04 LTS (Xenial Xerus) Systems and install node.js with few easy commands.

Install nodejs

Step 1: Add NodeJs PPA

First, you need to node.js PPA in our system provides by nodejs official website. We also need to install python-software-properties package if not installed already.

$ sudo apt-get install python-software-properties
$ curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -

Step 2: Install Nodejs and NPM

After adding required PPA file lets install Node package. NPM will also be installed with node.js. This command will also install many other dependent packages on your system.

$ sudo apt-get install nodejs

Step 3: Check Node.js and NPM Version

After installing node.js verify and check the installed version. You can find more details about current version on node.js official website.

$ node -v 

v7.10.0

Also, check the version of installed npm.

$ npm -v 

4.2.0

Step 4: Create Demo Web Server (Optional)

This is an optional step. If you want to test your node.js install. Let’s create a web server with “Hello World!” text. Create a file http_server.js

$ vim http_server.js

and add following content

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(3001, "127.0.0.1");
console.log('Server running at http://127.0.0.1:3001/');

Now start the web server using below command.

$ node --debug http_server.js

debugger listening on port 5858
Server running at http://127.0.0.1:3001/

The web server has been started on port 3001. Now access http://127.0.0.1:3001/ URL in browser. Now you will need to configure a front-end server for your app.

 

credit : https://tecadmin.net/

Cara Install Phalcon Di Ubuntu 16.04

Pada kesempatan kali ini saya akan berbagi kepada sobat tentang cara Install Phalcon Di Ubuntu 16.04 tentu saja cara ini tidak sama seperti halnya kita Install Phalcon Di Ubuntu 14.04. Sebelum sobat menginstall ini pastikan dahulu sobat mengenal phalcon jika belum kenal sobat bisa baca artikel saya sebelumnya tentang Perkenalan Framework Phalcon dan saya akan membuat tutorial series yang artinya setiap artikel yang satu dengan yang lain saling berkaitan. Nantikan tulisan saya lainnya tentang Tutorial Phalcon yang lainnya.

Yang berbeda cara installasi phalcon diubuntu 14.04 & ubuntu 16.04 adalah versi php yang berbeda. Perlu kalian ketahui bahwa ubuntu 16.04 hanya support menginstall dan menggunakan php7 , sementara ubuntu 14.04 menggunakan php 5. Tentu sangat berbeda apabila kita install ubuntu 16.04 dengan cara ubuntu 14.04.

1. Install LAMP-stack (Apache2, Mysql, Php 7)
Untuk cara penginstallan tidak akan saya jelaskan disini karena akan menjadi artikel yang sangaat panjang hahaha untuk saya rekomendasikan sobat untuk bisa ikuti cara di : http://tecadmin.net/install-apache-mysql-php-lamp-stack-on-ubuntu-16-04/
Setelah berhasil Install LAMP-stack kita akan mulai melakukan instalasi phalcon diharap untuk ikuti baik-baik step-by-stepnya.

2. Installasi Phalcon Ubuntu 16.04
Masukan command dibawah ini melalui terminal sobat secara bertahap satu per-satu.

 

$ sudo apt-add-repository ppa:phalcon/stable
$ sudo apt-get update
$ sudo apt-get install php7.0-phalcon
$ sudo apt-get install -y gcc make re2c libpcre3-dev php7.0-dev build-essential php7.0-zip

 

3. Aktifkan Extensi Phalcon
$ sudo apt-get install gcc make autoconf libc-dev pkg-config
$ git clone --depth=1 git://github.com/phalcon/cphalcon.git
$ cd cphalcon/build
$ sudo PATH=/opt/sp/php7.0/bin:$PATH ./install
4. Tambahkan Extensi Phalcon Ke Apache
$ sudo bash -c "echo extension=phalcon.so > /etc/php7.0/conf.d/phalcon.ini"
$ sudo service php7.0-fpm restart

 

5. Cek Ekstensi Phalcon.
Cek ekstensi phalcon apakah sudah aktif atau belum.
Runing terlebih dahulu Apache2 sobat “sudo service apache2 start”
lalu buat file php.info didirektori default apache2 /var/www/html/ cari ekstensi phalcon ctrl + f phalcon.
Selamat! Kini Phalcon v.3.0.1 telah diinstall diubuntu 16.04 sobat silahkan untuk terbang bersama phalcon ?

How To Install Apache MySQL PHP (LAMP Stack) on Ubuntu 16.04

LAMP (Linux, Apache, MySQL and PHP ) Stack is the most popular environment in PHP website development and hosting. Linux is the operating system, Apache is the popular web server developed by Apache Foundation. MySQL is relational database management system used for storing data and PHP is an development language.

This article will help you to Install Apache 2.4, MySQL 5.7 and PHP 7.0 . on Ubuntu 16.04 LTS Systems.

Step 1 – Install PHP

PHP 7 is the default available packages in Ubuntu 16.04 repositories. Simply use the following commands to update apt cache and install PHP packages on your system.

$ sudo apt update
$ sudo apt install -y php

Verify installed PHP version using following command.

rahul@tecadmin:~$ php -v

PHP 7.0.4-7ubuntu2 (cli) ( NTS )
Copyright (c) 1997-2016 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies
    with Zend OPcache v7.0.6-dev, Copyright (c) 1999-2016, by Zend Technologies

Step 2 – Install Apache2

After installing PHP on your system, let’s start installation of Apache2 in your system. Your also required to install libapache2-mod-php module to work PHP with Apache2.

$ sudo apt install apache2 libapache2-mod-php

Step 3 – Install MySQL

Finally install mysql-server packages for MySQL database. Also install php-mysql package to use MySQL support using php. Use following command to install it.

$ sudo apt install mysql-server php-mysql

Installer will prompt for root password, This password will work for your MySQL root user. After installing MySQL execute following command for initial settings of MySQL server. You will she that script will prompt about more settings than earlier mysql versions like password validation policy etc.

$ sudo mysql_secure_installation

Step 4 – Restart Apache2, MySQL Services

After installing all services on your system, start all required services.

$ sudo systemctl restart apache2.service
$ sudo systemctl restart mysql.service

Step 5 – Open Access in Firewall

If you are using iptables, Use following commands to open port 80 for public access of webserver.

Iptables Users:

$ sudo iptables -A INPUT -m state --state NEW -p tcp --dport 80 -j ACCEPT

UFW Users:

$ sudo ufw allow 80/tcp

Step 6 – Test Setup

After completing all setup. Let’s create a info.php file website document root with following content.


Now access this file in web browser. You will see the screen like below with all details of PHP on server.

lamp-on-ubuntu-16.04

Congratulation’s! You have successfully configured web server on your ubuntu System.

credit : https://tecadmin.net/