├── CONTRIBUTING.md
├── public
    ├── app.css
    └── mix-manifest.json
├── resources
    ├── sass
    │   ├── app.scss
    │   └── base.scss
    ├── js
    │   ├── event-bus.js
    │   ├── main.styl
    │   ├── models
    │   │   ├── Field.js
    │   │   ├── Submission.js
    │   │   ├── Model.js
    │   │   └── Form.js
    │   ├── pages
    │   │   ├── dashboard.vue
    │   │   ├── fields
    │   │   │   └── index.vue
    │   │   └── forms
    │   │   │   ├── index.vue
    │   │   │   ├── fields
    │   │   │       └── create.vue
    │   │   │   └── edit.vue
    │   ├── store
    │   │   ├── index.js
    │   │   └── modules
    │   │   │   └── forms.js
    │   ├── components
    │   │   ├── FormActionsComponent.vue
    │   │   ├── FieldsComponent.vue
    │   │   ├── NavComponent.vue
    │   │   ├── DialogComponent.vue
    │   │   ├── Alert.vue
    │   │   ├── FormsComponent.vue
    │   │   ├── FormSubmissionsComponent.vue
    │   │   └── FormFieldsComponent.vue
    │   ├── routes.js
    │   ├── app.js
    │   └── base.js
    └── views
    │   ├── submissions
    │       └── edit.blade.php
    │   ├── forms
    │       └── _form-questions.blade.php
    │   ├── layouts
    │       └── front.blade.php
    │   └── layout.blade.php
├── screenshots
    ├── new_field.png
    ├── new_form.png
    ├── form_details.png
    ├── forms_list.png
    ├── field_details.png
    ├── front_end_form.png
    └── submission_details.png
├── src
    ├── Fields
    │   ├── Date.php
    │   ├── Email.php
    │   ├── File.php
    │   ├── Text.php
    │   ├── Number.php
    │   ├── Password.php
    │   ├── TextArea.php
    │   ├── CheckBox.php
    │   ├── Radio.php
    │   ├── Select.php
    │   └── FormField.php
    ├── User.php
    ├── Http
    │   ├── Controllers
    │   │   ├── SubmissionController.php
    │   │   ├── DashboardController.php
    │   │   ├── FieldController.php
    │   │   ├── Controller.php
    │   │   ├── FormController.php
    │   │   ├── FormSubmissionController.php
    │   │   └── FormFieldController.php
    │   ├── Requests
    │   │   ├── ListFormRequest.php
    │   │   ├── DeleteFormRequest.php
    │   │   ├── CreateFormRequest.php
    │   │   ├── UpdateFormRequest.php
    │   │   ├── CreateFormQuestionRequest.php
    │   │   ├── UpdateFormQuestionRequest.php
    │   │   └── CreateFormSubmissionRequest.php
    │   └── routes.php
    ├── Services
    │   ├── SubmissionService.php
    │   ├── AnswerService.php
    │   ├── FormService.php
    │   └── QuestionService.php
    ├── Facades
    │   └── FormFacade.php
    ├── Transformers
    │   ├── FieldTypeTransformer.php
    │   ├── AnswerTransformer.php
    │   ├── SubmissionTransformer.php
    │   ├── FormTransformer.php
    │   ├── Transformer.php
    │   └── FieldTransformer.php
    ├── Models
    │   ├── Answer.php
    │   ├── Submission.php
    │   ├── Form.php
    │   └── Question.php
    ├── Rules
    │   └── ReCaptcha.php
    ├── Form.php
    └── FormServiceProvider.php
├── .travis.yml
├── tests
    ├── Feature
    │   ├── Form
    │   │   ├── DeleteTest.php
    │   │   ├── CreateTest.php
    │   │   ├── UpdateTest.php
    │   │   └── ListTest.php
    │   └── Question
    │   │   ├── DeleteTest.php
    │   │   ├── UpdateTest.php
    │   │   └── CreateTest.php
    ├── Unit
    │   ├── SubmissionTest.php
    │   ├── FormTest.php
    │   ├── AnswerTest.php
    │   ├── QuestionTest.php
    │   └── Fields
    │   │   └── FieldsRenderTest.php
    ├── TestCase.php
    └── BaseTestCase.php
├── .gitignore
├── phpunit.xml.dist
├── composer.json
├── webpack.mix.js
├── README.md
├── package.json
├── config
    └── laravel_forms.php
└── database
    ├── seeds
        └── FormsDatabaseSeeder.php
    ├── factories
        └── ModelFactory.php
    └── migrations
        └── create_form_tables.php


/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/public/app.css:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/resources/sass/app.scss:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/resources/sass/base.scss:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/resources/js/event-bus.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue';
2 | export const EventBus = new Vue();


--------------------------------------------------------------------------------
/resources/js/main.styl:
--------------------------------------------------------------------------------
1 | @import '~vuetify/src/stylus/main' // Ensure you are using stylus-loader


--------------------------------------------------------------------------------
/screenshots/new_field.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/new_field.png


--------------------------------------------------------------------------------
/screenshots/new_form.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/new_form.png


--------------------------------------------------------------------------------
/screenshots/form_details.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/form_details.png


--------------------------------------------------------------------------------
/screenshots/forms_list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/forms_list.png


--------------------------------------------------------------------------------
/screenshots/field_details.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/field_details.png


--------------------------------------------------------------------------------
/screenshots/front_end_form.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/front_end_form.png


--------------------------------------------------------------------------------
/screenshots/submission_details.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/musonza/laravel-forms/HEAD/screenshots/submission_details.png


--------------------------------------------------------------------------------
/public/mix-manifest.json:
--------------------------------------------------------------------------------
1 | {
2 |     "/app.js": "/app.js?id=080f3fb6c90b157f5680",
3 |     "/app.css": "/app.css?id=d41d8cd98f00b204e980"
4 | }
5 | 


--------------------------------------------------------------------------------
/src/Fields/Date.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class Date extends FormField
6 | {
7 |     protected $controlType = 'date';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Fields/Email.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class Email extends FormField
6 | {
7 |     protected $controlType = 'email';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Fields/File.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class File extends FormField
6 | {
7 |     protected $controlType = 'file';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Fields/Text.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class Text extends FormField
6 | {
7 |     protected $controlType = 'text';
8 | }
9 | 


--------------------------------------------------------------------------------
/resources/js/models/Field.js:
--------------------------------------------------------------------------------
1 | import Model from './Model'
2 | 
3 | export default class Field extends Model {
4 |   resource() {
5 |     return 'fields'
6 |   }
7 | }


--------------------------------------------------------------------------------
/src/Fields/Number.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class Number extends FormField
6 | {
7 |     protected $controlType = 'number';
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Fields/Password.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\Form\Fields;
4 | 
5 | class Password extends FormField
6 | {
7 |     protected $controlType = 'password';
8 | }
9 | 


--------------------------------------------------------------------------------
/resources/js/models/Submission.js:
--------------------------------------------------------------------------------
1 | import Model from './Model'
2 | 
3 | export default class Submission extends Model {
4 |   resource() {
5 |     return 'submissions'
6 |   }
7 | }


--------------------------------------------------------------------------------
/resources/js/pages/dashboard.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 | export default {
 3 |   name: "Dashboard"
 4 | };
 5 | </script>
 6 | 
 7 | <template>
 8 |   <p>Dashboard TODO</p>
 9 | </template>
10 | 


--------------------------------------------------------------------------------
/src/User.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form;
 4 | 
 5 | use Illuminate\Foundation\Auth\User as Authenticatable;
 6 | 
 7 | class User extends Authenticatable
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/resources/js/store/index.js:
--------------------------------------------------------------------------------
 1 | import Vue from 'vue';
 2 | import Vuex from 'vuex';
 3 | import Forms from './modules/forms';
 4 | 
 5 | Vue.use(Vuex);
 6 | 
 7 | export default new Vuex.Store({
 8 |   modules: {
 9 |     Forms,
10 |   },
11 | });


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 7.1
 5 |   - 7.2
 6 | 
 7 | env:
 8 |   global:
 9 |     - setup=basic
10 | 
11 | sudo: false
12 | 
13 | install:
14 |   - if [[ $setup = 'basic' ]]; then travis_retry composer install --no-interaction --prefer-source; fi
15 | 
16 | script: vendor/bin/phpunit


--------------------------------------------------------------------------------
/resources/js/pages/fields/index.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 | import FieldsComponent from "@/components/FieldsComponent";
 3 | export default {
 4 |   name: "FormsPage",
 5 | 
 6 |   components: {
 7 |     FieldsComponent
 8 |   }
 9 | };
10 | </script>
11 | 
12 | <template>
13 |   <fields-component></fields-component>
14 | </template>
15 | 


--------------------------------------------------------------------------------
/resources/js/pages/forms/index.vue:
--------------------------------------------------------------------------------
 1 | <template>
 2 |   <forms-component></forms-component>
 3 | </template>
 4 | 
 5 | <script>
 6 |     import FormsComponent from '@/components/FormsComponent';
 7 |     export default {
 8 |       name: 'FormsPage',
 9 | 
10 |       components: {
11 |         FormsComponent
12 |       }
13 |     }
14 | </script>
15 | 


--------------------------------------------------------------------------------
/resources/js/components/FormActionsComponent.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     export default {
 3 |       name: 'FormActionsComponent',
 4 | 
 5 |       data: () => ({
 6 |       }),
 7 | 
 8 |       methods: {
 9 |       }
10 |     }
11 | </script>
12 | 
13 | <template>
14 |   <div>
15 |      <v-btn color="primary">Add Field</v-btn>
16 |   </div>
17 | </template>
18 | 


--------------------------------------------------------------------------------
/resources/js/models/Model.js:
--------------------------------------------------------------------------------
 1 | import { Model as BaseModel } from 'vue-api-query'
 2 | 
 3 | export default class Model extends BaseModel {
 4 | 
 5 |   // define a base url for a REST API
 6 |   baseURL() {
 7 |     return '';
 8 |   }
 9 | 
10 |   // implement a default request method
11 |   request(config) {
12 |     return this.$http.request(config)
13 |   }
14 | }


--------------------------------------------------------------------------------
/src/Http/Controllers/SubmissionController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Controllers;
 4 | 
 5 | use Musonza\Form\Models\Submission;
 6 | 
 7 | class SubmissionController extends Controller
 8 | {
 9 |     public function destroy(Submission $submission)
10 |     {
11 |         $submission->delete();
12 | 
13 |         return response('', 201);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/resources/js/models/Form.js:
--------------------------------------------------------------------------------
 1 | import Model from './Model';
 2 | import Field from './Field';
 3 | import Submission from './Submission';
 4 | 
 5 | export default class Form extends Model {
 6 |   resource() {
 7 |     return 'forms';
 8 |   }
 9 | 
10 |   fields() {
11 |     return this.hasMany(Field);
12 |   }
13 | 
14 |   submissions() {
15 |     return this.hasMany(Submission);
16 |   }
17 | }


--------------------------------------------------------------------------------
/src/Services/SubmissionService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Services;
 4 | 
 5 | use Musonza\Form\Models\Submission;
 6 | 
 7 | class SubmissionService
 8 | {
 9 |     public function __construct(Submission $submission)
10 |     {
11 |         $this->submission = $submission;
12 |     }
13 | 
14 |     public function getById($id)
15 |     {
16 |         return $this->submission->findOrFail($id);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Facades/FormFacade.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Facades;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | 
 7 | class FormFacade extends Facade
 8 | {
 9 |     /**
10 |      * Get the registered name of the component.
11 |      *
12 |      * @return string
13 |      * @codeCoverageIgnore
14 |      */
15 |     protected static function getFacadeAccessor()
16 |     {
17 |         return 'form';
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Fields/TextArea.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Fields;
 4 | 
 5 | class TextArea extends FormField
 6 | {
 7 |     protected $controlType = 'textarea';
 8 | 
 9 |     public function input()
10 |     {
11 |         $value = '';
12 |         $this->attributes['class'] = "form-control";
13 |         $attributes = $this->attributes($this->attributes);
14 |         return "<textarea{$attributes}>" . e($value) . "</textarea>";
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/Services/AnswerService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Services;
 4 | 
 5 | use Musonza\Form\Models\Answer;
 6 | use Musonza\Form\Models\Form;
 7 | 
 8 | class AnswerService
 9 | {
10 |     public function __construct(Form $form, Answer $answer)
11 |     {
12 |         $this->form = $form;
13 |         $this->answer = $answer;
14 |     }
15 | 
16 |     public function getById($id)
17 |     {
18 |         return $this->answer->findOrFail($id);
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Services/FormService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Services;
 4 | 
 5 | use Musonza\Form\Models\Form;
 6 | 
 7 | class FormService
 8 | {
 9 |     public function __construct(Form $form)
10 |     {
11 |         $this->form = $form;
12 |     }
13 | 
14 |     public function create(array $data)
15 |     {
16 |         return $this->form->create($data);
17 |     }
18 | 
19 |     public function getById($id)
20 |     {
21 |         return $this->form->findOrFail($id);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/DashboardController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Controllers;
 4 | 
 5 | use Illuminate\Routing\Controller;
 6 | 
 7 | class DashboardController extends Controller
 8 | {
 9 |     /**
10 |      * Display the view.
11 |      *
12 |      * @return \Illuminate\Http\Response
13 |      */
14 |     public function index()
15 |     {
16 |         $cssFile = config('laravel_forms.dashboard_css_file');
17 | 
18 |         return view('laravel-forms::layout', [
19 |             'cssFile' => $cssFile,
20 |         ]);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Transformers/FieldTypeTransformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | class FieldTypeTransformer extends Transformer
 6 | {
 7 |     public function transform($field)
 8 |     {
 9 |         $fieldObj = app($field);
10 | 
11 |         return [
12 |             'id' => $field,
13 |             'title' => $this->title($field),
14 |             'has_choices' => $fieldObj->hasChoices(),
15 |         ];
16 |     }
17 | 
18 |     protected function title($field)
19 |     {
20 |         return substr($field, strrpos($field, '\\') + 1);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Services/QuestionService.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Services;
 4 | 
 5 | use Musonza\Form\Models\Form;
 6 | use Musonza\Form\Models\Question;
 7 | 
 8 | class QuestionService
 9 | {
10 |     public function __construct(Form $form, Question $question)
11 |     {
12 |         $this->form = $form;
13 |         $this->question = $question;
14 |     }
15 | 
16 |     public function create(array $data)
17 |     {
18 |         return $this->question->create($data);
19 |     }
20 | 
21 |     public function getById($id)
22 |     {
23 |         return $this->question->findOrFail($id);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Http/Requests/ListFormRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class ListFormRequest extends FormRequest
 8 | {
 9 |     /**
10 |      * Determine if the user is authorized to make this request.
11 |      *
12 |      * @return bool
13 |      */
14 |     public function authorize()
15 |     {
16 |         return true;
17 |     }
18 | 
19 |     /**
20 |      * Get the validation rules that apply to the request.
21 |      *
22 |      * @return array
23 |      */
24 |     public function rules()
25 |     {
26 |         return [];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Http/Requests/DeleteFormRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class DeleteFormRequest extends FormRequest
 8 | {
 9 |     /**
10 |      * Determine if the user is authorized to make this request.
11 |      *
12 |      * @return bool
13 |      */
14 |     public function authorize()
15 |     {
16 |         return true;
17 |     }
18 | 
19 |     /**
20 |      * Get the validation rules that apply to the request.
21 |      *
22 |      * @return array
23 |      */
24 |     public function rules()
25 |     {
26 |         return [];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/Feature/Form/DeleteTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Form;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Tests\TestCase;
 7 | 
 8 | class DeleteTest extends TestCase
 9 | {
10 |     /**
11 |      * @var Form
12 |      */
13 |     private $form;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->form = Form::create(['title' => 'Contact Form']);
19 |     }
20 | 
21 |     public function testDeleteSuccess()
22 |     {
23 |         $response = $this
24 |             ->deleteJson(route('forms.destroy', $this->form->id))
25 |             ->assertStatus(201);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/FieldController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Controllers;
 4 | 
 5 | use Musonza\Form\Transformers\FieldTypeTransformer;
 6 | 
 7 | class FieldController extends Controller
 8 | {
 9 |     /**
10 |      * @var FieldTypeTransformer
11 |      */
12 |     private $fieldTransformer;
13 | 
14 |     public function __construct(FieldTypeTransformer $fieldTransformer)
15 |     {
16 |         $this->fieldTransformer = $fieldTransformer;
17 |     }
18 | 
19 |     public function index()
20 |     {
21 |         $fields = $this->fieldTransformer->transformCollection(config('laravel_forms.fields'));
22 | 
23 |         return response($fields);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/resources/js/routes.js:
--------------------------------------------------------------------------------
 1 | export default [
 2 |   { path: '/', redirect: '/forms' },
 3 |   {
 4 |     path: '/dashboard',
 5 |     name: 'dashboard',
 6 |     component: require('./pages/dashboard')
 7 |   },
 8 |   {
 9 |     path: '/forms',
10 |     name: 'forms-index',
11 |     component: require('./pages/forms/index')
12 |   },
13 |   {
14 |     path: '/forms/:id',
15 |     name: 'forms-edit',
16 |     component: require('./pages/forms/edit')
17 |   },
18 |   {
19 |     path: '/fields',
20 |     name: 'fields-index',
21 |     component: require('./pages/fields/index')
22 |   },
23 |   {
24 |     path: '/forms/:id/fields/create',
25 |     name: 'formFieldCreate',
26 |     component: require('./pages/forms/fields/create')
27 |   },
28 | ];


--------------------------------------------------------------------------------
/src/Transformers/AnswerTransformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | class AnswerTransformer extends Transformer
 6 | {
 7 |     public function transform($answer)
 8 |     {
 9 |         return array_merge(
10 |             $answer->toArray(),
11 |             [
12 |                 'response' => $this->getResponse($answer),
13 |                 'question' => $answer->question,
14 |             ]
15 |         );
16 |     }
17 | 
18 |     public function getResponse($answer)
19 |     {
20 |         if ($answer->question->options && isset($answer->question->options[$answer->value])) {
21 |             return $answer->question->options[$answer->value];
22 |         }
23 | 
24 |         return $answer->value;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Fields/CheckBox.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Fields;
 4 | 
 5 | class CheckBox extends FormField
 6 | {
 7 |     protected $controlType = 'checkbox';
 8 |     protected $hasChoices = true;
 9 | 
10 |     public function input()
11 |     {
12 |         $this->attributes['class'] = "";
13 |         $this->attributes['name'] = "{$this->attributes['name']}[]";
14 | 
15 |         $html = "";
16 | 
17 |         foreach ($this->options as $value => $label) {
18 |             $html .= '<input type="checkbox" ' . $this->attributes($this->attributes)
19 |                 . '  value="'
20 |                 . $value
21 |                 . '"> '
22 |                 . $label
23 |                 . '<br>';
24 |         }
25 |         return $html;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Folders #
 2 | ###########
 3 | dist/
 4 | vendor/
 5 | node_modules/
 6 | CVS/
 7 | .idea
 8 | deploy.php
 9 | composer.lock
10 | # Compiled source #
11 | ###################
12 | *.com
13 | *.class
14 | *.dll
15 | *.exe
16 | *.o
17 | *.so
18 | 
19 | # Packages #
20 | ############
21 | # it's better to unpack these files and commit the raw source
22 | # git has its own built in compression methods
23 | *.7z
24 | *.dmg
25 | *.gz
26 | *.iso
27 | *.jar
28 | *.rar
29 | *.tar
30 | *.zip
31 | 
32 | # Logs and databases #
33 | ######################
34 | *.log
35 | *.sqlite
36 | 
37 | # OS generated files #
38 | ######################
39 | .DS_Store
40 | .DS_Store?
41 | ._*
42 | .Spotlight-V100
43 | .Trashes
44 | ehthumbs.db
45 | Thumbs.db
46 | 
47 | docs/
48 | phpDocumentor.phar


--------------------------------------------------------------------------------
/src/Fields/Radio.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Fields;
 4 | 
 5 | class Radio extends FormField
 6 | {
 7 |     protected $controlType = 'radio';
 8 |     protected $hasChoices = true;
 9 | 
10 |     public function input()
11 |     {
12 |         $this->attributes['class'] = "";
13 |         $attributes = $this->attributes($this->attributes);
14 | 
15 |         $html = "";
16 | 
17 |         foreach ($this->options as $value => $label) {
18 |             $html .= '<input type="' . $this->controlType
19 |                 . '" '
20 |                 . $attributes
21 |                 . ' value="'
22 |                 . $value
23 |                 . '"> '
24 |                 . $label
25 |                 . '<br>';
26 |         }
27 | 
28 |         return $html;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Http/Requests/CreateFormRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class CreateFormRequest extends FormRequest
 8 | {
 9 |     public static $rules = [
10 |         'title' => 'Required',
11 |         'description' => '',
12 |         'status' => '',
13 |     ];
14 | 
15 |     /**
16 |      * Determine if the user is authorized to make this request.
17 |      *
18 |      * @return bool
19 |      */
20 |     public function authorize()
21 |     {
22 |         return true;
23 |     }
24 | 
25 |     /**
26 |      * Get the validation rules that apply to the request.
27 |      *
28 |      * @return array
29 |      */
30 |     public function rules()
31 |     {
32 |         return self::$rules;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Http/Requests/UpdateFormRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class UpdateFormRequest extends FormRequest
 8 | {
 9 |     public static $rules = [
10 |         'title' => 'Required',
11 |         'description' => '',
12 |         'status' => '',
13 |     ];
14 | 
15 |     /**
16 |      * Determine if the user is authorized to make this request.
17 |      *
18 |      * @return bool
19 |      */
20 |     public function authorize()
21 |     {
22 |         return true;
23 |     }
24 | 
25 |     /**
26 |      * Get the validation rules that apply to the request.
27 |      *
28 |      * @return array
29 |      */
30 |     public function rules()
31 |     {
32 |         return self::$rules;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Http/routes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $dashboardPathPrefix = config('laravel_forms.dashboard_path_prefix');
 4 | 
 5 | Route::group([
 6 |     'middleware' => 'web',
 7 |     'namespace' => 'Musonza\Form\Http\Controllers',
 8 | ], function () {
 9 |     Route::resource('fields', 'FieldController');
10 |     Route::resource('forms', 'FormController');
11 |     Route::resource('forms.fields', 'FormFieldController');
12 |     Route::resource('forms.submissions', 'FormSubmissionController');
13 |     Route::resource('submissions', 'SubmissionController');
14 | });
15 | 
16 | Route::group([
17 |     'middleware' => 'web',
18 |     'namespace' => 'Musonza\Form\Http\Controllers',
19 | ], function () use ($dashboardPathPrefix) {
20 |     Route::get($dashboardPathPrefix, 'DashboardController@index');
21 | });
22 | 


--------------------------------------------------------------------------------
/resources/views/submissions/edit.blade.php:
--------------------------------------------------------------------------------
 1 | @extends('laravel-forms::layouts.front')
 2 | 
 3 | @section('content')
 4 | 
 5 | <h1>{{ $form['title'] }}</h1>
 6 | 
 7 | <form role="form" method="post" action="{{ route('forms.submissions.store', $form['id']) }}">
 8 | 	{{ csrf_field() }}
 9 | 
10 | 	@include('laravel-forms::forms._form-questions')
11 | 
12 | 	@if($googleRecaptchaEnabled)
13 | 	<div class="form-group col-md-12">
14 | 		<div class="g-recaptcha"
15 | 	        data-sitekey="{{ config('laravel_forms.google_recaptcha_key') }}">
16 | 		</div>
17 | 	</div>
18 | 	@endif
19 | 
20 | 	<!-- Submit Button -->
21 | 	<div class="form-group row">
22 | 	    <div class="offset-md-2 col-md-10">
23 | 	        <button type="submit" class="btn btn-primary">Submit</button>
24 | 	    </div>
25 | 	</div>
26 | </form>
27 | @endsection
28 | 


--------------------------------------------------------------------------------
/src/Fields/Select.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Fields;
 4 | 
 5 | class Select extends FormField
 6 | {
 7 |     protected $controlType = 'select';
 8 |     protected $hasChoices = true;
 9 | 
10 |     public function input()
11 |     {
12 |         $selected = '';
13 | 
14 |         $attributes = $this->attributes($this->attributes);
15 |         $html = "<select{$attributes}>";
16 |         foreach ($this->options as $value => $label) {
17 |             if ($value == $selected) {
18 |                 $selectedAttribute = ' selected="selected"';
19 |             } else {
20 |                 $selectedAttribute = '';
21 |             }
22 |             $html .= '<option value="' . $value . '"' . $selectedAttribute . '>' . $label . '</option>';
23 |         }
24 |         return $html . '</select>';
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Models/Answer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class Answer extends Model
 8 | {
 9 |     protected $table = 'mc_answers';
10 |     protected $fillable = [
11 |         'value',
12 |         'submission_id',
13 |     ];
14 | 
15 |     protected $with = [
16 |         'question',
17 |     ];
18 | 
19 |     /**
20 |      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
21 |      */
22 |     public function question()
23 |     {
24 |         return $this->belongsTo(Question::class)->orderBy('position');
25 |     }
26 | 
27 |     /**
28 |      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
29 |      */
30 |     public function submission()
31 |     {
32 |         return $this->belongsTo(Submission::class);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/Controller.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Controllers;
 4 | 
 5 | use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
 6 | use Illuminate\Foundation\Bus\DispatchesJobs;
 7 | use Illuminate\Foundation\Validation\ValidatesRequests;
 8 | use Illuminate\Routing\Controller as BaseController;
 9 | use Illuminate\Support\Facades\Session;
10 | 
11 | class Controller extends BaseController
12 | {
13 |     use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
14 | 
15 |     public function flashError($message)
16 |     {
17 |         Session::flash('alert-danger', $message);
18 |     }
19 | 
20 |     public function flashSuccess($message)
21 |     {
22 |         Session::flash('alert-success', $message);
23 |     }
24 | 
25 |     public function response($data = [], $view = null)
26 |     {
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/resources/js/store/modules/forms.js:
--------------------------------------------------------------------------------
 1 | const axios = require('axios');
 2 | 
 3 | const state = {
 4 |   forms: null
 5 | };
 6 | 
 7 | const getters = {
 8 |   forms: state => {
 9 |     return state.forms;
10 |   }
11 | };
12 | 
13 | const BASEURL = ''; //http://127.0.0.1:8000';
14 | 
15 | const actions = {
16 |   loadForms({ commit }) {
17 |     commit('LOADING', true);
18 |     axios.get(BASEURL + '/forms')
19 |       .then((response) => {
20 |         commit('SET_FORMS', response.data);
21 |         commit('LOADING', false);
22 |         return response;
23 |       });
24 |   },
25 | };
26 | 
27 | const mutations = {
28 |   ['LOADING'](state, payload) {
29 |     state.loading = payload;
30 |   },
31 |   ['SET_FORMS'](state, payload) {
32 |     state.forms = payload;
33 |   },
34 | };
35 | 
36 | export default {
37 |   state,
38 |   getters,
39 |   actions,
40 |   mutations,
41 | };


--------------------------------------------------------------------------------
/tests/Feature/Form/CreateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Form;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Tests\TestCase;
 7 | 
 8 | class CreateTest extends TestCase
 9 | {
10 |     public function testCreateSuccess()
11 |     {
12 |         $response = $this->postJson(route('forms.store'), ['title' => 'Contact Form', 'description' => 'Our Form']);
13 | 
14 |         $response
15 |             ->assertStatus(200)
16 |             ->assertJson([
17 |                 'title' => 'Contact Form',
18 |                 'description' => 'Our Form',
19 |             ]);
20 |     }
21 | 
22 |     public function testFormRequiresTitle()
23 |     {
24 |         $response = $this->postJson(route('forms.store'), [])
25 |             ->assertStatus(422)
26 |             ->assertJson([
27 |                 'message' => 'The given data was invalid.',
28 |             ]);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Http/Requests/CreateFormQuestionRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class CreateFormQuestionRequest extends FormRequest
 8 | {
 9 |     public static $rules = [
10 |         'label' => 'Required',
11 |         'field_type' => 'Required',
12 |         'help_text' => '',
13 |         'placeholder' => '',
14 |         'value' => '',
15 |         'columns_count' => '',
16 |     ];
17 | 
18 |     /**
19 |      * Determine if the user is authorized to make this request.
20 |      *
21 |      * @return bool
22 |      */
23 |     public function authorize()
24 |     {
25 |         return true;
26 |     }
27 | 
28 |     /**
29 |      * Get the validation rules that apply to the request.
30 |      *
31 |      * @return array
32 |      */
33 |     public function rules()
34 |     {
35 |         return self::$rules;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Http/Requests/UpdateFormQuestionRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Illuminate\Foundation\Http\FormRequest;
 6 | 
 7 | class UpdateFormQuestionRequest extends FormRequest
 8 | {
 9 |     public static $rules = [
10 |         'label' => 'Required',
11 |         'field_type' => 'Required',
12 |         'is_required' => '',
13 |         'help_text' => '',
14 |         'placeholder' => '',
15 |         'default_value' => '',
16 |         //'columns_count' => '',
17 |     ];
18 | 
19 |     /**
20 |      * Determine if the user is authorized to make this request.
21 |      *
22 |      * @return bool
23 |      */
24 |     public function authorize()
25 |     {
26 |         return true;
27 |     }
28 | 
29 |     /**
30 |      * Get the validation rules that apply to the request.
31 |      *
32 |      * @return array
33 |      */
34 |     public function rules()
35 |     {
36 |         return self::$rules;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Feature/Form/UpdateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Form;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Tests\TestCase;
 7 | 
 8 | class UpdateTest extends TestCase
 9 | {
10 |     /**
11 |      * @var Form
12 |      */
13 |     private $form;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->form = Form::create(['title' => 'Contact Form']);
19 |     }
20 | 
21 |     public function testUpdateSuccess()
22 |     {
23 |         $response = $this->putJson(route('forms.update', $this->form->id), [
24 |             'title' => 'Contact Form2',
25 |             'label' => 'Contact Form2',
26 |             'description' => 'Our Form2',
27 |         ]);
28 | 
29 |         $response
30 |             ->assertStatus(200)
31 |             ->assertJson([
32 |                 'title' => 'Contact Form2',
33 |                 'description' => 'Our Form2',
34 |             ]);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/resources/views/forms/_form-questions.blade.php:
--------------------------------------------------------------------------------
 1 | @php
 2 |  $count = 0;
 3 | @endphp
 4 | 
 5 | <div class="form-row">
 6 | 
 7 | @if ($errors->any())
 8 |     <ul class="alert alert-danger p2">
 9 |         @foreach ($errors->all() as $error)
10 |             <li>{{ $error }}</li>
11 |         @endforeach
12 |     </ul>
13 | @endif
14 | 
15 | @foreach($form['questions']['data'] as $question)
16 | 
17 | @php
18 |  $count += $question['columns_count'];
19 | @endphp
20 | 	<div class="form-group col-md-{{ $question['columns_count'] }}">
21 | 		<label
22 | 		for="{{ $question['title'] }}"
23 | 		class="col-form-label text-md-right">{{ $question['label'] }}</label>
24 | 		<div class="">
25 | 			{!! $question['render'] !!}
26 | 			@if(isset($question['help_text']))
27 | 				<small class="form-text text-muted">{{ $question['help_text'] }}</small>
28 | 			@endif
29 | 		</div>
30 | 	</div>
31 | 
32 | @if($count == 12)
33 | </div>
34 | <div class="form-row">
35 | @endif
36 | @endforeach
37 | 


--------------------------------------------------------------------------------
/tests/Feature/Question/DeleteTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Question;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Text;
 7 | use Musonza\Form\Tests\TestCase;
 8 | 
 9 | class DeleteTest extends TestCase
10 | {
11 |     protected $form;
12 |     protected $question;
13 | 
14 |     public function setUp(): void
15 |     {
16 |         parent::setUp();
17 |         $this->form = Form::create(['title' => 'Contact Form']);
18 |         $this->question = Form::createQuestion(
19 |             [
20 |                 'label' => 'First Name',
21 |                 'description' => 'Description',
22 |                 'field_type' => Text::class,
23 |                 'form_id' => $this->form->id,
24 |             ]
25 |         );
26 |     }
27 | 
28 |     public function testDeleteSuccess()
29 |     {
30 |         $response = $this
31 |             ->deleteJson(route('forms.fields.destroy', [$this->form->id, $this->question->id]))
32 |             ->assertStatus(201);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Unit/SubmissionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Unit;
 4 | 
 5 | use Form;
 6 | use Illuminate\Database\Eloquent\Collection;
 7 | use Musonza\Form\Models\Submission;
 8 | use Musonza\Form\Tests\TestCase;
 9 | 
10 | class SubmissionTest extends TestCase
11 | {
12 |     protected $form;
13 |     protected $question;
14 |     protected $submission;
15 | 
16 |     public function setUp(): void
17 |     {
18 |         parent::setUp();
19 |         $this->form = Form::create(['title' => 'Contact Form']);
20 |         $this->submission = $this->form->addSubmission([]);
21 |     }
22 | 
23 |     public function testFormSubmissions()
24 |     {
25 |         $this->assertInstanceOf(Collection::class, $this->form->submissions);
26 |     }
27 | 
28 |     public function testGetSubmissionById()
29 |     {
30 |         $submission = Form::submissionService()->getById(1);
31 |         $this->assertEquals($this->submission->id, $submission->id);
32 |         $this->assertInstanceOf(Submission::class, $submission);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Transformers/SubmissionTransformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | use Musonza\Form\Transformers\Transformer;
 6 | 
 7 | class SubmissionTransformer extends Transformer
 8 | {
 9 |     protected $availableIncludes = ['answers'];
10 |     protected $defaultIncludes = [];
11 | 
12 |     public function transform($submission)
13 |     {
14 |         return [
15 |             'id' => $submission->id,
16 |             'form_id' => $submission->form_id,
17 |             'ip_address' => $submission->ip_address,
18 |             'response' => $submission->response,
19 |             'is_complete' => $submission->is_complete,
20 |             'created_at_readable' => $submission->created_at->diffForHumans(),
21 |             'created_at' => $submission->created_at,
22 |             'updated_at' => $submission->updated_at,
23 |         ];
24 |     }
25 | 
26 |     public function includeAnswers($submission)
27 |     {
28 |         return $this->collection($submission->answers, new AnswerTransformer());
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Models/Submission.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class Submission extends Model
 8 | {
 9 |     protected $table = 'mc_submissions';
10 |     protected $fillable = [
11 |         'ip_address',
12 |         'form_id',
13 |         'response',
14 |         'is_complete',
15 |     ];
16 | 
17 |     /**
18 |      * The attributes that should be cast to native types.
19 |      *
20 |      * @var array
21 |      */
22 |     protected $casts = [
23 |         'response' => 'array',
24 |         'is_complete' => 'boolean',
25 |     ];
26 | 
27 |     /**
28 |      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
29 |      */
30 |     public function form()
31 |     {
32 |         return $this->belongsTo(Form::class);
33 |     }
34 | 
35 |     /**
36 |      * Submission has answers.
37 |      *
38 |      * @return \Illuminate\Database\Eloquent\Relations\HasMany
39 |      */
40 |     public function answers()
41 |     {
42 |         return $this->hasMany(Answer::class);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit bootstrap="vendor/autoload.php"
 3 |          backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          colors="true"
 6 |          verbose="true"
 7 |          convertErrorsToExceptions="true"
 8 |          convertNoticesToExceptions="true"
 9 |          convertWarningsToExceptions="true"
10 |          processIsolation="false"
11 |          stopOnFailure="false">
12 |     <testsuites>
13 |         <testsuite name="Feature">
14 |             <directory suffix="Test.php">./tests/Feature</directory>
15 |         </testsuite>
16 |         <testsuite name="Unit">
17 |             <directory suffix="Test.php">./tests/Unit</directory>
18 |         </testsuite>
19 |     </testsuites>
20 |     <filter>
21 |         <whitelist>
22 |             <directory suffix=".php">src/</directory>
23 |         </whitelist>
24 |     </filter>
25 |     <php>
26 |         <env name="APP_NAME" value="mysite"/>
27 |         <env name="APP_KEY" value="AckfSECXIvnK5r28GVIWUAxmbBSjTsmF"/>
28 |     </php>
29 | </phpunit>


--------------------------------------------------------------------------------
/src/Models/Form.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class Form extends Model
 8 | {
 9 |     protected $table = 'mc_forms';
10 |     protected $fillable = [
11 |         'title',
12 |         'description',
13 |         'status',
14 |     ];
15 | 
16 |     protected $with = [
17 |         'submissions',
18 |     ];
19 | 
20 |     /**
21 |      * A form has many questions.
22 |      *
23 |      * @return \Illuminate\Database\Eloquent\Relations\HasMany
24 |      */
25 |     public function questions()
26 |     {
27 |         return $this->hasMany(Question::class)->orderBy('position');
28 |     }
29 | 
30 |     /**
31 |      * A form has many submissions.
32 |      *
33 |      * @return \Illuminate\Database\Eloquent\Relations\HasMany
34 |      */
35 |     public function submissions()
36 |     {
37 |         return $this->hasMany(Submission::class);
38 |     }
39 | 
40 |     public function addSubmission($submission)
41 |     {
42 |         return $this->submissions()->create($submission);
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/Rules/ReCaptcha.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Rules;
 4 | 
 5 | use GuzzleHttp\Client;
 6 | use Illuminate\Contracts\Validation\Rule;
 7 | 
 8 | class ReCaptcha implements Rule
 9 | {
10 |     public function passes($attribute, $value)
11 |     {
12 | 
13 |         $client = new Client();
14 | 
15 |         $response = $client->post(
16 |             'https://www.google.com/recaptcha/api/siteverify',
17 |             ['form_params' =>
18 |                 [
19 |                     'secret' => config('laravel_forms.google_recaptcha_secret'),
20 |                     'response' => $value,
21 |                     'remoteip' => $_SERVER['REMOTE_ADDR'],
22 |                 ],
23 |             ]
24 |         );
25 | 
26 |         $body = json_decode((string) $response->getBody());
27 | 
28 |         return $body->success;
29 |     }
30 | 
31 |     /**
32 |      * Get the validation error message.
33 |      *
34 |      * @return string
35 |      */
36 |     public function message()
37 |     {
38 |         return 'Please ensure that you are a human!';
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/resources/js/components/FieldsComponent.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     import Field from '@/models/Field';
 3 |     export default {
 4 |         name: 'FieldsComponent',
 5 |         data: () => ({
 6 |           headers: [
 7 |             { text: 'ID', value: 'id' },
 8 |             { text: 'Title', value: 'title' },
 9 |             { text: 'Choices', value: 'has_choices' },
10 |           ],
11 |           fieldTypes: [],
12 |         }),
13 | 
14 |         methods: {
15 |           async getFields() {
16 |             this.fieldTypes = await Field.$get();
17 |           },
18 |         },
19 | 
20 |         created() {
21 |           this.getFields();
22 |         }
23 |     }
24 | </script>
25 | 
26 | <template>
27 |     <v-data-table
28 |       :headers="headers"
29 |       :items="fieldTypes"
30 |       class="elevation-1"
31 |     >
32 |       <template slot="items" slot-scope="props">
33 |         <td>{{ props.item.id }}</td>
34 |         <td>{{ props.item.title }}</td>
35 |         <td>{{ props.item.has_choices }}</td>
36 |       </template>
37 |     </v-data-table>
38 | </template>
39 | 
40 | 


--------------------------------------------------------------------------------
/src/Transformers/FormTransformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | class FormTransformer extends Transformer
 6 | {
 7 |     protected $availableIncludes = ['questions'];
 8 |     protected $defaultIncludes = [];
 9 | 
10 |     public function transform($form)
11 |     {
12 |         $statuses = config('laravel_forms.form_statuses');
13 | 
14 |         return [
15 |             'id' => $form->id,
16 |             'title' => $form->title,
17 |             'description' => $form->description,
18 |             'created_at' => $form->created_at,
19 |             'status' => [
20 |                 'value' => (int)$form->status,
21 |                 'label' => $statuses[$form->status]['label'],
22 |                 'class' => $statuses[$form->status]['class'],
23 |             ],
24 |             'statuses' => $statuses,
25 |             'submissions_count' => $form->submissions->count(),
26 |         ];
27 |     }
28 | 
29 |     public function includeQuestions($form)
30 |     {
31 |         return $this->collection($form->questions, new FieldTransformer());
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/Feature/Form/ListTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Form;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Tests\TestCase;
 7 | 
 8 | class ListTest extends TestCase
 9 | {
10 |     public function setUp(): void
11 |     {
12 |         parent::setUp();
13 |         Form::create(['title' => 'Contact Form1']);
14 |         Form::create(['title' => 'Contact Form2']);
15 |         Form::create(['title' => 'Contact Form3']);
16 |     }
17 | 
18 |     public function testListForms()
19 |     {
20 |         // $response = $this->get(route('forms.index'));
21 | 
22 |         // $response->dump();
23 | 
24 |         $response = $this->getJson(route('forms.index'));
25 | 
26 |         $response
27 |             ->assertStatus(200)
28 |             ->assertJsonCount(3, 'data');
29 |     }
30 | 
31 |     public function testGetForm()
32 |     {
33 |         $response = $this->getJson(route('forms.show', $id = 2));
34 | 
35 |         $response
36 |             ->assertStatus(200)
37 |             ->assertJson([
38 |                 'title' => 'Contact Form2',
39 |             ]);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/resources/js/components/NavComponent.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 | export default {
 3 |   name: "NavComponent",
 4 | 
 5 |   data: () => ({
 6 |     items: [
 7 |       // { title: 'Dashboard', icon: 'dashboard', link: '/'},
 8 |       { title: "Forms", icon: "list", link: "/forms" },
 9 |       { title: "Field Types", icon: "text_fields", link: "/fields" }
10 |       // { title: "Settings", icon: "settings", link: "/settings" }
11 |     ]
12 |   }),
13 | 
14 |   methods: {
15 |     goTo(link) {
16 |       this.$router.push(link);
17 |     }
18 |   }
19 | };
20 | </script>
21 | 
22 | <template>
23 |   <div>
24 |     <v-navigation-drawer class="blue-grey darken-3" dark permanent>
25 |       <v-list>
26 |         <v-list-tile v-for="item in items" :key="item.title" @click="goTo(item.link)">
27 |           <v-list-tile-action>
28 |             <v-icon>{{ item.icon }}</v-icon>
29 |           </v-list-tile-action>
30 | 
31 |           <v-list-tile-content>
32 |             <v-list-tile-title>{{ item.title }}</v-list-tile-title>
33 |           </v-list-tile-content>
34 |         </v-list-tile>
35 |       </v-list>
36 |     </v-navigation-drawer>
37 |   </div>
38 | </template>
39 | 


--------------------------------------------------------------------------------
/tests/Feature/Question/UpdateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Question;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Text;
 7 | use Musonza\Form\Tests\TestCase;
 8 | 
 9 | class UpdateTest extends TestCase
10 | {
11 |     protected $form;
12 |     protected $question;
13 | 
14 |     public function setUp(): void
15 |     {
16 |         parent::setUp();
17 |         $this->form = Form::create(['title' => 'Contact Form']);
18 |         $this->data = [
19 |             'label' => 'First Name',
20 |             'description' => 'Description',
21 |             'field_type' => Text::class,
22 |             'form_id' => $this->form->id,
23 |         ];
24 |         $this->question = Form::createQuestion($this->data);
25 |     }
26 | 
27 |     public function testUpdateSuccess()
28 |     {
29 |         $this->data['label'] = 'First Name Updated';
30 | 
31 |         $response = $this
32 |             ->putJson(route('forms.fields.update', [$this->form->id, $this->question->id]), $this->data)
33 |             ->assertStatus(200)
34 |             ->assertJson([
35 |                 'label' => 'First Name Updated',
36 |             ]);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "musonza/laravel-forms",
 3 |   "authors": [
 4 |     {
 5 |       "name": "Tinashe Musonza",
 6 |       "email": "tinashemusonza@gmail.com",
 7 |       "role": "Developer"
 8 |     }
 9 |   ],
10 |   "require": {
11 |     "league/fractal": "^0.17.0",
12 |     "laravel/framework": "~5.5.0|~5.6.0|~5.7.0|~5.8.0",
13 |     "guzzlehttp/guzzle": "~6.0"
14 |   },
15 |   "require-dev": {
16 |     "phpunit/phpunit": "^5.7|6.2|^7.0",
17 |     "orchestra/testbench": "~3.3.0|~3.4.2|^3.5.0|~3.7.0",
18 |     "orchestra/database": "~3.3.0|~3.4.2|^3.5.0|~3.7.0",
19 |     "mockery/mockery": "^1.0.0",
20 |     "spatie/phpunit-watcher": "dev-master",
21 |     "orchestra/testbench-dusk": "^3.7@dev"
22 |   },
23 |   "minimum-stability": "dev",
24 |   "autoload": {
25 |     "psr-4": {
26 |       "Musonza\\Form\\": "src/"
27 |     }
28 |   },
29 |   "autoload-dev": {
30 |     "psr-4": {
31 |       "Musonza\\Form\\Tests\\": "tests"
32 |     }
33 |   },
34 |   "scripts": {
35 |     "test": "phpunit"
36 |   },
37 |   "extra": {
38 |     "laravel": {
39 |       "providers": [
40 |         "Musonza\\Form\\FormServiceProvider"
41 |       ]
42 |     }
43 |   },
44 |   "license": "MIT"
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/Unit/FormTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Unit;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Tests\TestCase;
 7 | 
 8 | class FormTest extends TestCase
 9 | {
10 |     /**
11 |      * @var Form
12 |      */
13 |     private $form;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->form = Form::create(['title' => 'Contact Form']);
19 |     }
20 | 
21 |     public function testCreatesForm()
22 |     {
23 |         $this->assertDatabaseHas($this->tablePrefix . 'forms', ['id' => 1, 'title' => 'Contact Form']);
24 |     }
25 | 
26 |     public function testGetFormById()
27 |     {
28 |         $form = Form::formService()->getById($this->form->id);
29 |         $this->assertEquals($this->form->id, $form->id);
30 |     }
31 | 
32 |     public function testDeleteForm()
33 |     {
34 |         $this->assertDatabaseHas($this->tablePrefix . 'forms', ['id' => 1, 'title' => 'Contact Form']);
35 | 
36 |         Form::formService()
37 |             ->getById($this->form->id)
38 |             ->delete();
39 | 
40 |         $this->assertDatabaseMissing($this->tablePrefix . 'forms', ['id' => 1, 'title' => 'Contact Form']);
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests;
 4 | 
 5 | class TestCase extends \Orchestra\Testbench\TestCase
 6 | {
 7 |     use BaseTestCase;
 8 | 
 9 |     public $tablePrefix = 'mc_';
10 | 
11 |     public function setUp(): void
12 |     {
13 |         parent::setUp();
14 | 
15 |         //$this->artisan('migrate', ['--database' => 'testbench']);
16 |         $this->withFactories(__DIR__ . '/../database/factories');
17 |         $this->migrate();
18 |         $this->users = $this->createUsers(6);
19 |     }
20 | 
21 |     /**
22 |      * Define environment setup.
23 |      *
24 |      * @param \Illuminate\Foundation\Application $app
25 |      *
26 |      * @return void
27 |      */
28 |     protected function getEnvironmentSetUp($app)
29 |     {
30 |         parent::getEnvironmentSetUp($app);
31 | 
32 |         // Setup default database to use sqlite :memory:
33 |         $app['config']->set('database.default', 'testbench');
34 |         $app['config']->set('database.connections.testbench', [
35 |             'driver' => 'sqlite',
36 |             'database' => ':memory:',
37 |             'prefix' => '',
38 |         ]);
39 |         $app['config']->set('app.debug', true);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/webpack.mix.js:
--------------------------------------------------------------------------------
 1 | const mix = require('laravel-mix');
 2 | const webpack = require('webpack');
 3 | 
 4 | /*
 5 |  |--------------------------------------------------------------------------
 6 |  | Mix Asset Management
 7 |  |--------------------------------------------------------------------------
 8 |  |
 9 |  | Mix provides a clean, fluent API for defining some Webpack build steps
10 |  | for your Laravel application. By default, we are compiling the Sass
11 |  | file for the application as well as bundling up all the JS files.
12 |  |
13 |  */
14 | 
15 | mix
16 |     .options({
17 |         uglify: {
18 |             uglifyOptions: {
19 |                 compress: {
20 |                     drop_console: true,
21 |                 }
22 |             }
23 |         }
24 |     })
25 |     .setPublicPath('public')
26 |     .js('resources/js/app.js', 'public')
27 |     .sass('resources/sass/app.scss', 'public')
28 |     .version()
29 |     .webpackConfig({
30 |         resolve: {
31 |             symlinks: false,
32 |             alias: {
33 |                 '@': path.resolve(__dirname, 'resources/js/'),
34 |             }
35 |         },
36 |         plugins: [
37 |             new webpack.IgnorePlugin(/^\.\/locale$/, /moment$/)
38 |         ],
39 |     });
40 | 


--------------------------------------------------------------------------------
/resources/views/layouts/front.blade.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | 
 4 | <head>
 5 | 	<title>Forms</title>
 6 |     <meta name="csrf-token" content="{{ csrf_token() }}">
 7 |     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css">
 8 |     <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
 9 |  	<script src="https://www.google.com/recaptcha/api.js" async defer></script>
10 | </head>
11 | 
12 | <body class="flex flex-col min-h-screen">
13 |      <main class="py-4 col-md-12 ml-sm-auto col-lg-12 pt-3 px-4">
14 | 	    <div class="container">
15 | 	        <div class="row justify-content-center">
16 | 	            <div class="col-md-12">
17 | 	                <div class="flash-message">
18 | 	                  @foreach (['danger', 'warning', 'success', 'info'] as $msg)
19 | 	                    @if(Session::has('alert-' . $msg))
20 | 	                    <p class="alert alert-{{ $msg }}">{{ Session::get('alert-' . $msg) }}</p>
21 | 	                    @endif
22 | 	                  @endforeach
23 | 	                </div>
24 | 	            </div>
25 | 	        </div>
26 | 	    </div>
27 |         @yield('content')
28 |       </main>
29 |     </div>
30 | </body>
31 | </html>
32 | 


--------------------------------------------------------------------------------
/src/Http/Requests/CreateFormSubmissionRequest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Http\Requests;
 4 | 
 5 | use Musonza\Form\Form;
 6 | use Illuminate\Foundation\Http\FormRequest;
 7 | use Musonza\Form\Rules\ReCaptcha;
 8 | 
 9 | class CreateFormSubmissionRequest extends FormRequest
10 | {
11 |     /**
12 |      * Determine if the user is authorized to make this request.
13 |      *
14 |      * @return bool
15 |      */
16 |     public function authorize()
17 |     {
18 |         return true;
19 |     }
20 | 
21 |     /**
22 |      * Get the validation rules that apply to the request.
23 |      *
24 |      * @return array
25 |      */
26 |     public function rules()
27 |     {
28 |         /** @var  $form Form */
29 |         $form = app(Form::class);
30 | 
31 |         return [
32 |             'g-recaptcha-response' => [
33 |                 $form->googleRecaptchaEnabled() ? 'required' : '',
34 |                 new ReCaptcha,
35 |             ],
36 |         ];
37 |     }
38 | 
39 |     /**
40 |      * Get the error messages for the defined validation rules.
41 |      *
42 |      * @return array
43 |      */
44 |     public function messages()
45 |     {
46 |         return [
47 |             'g-recaptcha-response.required' => 'Captcha response is required.',
48 |         ];
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/resources/js/app.js:
--------------------------------------------------------------------------------
 1 | import Vue from 'vue';
 2 | import Base from './base';
 3 | import axios from 'axios';
 4 | import Routes from './routes';
 5 | import VueRouter from 'vue-router';
 6 | import TreeView from 'vue-json-tree-view';
 7 | import store from './store/index';
 8 | import Vuetify from 'vuetify';
 9 | import 'vuetify/dist/vuetify.min.css';
10 | import { Model } from 'vue-api-query';
11 | import VeeValidate from 'vee-validate'
12 | 
13 | // inject global axios instance as http client to Model
14 | Model.$http = axios
15 | require('bootstrap');
16 | let token = document.head.querySelector('meta[name="csrf-token"]');
17 | if (token) {
18 |   axios.defaults.headers.common['X-CSRF-TOKEN'] = token.content;
19 | }
20 | 
21 | Vue.use(Vuetify);
22 | Vue.use(VueRouter);
23 | Vue.use(TreeView);
24 | Vue.use(VeeValidate);
25 | 
26 | Vue.component('nav-component', require('./components/NavComponent.vue'));
27 | Vue.component('alert', require('./components/Alert.vue'));
28 | 
29 | const router = new VueRouter({
30 |   routes: Routes,
31 |   // mode: 'history',
32 |   base: '/laravel-forms/',
33 | });
34 | 
35 | Vue.mixin(Base);
36 | 
37 | new Vue({
38 |   el: '#laravel-forms',
39 |   router,
40 |   store,
41 |   // render: (h) => h(App),
42 |   data() {
43 |     return {
44 |       alert: {
45 |         type: null,
46 |         show: false,
47 |         autoDismiss: 5000,
48 |         message: '',
49 |         title: '',
50 |         confirmationAgree: null,
51 |       },
52 |     }
53 |   },
54 | });


--------------------------------------------------------------------------------
/src/Transformers/Transformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | use League\Fractal;
 6 | use League\Fractal\Manager;
 7 | use League\Fractal\Pagination\IlluminatePaginatorAdapter;
 8 | use League\Fractal\Resource\Collection;
 9 | use League\Fractal\Resource\Item;
10 | use League\Fractal\Serializer\ArraySerializer;
11 | 
12 | abstract class Transformer extends Fractal\TransformerAbstract
13 | {
14 |     public function transformCollection($items, $paginator = null, $meta = null)
15 |     {
16 |         $resource = new Collection($items, $this);
17 | 
18 |         if ($paginator) {
19 |             $resource->setPaginator(new IlluminatePaginatorAdapter($paginator));
20 |         }
21 | 
22 |         if ($meta) {
23 |             $resource->setMeta($meta);
24 |         }
25 | 
26 |         return $this->fractalManager($resource);
27 |     }
28 | 
29 |     public function fractalManager($resource)
30 |     {
31 |         $fractal = new Manager();
32 | 
33 |         $fractal->setSerializer(new ArraySerializer());
34 | 
35 |         if ($includes = request('include', null)) {
36 |             $fractal->parseIncludes($includes);
37 |         }
38 | 
39 |         return $fractal->createData($resource)->toArray();
40 |     }
41 | 
42 |     public function transformItem($item)
43 |     {
44 |         $resource = new Item($item, $this);
45 | 
46 |         return $this->fractalManager($resource);
47 |     }
48 | 
49 |     abstract public function transform($item);
50 | }
51 | 


--------------------------------------------------------------------------------
/resources/views/layout.blade.php:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 6 |     <meta name="csrf-token" content="{{ csrf_token() }}">
 7 |     <title>Laravel Forms</title>
 8 |     <!-- Style sheets-->
 9 |     <link href="{{ asset(mix($cssFile, 'vendor/laravel-forms')) }}" rel="stylesheet" type="text/css">
10 |     <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900">
11 |     <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Material+Icons">
12 | </head>
13 | <body>
14 | <div id="laravel-forms" v-cloak>
15 |   <v-app>
16 |     <v-container grid-list-md fluid>
17 |         <v-layout row>
18 |           <v-flex xs2>
19 |             <nav-component></nav-component>
20 |           </v-flex>
21 |           <v-flex xs10>
22 |             <alert :message="alert.message"
23 |                   :title="alert.title"
24 |                   :type="alert.type"
25 |                   :show="alert.show"
26 |                   :auto-dismiss="alert.autoDismiss"
27 |                   :confirmation-agree="alert.confirmationAgree"
28 |                   v-if="alert.type"></alert>
29 |             <router-view></router-view>
30 |           </v-flex>
31 |         </v-layout>
32 |     </v-container>
33 |   </v-app>
34 | </div>
35 | 
36 | <script src="{{asset(mix('app.js', 'vendor/laravel-forms'))}}"></script>
37 | </body>
38 | </html>
39 | 


--------------------------------------------------------------------------------
/resources/js/components/DialogComponent.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     export default {
 3 |       name: 'DialogComponent',
 4 | 
 5 |       data: () => ({
 6 |       }),
 7 | 
 8 |       props: {
 9 |         type: String,
10 |         title: null,
11 |         message: String,
12 |         show: Boolean,
13 |         confirmationAgree: null
14 |       },
15 | 
16 |       methods: {
17 |         confirm() {
18 |           this.confirmationAgree();
19 |           this.dismissAlert();
20 |         }
21 |       },
22 | 
23 |       computed: {
24 |         alert: function () {
25 |           return this.$root.alert.show;
26 |         }
27 |       },
28 | 
29 |       mounted() {
30 |       }
31 |     }
32 | </script>
33 | 
34 | <template>
35 |   <div>
36 |     <v-dialog
37 |       v-model="alert"
38 |       max-width="400"
39 |     >
40 |       <v-card>
41 |         <v-card-title class="headline">
42 |           {{ title }}
43 |         </v-card-title>
44 |         <v-card-text>
45 |           {{ message }}
46 |         </v-card-text>
47 | 
48 |         <v-card-actions>
49 |           <v-spacer></v-spacer>
50 | 
51 |           <v-btn
52 |             color="green darken-1"
53 |             flat="flat"
54 |             @click="dismissAlert()"
55 |           >
56 |             Cancel
57 |           </v-btn>
58 | 
59 |           <v-btn
60 |             color="red darken-1"
61 |             flat="flat"
62 |             @click="confirm()"
63 |           >
64 |             Delete
65 |           </v-btn>
66 |         </v-card-actions>
67 |       </v-card>
68 |     </v-dialog>
69 |   </div>
70 | </template>
71 | 


--------------------------------------------------------------------------------
/src/Form.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form;
 4 | 
 5 | use Musonza\Form\Services\AnswerService;
 6 | use Musonza\Form\Services\FormService;
 7 | use Musonza\Form\Services\QuestionService;
 8 | use Musonza\Form\Services\SubmissionService;
 9 | 
10 | class Form
11 | {
12 |     protected $formService;
13 | 
14 |     public function __construct(
15 |         FormService $formService,
16 |         QuestionService $questionService,
17 |         AnswerService $answerService,
18 |         SubmissionService $submissionService
19 |     ) {
20 |         $this->formService = $formService;
21 |         $this->questionService = $questionService;
22 |         $this->answerService = $answerService;
23 |         $this->submissionService = $submissionService;
24 |     }
25 | 
26 |     public function create(array $data)
27 |     {
28 |         return $this->formService->create($data);
29 |     }
30 | 
31 |     public function formService()
32 |     {
33 |         return $this->formService;
34 |     }
35 | 
36 |     public function createQuestion(array $data)
37 |     {
38 |         return $this->questionService->create($data);
39 |     }
40 | 
41 |     public function questionService()
42 |     {
43 |         return $this->questionService;
44 |     }
45 | 
46 |     public function answerService()
47 |     {
48 |         return $this->answerService;
49 |     }
50 | 
51 |     public function submissionService()
52 |     {
53 |         return $this->submissionService;
54 |     }
55 | 
56 |     public function googleRecaptchaEnabled()
57 |     {
58 |         return config('laravel_forms.google_recaptcha_enabled');
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Laravel Forms
 2 | 
 3 | [![Build Status](https://travis-ci.org/musonza/laravel-forms.svg?branch=master)](https://travis-ci.org/musonza/laravel-forms)
 4 | [![Packagist](https://img.shields.io/packagist/v/musonza/laravel-forms.svg)](https://packagist.org/packages/musonza/laravel-forms)
 5 | 
 6 | <img src="screenshots/forms_list.png" alt="forms list">
 7 | 
 8 | ## Installation
 9 | 1. Install composer package
10 |     ```sh
11 |     composer require musonza/laravel-forms
12 |     ```
13 | 
14 | 1. Publish Assets
15 |     ```sh
16 |     php artisan vendor:publish
17 |     ```
18 | 1. Add Form facade to `config/app.php`
19 |     ```php
20 |     'Form' => Musonza\Form\Facades\FormFacade::class,
21 |     ```
22 |     
23 | 1. Run migrations
24 |     ```sh
25 |     php artisan migrate
26 |     ```  
27 | 
28 | 1. Check the published file config/laravel_forms.php
29 |     - You can enable / disable captcha
30 |     - You can configure the path for your forms dashboard
31 |     - You can add custom field types
32 |     
33 | 1. Access dashboard at
34 | 
35 |     http//your-url.com/laravel-forms (you can change the path in config/laravel_forms.php)
36 | 
37 | ## Adding a Form
38 | <img src="screenshots/new_form.png" alt="adding a form">
39 | 
40 | ## Form details
41 | <img src="screenshots/form_details.png" alt="form details">
42 | 
43 | ## Adding a Field
44 | <img src="screenshots/new_field.png" alt="adding a field">
45 | 
46 | ## Field details
47 | <img src="screenshots/field_details.png" alt="field details">
48 | 
49 | ## Sample Form Output
50 | <img src="screenshots/front_end_form.png" alt="form output">
51 | 
52 | ## Sample Submission
53 | <img src="screenshots/submission_details.png">
54 | 
55 | ## TODO
56 | - Multi page forms
57 | 
58 | ## Credits
59 | https://github.com/laravel/telescope for some of the front-end structuring 
60 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "private": true,
 3 |   "scripts": {
 4 |     "dev": "npm run development",
 5 |     "development": "cross-env NODE_ENV=development node_modules/webpack/bin/webpack.js --progress --hide-modules --config=node_modules/laravel-mix/setup/webpack.config.js",
 6 |     "watch": "npm run development -- --watch",
 7 |     "watch-poll": "npm run watch -- --watch-poll",
 8 |     "hot": "cross-env NODE_ENV=development node_modules/webpack-dev-server/bin/webpack-dev-server.js --inline --hot --config=node_modules/laravel-mix/setup/webpack.config.js",
 9 |     "prod": "npm run production",
10 |     "production": "cross-env NODE_ENV=production node_modules/webpack/bin/webpack.js --no-progress --hide-modules --config=node_modules/laravel-mix/setup/webpack.config.js"
11 |   },
12 |   "devDependencies": {
13 |     "@vue/cli-plugin-babel": "^3.1.1",
14 |     "@vue/cli-plugin-eslint": "^3.1.5",
15 |     "@vue/cli-service": "^3.1.4",
16 |     "axios": "^0.18",
17 |     "babel-eslint": "^10.0.1",
18 |     "bootstrap": "^4.0.0",
19 |     "cross-env": "^5.1",
20 |     "eslint": "^5.8.0",
21 |     "eslint-plugin-vue": "^5.0.0-beta.5",
22 |     "highlight.js": "^9.12.0",
23 |     "jquery": "^3.2",
24 |     "laravel-mix": "^2.0",
25 |     "lodash": "^4.17.4",
26 |     "moment": "^2.10.6",
27 |     "moment-timezone": "^0.5.21",
28 |     "popper.js": "^1.14.5",
29 |     "sql-formatter": "^2.3.1",
30 |     "stylus": "^0.54.5",
31 |     "stylus-loader": "^3.0.1",
32 |     "vue": "^2.5.7",
33 |     "vue-cli-plugin-vuetify": "^0.4.6",
34 |     "vue-json-tree-view": "^2.1.4",
35 |     "vue-router": "^3.0.2",
36 |     "vue-template-compiler": "^2.5.17",
37 |     "vuetify-loader": "^1.0.7"
38 |   },
39 |   "dependencies": {
40 |     "api-class": "0.0.2",
41 |     "md5": "^2.2.1",
42 |     "sortablejs": "^1.7.0",
43 |     "vee-validate": "^2.1.3",
44 |     "vue-api-query": "^1.2.0",
45 |     "vuedraggable": "^2.16.0",
46 |     "vuetify": "^1.3.9",
47 |     "vuex": "^3.0.1"
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/config/laravel_forms.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'dashboard_path_prefix' => 'laravel-forms',
 5 |     'dashboard_css_file' => 'app.css',
 6 |     /*
 7 |     |--------------------------------------------------------------------------
 8 |     | Field Types
 9 |     |--------------------------------------------------------------------------
10 |     |
11 |     | Here you may define add additional field types for use in your application.
12 |     |
13 |      */
14 |     'fields' => [
15 |         Musonza\Form\Fields\CheckBox::class,
16 |         Musonza\Form\Fields\Date::class,
17 |         Musonza\Form\Fields\File::class,
18 |         Musonza\Form\Fields\Password::class,
19 |         Musonza\Form\Fields\Radio::class,
20 |         Musonza\Form\Fields\Select::class,
21 |         Musonza\Form\Fields\Text::class,
22 |         Musonza\Form\Fields\TextArea::class,
23 |         Musonza\Form\Fields\Email::class,
24 |         Musonza\Form\Fields\Number::class,
25 |     ],
26 |     /*
27 |     |--------------------------------------------------------------------------
28 |     | Form Statuses
29 |     |--------------------------------------------------------------------------
30 |     |
31 |     |
32 |      */
33 |     'form_statuses' => [
34 |         0 => [
35 |             'label' => 'Draft',
36 |             'class' => 'warning',
37 |         ],
38 |         1 => [
39 |             'label' => 'Published',
40 |             'class' => 'success',
41 |         ],
42 |         2 => [
43 |             'label' => 'Unpublished',
44 |             'class' => 'error',
45 |         ],
46 |     ],
47 |     /*
48 |     |--------------------------------------------------------------------------
49 |     | Google Recaptcha
50 |     |--------------------------------------------------------------------------
51 |     |
52 |     |
53 |      */
54 |     'google_recaptcha_enabled' => true,
55 |     'google_recaptcha_key' => env('GOOGLE_RECAPTCHA_KEY'),
56 |     'google_recaptcha_secret' => env('GOOGLE_RECAPTCHA_SECRET'),
57 | ];
58 | 


--------------------------------------------------------------------------------
/src/Transformers/FieldTransformer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Transformers;
 4 | 
 5 | class FieldTransformer extends Transformer
 6 | {
 7 |     public function transform($question)
 8 |     {
 9 |         return [
10 |             'id' => $question->id,
11 |             'title' => $question->title,
12 |             'label' => $question->label,
13 |             'field_type' => $question->field_type,
14 |             'field_type_name' => $this->fieldTypeTitle($question->field_type),
15 |             'has_choices' => $this->hasChoices($question->field_type),
16 |             'help_text' => $question->help_text,
17 |             'placeholder' => $question->placeholder,
18 |             'render' => $question->field()->render(),
19 |             'is_required' => $question->is_required,
20 |             'description' => $question->description,
21 |             'validations' => $question->validations,
22 |             'options' => $question->options,
23 |             'options_text' => implode(PHP_EOL, $question->options),
24 |             'position' => $question->position,
25 |             'default_value' => $question->default_value,
26 |             'columns_count' => $question->columns_count ?? 12,
27 |         ];
28 |     }
29 | 
30 |     protected function fieldTypeTitle($field)
31 |     {
32 |         return substr($field, strrpos($field, '\\') + 1);
33 |     }
34 | 
35 |     protected function hasChoices($field)
36 |     {
37 |         return app($field)->hasChoices();
38 |     }
39 | }
40 | 
41 | // "id": {
42 | //     "id": 1,
43 | //     "form_id": "1",
44 | //     "title": "wqeqw",
45 | //     "label": "qweqwe",
46 | //     "place_holder": "qweqwe",
47 | //     "help_text": null,
48 | //     "is_required": true,
49 | //     "description": "eqweqweqwe",
50 | //     "field_type": "Musonza\\Form\\Fields\\CheckBox",
51 | //     "validations": null,
52 | //     "properties": null,
53 | //     "options": [],
54 | //     "created_at": "2018-10-13 16:33:29",
55 | //     "updated_at": "2018-10-13 16:33:29"
56 | // }
57 | 


--------------------------------------------------------------------------------
/src/Models/Question.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class Question extends Model
 8 | {
 9 |     // use \Lookitsatravis\Listify\Listify;
10 |     protected $table = 'mc_questions';
11 |     protected $fillable = [
12 |         'label',
13 |         'placeholder',
14 |         'help_text',
15 |         'description',
16 |         'is_required',
17 |         'properties',
18 |         'field_type',
19 |         'options',
20 |         'default_value',
21 |         'columns_count',
22 |         'form_id',
23 |     ];
24 |     /**
25 |      * The attributes that should be cast to native types.
26 |      *
27 |      * @var array
28 |      */
29 |     protected $casts = [
30 |         'is_required' => 'boolean',
31 |         'properties' => 'array',
32 |         'options' => 'array',
33 |         'position' => 'integer',
34 |     ];
35 | 
36 |     protected $attributes = [
37 |         'options' => '{}',
38 |     ];
39 | 
40 |     public function __construct(array $attributes = array(), $exists = false)
41 |     {
42 |         parent::__construct($attributes, $exists);
43 | 
44 |         // $this->initListify();
45 |     }
46 | 
47 |     /**
48 |      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
49 |      */
50 |     public function form()
51 |     {
52 |         return $this->belongsTo(Form::class);
53 |     }
54 | 
55 |     public function answers()
56 |     {
57 |         return $this->hasMany(Answer::class);
58 |     }
59 | 
60 |     public function addValidations($validations)
61 |     {
62 |         $this->validations = $validations;
63 |         $this->save();
64 |         return $this;
65 |     }
66 | 
67 |     /**
68 |      * Get prefilled value for the field.
69 |      *
70 |      * @return mixed
71 |      */
72 |     public function getValueAttribute()
73 |     {
74 |         return "";
75 |     }
76 | 
77 |     public function field()
78 |     {
79 |         return new $this->field_type($this, $this->options);
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/Feature/Question/CreateTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Feature\Question;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Text;
 7 | use Musonza\Form\Tests\TestCase;
 8 | 
 9 | class CreateTest extends TestCase
10 | {
11 |     /**
12 |      * @var Form
13 |      */
14 |     private $form;
15 | 
16 |     public function setUp(): void
17 |     {
18 |         parent::setUp();
19 |         $this->form = Form::create(['title' => 'Contact Form']);
20 |     }
21 | 
22 |     public function testCreateSuccess()
23 |     {
24 |         $data = [
25 |             'label' => 'First Name Label',
26 |             'description' => 'Description',
27 |             'field_type' => Text::class,
28 |         ];
29 | 
30 |         $response = $this->postJson(route('forms.fields.store', $this->form->id), $data);
31 | 
32 |         $response
33 |             ->assertStatus(200)
34 |             ->assertJson([
35 |                 'label' => 'First Name Label',
36 |                 'description' => 'Description',
37 |                 'field_type' => 'Musonza\Form\Fields\Text',
38 |             ]);
39 |     }
40 | 
41 |     public function testQuestionRequiresLabel()
42 |     {
43 |         $data = [
44 |             'description' => 'Description',
45 |             'field_type' => Text::class,
46 |         ];
47 | 
48 |         $response = $this->postJson(route('forms.fields.store', $this->form->id), $data)
49 |             ->assertStatus(422)
50 |             ->assertJson([
51 |                 'message' => 'The given data was invalid.',
52 |             ]);
53 |     }
54 | 
55 |     public function testQuestionRequiresFieldType()
56 |     {
57 |         $data = [
58 |             'label' => 'First Name Label',
59 |             'description' => 'Description',
60 |         ];
61 | 
62 |         $response = $this->postJson(route('forms.fields.store', $this->form->id), $data)
63 |             ->assertStatus(422)
64 |             ->assertJson([
65 |                 'message' => 'The given data was invalid.',
66 |             ]);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/tests/Unit/AnswerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Unit;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Text;
 7 | use Musonza\Form\Models\Answer;
 8 | use Musonza\Form\Models\Submission;
 9 | use Musonza\Form\Tests\TestCase;
10 | 
11 | class AnswerTest extends TestCase
12 | {
13 |     protected $form;
14 |     protected $question;
15 |     protected $answer;
16 | 
17 |     public function setUp(): void
18 |     {
19 |         parent::setUp();
20 |         $this->form = Form::create(['title' => 'Contact Form']);
21 |         $this->question = Form::createQuestion(
22 |             [
23 |                 'title' => 'First Name',
24 |                 'label' => 'First Name',
25 |                 'description' => 'Description',
26 |                 'field_type' => Text::class,
27 |                 'form_id' => $this->form->id,
28 |             ]
29 |         );
30 | 
31 |         $submission = $this->form->addSubmission([]);
32 |         $question = $this->form->questions()->first();
33 |         $this->answer = $question->answers()->create([
34 |             'value' => 'Jane',
35 |             'submission_id' => $submission->id,
36 |         ]);
37 |     }
38 | 
39 |     public function testCreateFormQuestionAnswer()
40 |     {
41 |         $this->assertInstanceOf(Answer::class, $this->answer);
42 |         $this->assertInstanceOf(Submission::class, $this->answer->submission);
43 |     }
44 | 
45 |     public function testGetAnswerById()
46 |     {
47 |         $answer = Form::answerService()->getById(1);
48 |         $this->assertEquals($this->answer->id, $answer->id);
49 |         $this->assertInstanceOf(Answer::class, $answer);
50 |     }
51 | 
52 |     public function testDeleteAnswer()
53 |     {
54 |         $this->assertDatabaseHas($this->tablePrefix . 'answers', ['id' => 1, 'value' => 'Jane']);
55 | 
56 |         Form::answerService()
57 |             ->getById(1)
58 |             ->delete();
59 | 
60 |         $this->assertDatabaseMissing($this->tablePrefix . 'answers', ['id' => 1, 'value' => 'Jane']);
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/resources/js/components/Alert.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     import DialogComponent from '@/components/DialogComponent';
 3 |     export default {
 4 |       name: 'Alert',
 5 | 
 6 |       components: {
 7 |         DialogComponent,
 8 |       },
 9 | 
10 |       data: () => ({
11 |         timeout: null,
12 |       }),
13 | 
14 |       props: {
15 |         type: String,
16 |         title: null,
17 |         message: String,
18 |         autoDismiss: Number,
19 |         show: Boolean,
20 |         confirmationAgree: null,
21 |       },
22 | 
23 |       methods: {
24 |         close(){
25 |           clearTimeout(this.timeout);
26 |           this.$root.alert.type = null;
27 |         },
28 |       },
29 | 
30 |       computed: {
31 |         alert: function () {
32 |           return this.$root.alert.show;
33 |         }
34 |       },
35 | 
36 |       mounted() {
37 |         if (this.autoDismiss && this.$root.alert.type != 'confirmation') {
38 |           this.timeout = setTimeout(() => {
39 |             this.close();
40 |             this.dismissAlert();
41 |           }, this.autoDismiss);
42 |         }
43 |       }
44 |     }
45 | </script>
46 | 
47 | <template>
48 |   <div>
49 |     <div v-if="type == 'confirmation'">
50 |       <dialog-component
51 |         :title="title"
52 |         :message="message"
53 |         :confirmationAgree="confirmationAgree"></dialog-component>
54 |     </div>
55 |     <div v-else-if="type == 'success' || type == 'warning'">
56 |       <v-snackbar
57 |         v-model="show"
58 |         :bottom="true"
59 |         :left="true"
60 |         :multi-line="true"
61 |       >
62 |         {{ message }}
63 |         <v-btn
64 |           color="pink"
65 |           flat
66 |           @click="close()"
67 |         >
68 |           Close
69 |         </v-btn>
70 |       </v-snackbar>
71 |     </div>
72 |     <div v-else>
73 |       <v-alert
74 |         :value="show"
75 |         :type="type"
76 |         transition="scale-transition"
77 |         outline
78 |         class="mb-3"
79 |       >
80 |       {{ message }}
81 |       </v-alert>
82 |     </div>
83 |   </div>
84 | </template>
85 | 


--------------------------------------------------------------------------------
/database/seeds/FormsDatabaseSeeder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Seeder;
 4 | use Musonza\Form\Fields\Text;
 5 | use Musonza\Form\Fields\TextArea;
 6 | use Musonza\Form\Models\Form;
 7 | use Musonza\Form\Models\Question;
 8 | 
 9 | class FormsDatabaseSeeder extends Seeder
10 | {
11 |     /**
12 |      * Seed the application's database.
13 |      *
14 |      * @return void
15 |      */
16 |     public function run()
17 |     {
18 |         // $this->call(UsersTableSeeder::class);
19 |         $fieldTypes = ['text', 'textarea', 'checkbox', 'radio', 'select'];
20 |         $props = [];
21 |         $props['choices'] = [
22 |             [
23 |                 'label' => 'Choice1',
24 |                 'recode' => 1,
25 |             ],
26 |             [
27 |                 'label' => 'Choice2',
28 |                 'description' => 'This is a test description',
29 |                 'attachment' => [
30 |                     "type" => "image",
31 |                     "href" => "http://example.com/img",
32 |                 ],
33 |             ],
34 |             ['label' => 'Choice3', 'recode' => 3],
35 |         ];
36 | 
37 |         factory(Form::class, 55)->create()->each(function ($form) use ($props) {
38 |             $form->questions()->save(factory(Question::class)->make([
39 |                 'form_id' => $form->id,
40 |                 'field_type' => Text::class,
41 |             ]));
42 |             $form->questions()->save(factory(Question::class)->make([
43 |                 'form_id' => $form->id,
44 |                 'field_type' => TextArea::class,
45 |             ]));
46 |             $form->questions()->save(factory(Question::class)->make([
47 |                 'form_id' => $form->id,
48 |                 'field_type' => Text::class,
49 |                 'properties' => $props,
50 |             ]));
51 |             $form->questions()->save(factory(Question::class)->make([
52 |                 'form_id' => $form->id,
53 |                 'field_type' => Text::class,
54 |                 'properties' => $props,
55 |             ]));
56 |             $form->questions()->save(factory(Question::class)->make([
57 |                 'form_id' => $form->id,
58 |                 'field_type' => Text::class,
59 |                 'properties' => $props,
60 |             ]));
61 |         });
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/tests/BaseTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests;
 4 | 
 5 | use CreateFormTables;
 6 | use Illuminate\Database\Schema\Blueprint;
 7 | use Illuminate\Foundation\Exceptions\Handler;
 8 | use Illuminate\Support\Facades\Schema;
 9 | use Musonza\Form\User;
10 | 
11 | require __DIR__ . '/../database/migrations/create_form_tables.php';
12 | 
13 | trait BaseTestCase
14 | {
15 |     protected function migrateTestTables()
16 |     {
17 |         Schema::create('users', function (Blueprint $table) {
18 |             $table->increments('id');
19 |             $table->string('name');
20 |             $table->string('email')->unique();
21 |             $table->string('password');
22 |             $table->rememberToken();
23 |             $table->timestamps();
24 |         });
25 |     }
26 | 
27 |     protected function migrate()
28 |     {
29 |         (new CreateFormTables)->up();
30 |         $this->migrateTestTables();
31 |     }
32 | 
33 |     public function tearDown(): void
34 |     {
35 |         $this->rollbackTestTables();
36 |         (new CreateFormTables)->down();
37 |         // parent::tearDown();
38 |     }
39 | 
40 |     public function createUsers($count = 1)
41 |     {
42 |         return factory(User::class, $count)->create();
43 |     }
44 | 
45 |     protected function rollbackTestTables()
46 |     {
47 |         Schema::drop('users');
48 |     }
49 | 
50 |     protected function getPackageProviders($app)
51 |     {
52 |         return [
53 |             \Orchestra\Database\ConsoleServiceProvider::class,
54 |             \Musonza\Form\FormServiceProvider::class,
55 |         ];
56 |     }
57 | 
58 |     protected function getPackageAliases($app)
59 |     {
60 |         return [
61 |             'Form' => \Musonza\Form\Facades\FormFacade::class,
62 |         ];
63 |     }
64 | 
65 |     protected function disableExceptionHandling($app)
66 |     {
67 |         $app->instance(ExceptionHandler::class, new class extends Handler
68 |         {
69 |             public function __construct()
70 |             {
71 |             }
72 | 
73 |             public function report(\Exception $e)
74 |             {
75 |                 // no-op
76 |             }
77 | 
78 |             public function render($request, \Exception $e)
79 |             {
80 |                 throw $e;
81 |             }
82 |         });
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/src/FormServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | 
 7 | class FormServiceProvider extends ServiceProvider
 8 | {
 9 |     /**
10 |      * Indicates if loading of the provider is deferred.
11 |      *
12 |      * @var bool
13 |      */
14 |     protected $defer = false;
15 | 
16 |     /**
17 |      * Bootstrap application services.
18 |      *
19 |      * @return void
20 |      */
21 |     public function boot()
22 |     {
23 |         $this->publishMigrations();
24 |         $this->publishDatabaseSeeds();
25 |         $this->publishConfig();
26 | 
27 |         require __DIR__ . '/Http/routes.php';
28 | 
29 |         $this->publishes([
30 |             __DIR__ . '/../public' => public_path('vendor/laravel-forms'),
31 |         ], 'laravel-forms-assets');
32 |     }
33 | 
34 |     /**
35 |      * Register application services.
36 |      *
37 |      * @return void
38 |      */
39 |     public function register()
40 |     {
41 |         $this->app->bind('form', function () {
42 |             return $this->app->make(\Musonza\Form\Form::class);
43 |         });
44 |     }
45 | 
46 |     /**
47 |      * Publish package's migrations.
48 |      *
49 |      * @return void
50 |      */
51 |     public function publishMigrations()
52 |     {
53 |         $timestamp = date('Y_m_d_His', time());
54 |         $stub = __DIR__ . '/../database/migrations/create_form_tables.php';
55 |         $target = $this->app->databasePath() . '/migrations/' . $timestamp . '_create_form_tables.php';
56 | 
57 |         $this->publishes([$stub => $target], 'laravel_forms.migrations');
58 |     }
59 | 
60 |     /**
61 |      * Publish database seeds.
62 |      *
63 |      * @return void
64 |      */
65 |     public function publishDatabaseSeeds()
66 |     {
67 |         $this->publishes([
68 |             __DIR__ . '/../database/seeds' => database_path() . '/seeds',
69 |         ], 'laravel_forms.database_seeds');
70 |     }
71 | 
72 |     /**
73 |      * Publish package's config file.
74 |      *
75 |      * @return void
76 |      */
77 |     public function publishConfig()
78 |     {
79 |         $this->loadViewsFrom(__DIR__ . '/../resources/views', 'laravel-forms');
80 |         $this->publishes([
81 |             __DIR__ . '/../config' => config_path(),
82 |         ], 'laravel_forms.config');
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/resources/js/base.js:
--------------------------------------------------------------------------------
 1 | export default {
 2 |   methods: {
 3 |     /**
 4 |      * Show an error message.
 5 |      */
 6 |     alertError(message) {
 7 |       this.$root.alert.type = 'error';
 8 |       this.$root.alert.message = message;
 9 |       this.$root.alert.show = true;
10 |     },
11 | 
12 |     alertWarning(message) {
13 |       this.$root.alert.type = 'warning';
14 |       this.$root.alert.message = message;
15 |       this.$root.alert.show = true;
16 |     },
17 | 
18 |     /**
19 |      * Show a success message.
20 |      */
21 |     alertSuccess(message, autoClose) {
22 |       this.$root.alert.type = 'success';
23 |       this.$root.alert.message = message;
24 |       this.$root.alert.show = true;
25 |     },
26 | 
27 |     /**
28 |      * Show confirmation message.
29 |      */
30 |     alertConfirm(message, success, failure, title) {
31 |       this.$root.alert.type = 'confirmation';
32 |       this.$root.alert.autoClose = false;
33 |       this.$root.alert.title = title;
34 |       this.$root.alert.message = message;
35 |       this.$root.alert.confirmationAgree = success;
36 |       this.$root.alert.confirmationCancel = failure;
37 |       this.$root.alert.show = true;
38 |     },
39 | 
40 |     dismissAlert() {
41 |       this.$root.alert.show = false;
42 |     },
43 | 
44 |     formatErrorMessage(response) {
45 |       let message = '';
46 |       if (response.data) {
47 |         let data = response.data;
48 |         message += data.message;
49 | 
50 |         if (data.errors) {
51 |           for (let [key, value] of Object.entries(data.errors)) {
52 |             message += ' ' + value;
53 |             break;
54 |           }
55 |         }
56 |       }
57 |       return message;
58 |     },
59 | 
60 |     getConfirmationMessages() {
61 |       return {
62 |         'delete_form': {
63 |           'title': 'Delete Form',
64 |           'message': 'Are you sure you want to delete this form? This action cannot be undone.'
65 |         },
66 |         'delete_field': {
67 |           'title': 'Delete Field',
68 |           'message': 'Are you sure you want to delete this field? This action cannot be undone.'
69 |         },
70 |         'delete_submission': {
71 |           'title': 'Delete Submission',
72 |           'message': 'Are you sure you want to delete this submission? This action cannot be undone.'
73 |         },
74 |       }
75 |     }
76 |   }
77 | };


--------------------------------------------------------------------------------
/database/factories/ModelFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Faker\Generator as Faker;
 4 | use Musonza\Form\Fields\Text;
 5 | use Musonza\Form\Models\Form;
 6 | use Musonza\Form\Models\Question;
 7 | use Musonza\Form\Models\Submission;
 8 | use Musonza\Form\Models\SubmissionResponse;
 9 | 
10 | $factory->define(Musonza\Form\User::class, function (Faker $faker) {
11 |     return [
12 |         'name' => $faker->name,
13 |         'email' => $faker->unique()->safeEmail,
14 |         'password' => '$2y$10$TKh8H1.PfQx37YgCzwiKb.KjNyWgaHb9cbcoQgdIVFlYg7B77UdFm', // secret
15 |         'remember_token' => str_random(10),
16 |     ];
17 | });
18 | 
19 | $factory->define(Form::class, function (Faker $faker) {
20 |     return [
21 |         'title' => $faker->sentence,
22 |         'description' => $faker->sentence,
23 |     ];
24 | });
25 | 
26 | $factory->define(Question::class, function (Faker $faker) {
27 |     return [
28 |         'label' => $faker->sentence,
29 |         'description' => $faker->sentence,
30 |         'form_id' => function () {
31 |             return factory(Form::class)->create()->id;
32 |         },
33 |         'field_type' => Text::class,
34 |         'is_required' => true,
35 |     ];
36 | });
37 | 
38 | $factory->define(Submission::class, function (Faker $faker) {
39 |     return [
40 |         'ip_address' => $faker->ipv4,
41 |         'response' => [
42 |             'field1' => [
43 |                 'field_identifier' => 'field1',
44 |                 'response_text' => $faker->sentence,
45 |             ],
46 |             'field2' => [
47 |                 'field_identifier' => 'field2',
48 |                 'response_text' => $faker->paragraph,
49 |             ],
50 |             'field3' => [
51 |                 'field_identifier' => 'field3',
52 |                 'response_text' => $faker->sentence,
53 |             ],
54 |         ],
55 |         'form_id' => function () {
56 |             return factory(Form::class)->create()->id;
57 |         },
58 |     ];
59 | });
60 | 
61 | $factory->define(SubmissionResponse::class, function (Faker $faker) {
62 |     return [
63 |         'submission_id' => function () {
64 |             return factory(Submission::class)->create()->id;
65 |         },
66 |         'question_id' => function () {
67 |             return factory(Question::class)->create()->id;
68 |         },
69 |         'response_text' => $faker->sentence,
70 |     ];
71 | });
72 | 


--------------------------------------------------------------------------------
/tests/Unit/QuestionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Unit;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Text;
 7 | use Musonza\Form\Fields\TextArea;
 8 | use Musonza\Form\Tests\TestCase;
 9 | 
10 | class QuestionTest extends TestCase
11 | {
12 |     protected $form;
13 |     protected $question;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 |         $this->form = Form::create(['title' => 'Contact Form']);
19 |         $this->question = Form::createQuestion(
20 |             [
21 |                 'label' => 'First Name',
22 |                 'description' => 'Description',
23 |                 'field_type' => Text::class,
24 |                 'form_id' => $this->form->id,
25 |             ]
26 |         );
27 |     }
28 | 
29 |     public function testCreatesQuestion()
30 |     {
31 |         $this->assertDatabaseHas($this->tablePrefix . 'questions', ['id' => 1]);
32 |     }
33 | 
34 |     public function testGetQuestionById()
35 |     {
36 |         $question = Form::questionService()->getById(1);
37 |         $this->assertEquals(1, $question->id);
38 |     }
39 | 
40 |     public function testQuestionBelongsToForm()
41 |     {
42 |         $this->assertInstanceOf(\Musonza\Form\Models\Form::class, $this->question->form);
43 |     }
44 | 
45 |     public function testUpdatesQuestion()
46 |     {
47 |         $this->question->update([
48 |             'label' => 'New Label',
49 |             'field_type' => TextArea::class,
50 |         ]);
51 | 
52 |         $this->assertEquals('New Label', $this->question->label);
53 |         $this->assertInstanceOf(TextArea::class, $this->question->field());
54 |     }
55 | 
56 |     public function testDeleteQuestion()
57 |     {
58 |         $this->assertDatabaseHas($this->tablePrefix . 'questions', ['id' => 1]);
59 |         Form::questionService()
60 |             ->getById(1)
61 |             ->delete();
62 |         $this->assertDatabaseMissing($this->tablePrefix . 'questions', ['id' => 1]);
63 |     }
64 | 
65 |     public function testAddQuestionValidations()
66 |     {
67 |         $validations = "required | email";
68 |         $this->question->addValidations($validations);
69 |         $this->assertEquals($validations, $this->question->validations);
70 |     }
71 | 
72 |     public function testResolvesQuestionField()
73 |     {
74 |         $this->assertInstanceOf(Text::class, $this->question->field());
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/resources/js/pages/forms/fields/create.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 |     import Field from '@/models/Field';
 3 |     import Form from '@/models/Form';
 4 |     export default {
 5 | 
 6 |       $_veeValidate: {
 7 |         validator: 'new'
 8 |       },
 9 | 
10 |       data: () => ({
11 |         formId: null,
12 |         fieldTypes: null,
13 |         payload: {
14 |           field_type: '',
15 |           label: '',
16 |         },
17 |       }),
18 | 
19 |       methods: {
20 |         async getFieldTypes() {
21 |           let response = await Field.get();
22 |           this.fieldTypes = response.data;
23 |         },
24 | 
25 |         getItems() {
26 |           let items = [];
27 |           for (let f of this.fieldTypes) {
28 |             items.push(f.id);
29 |           }
30 |           return items;
31 |         },
32 | 
33 |         cancel() {
34 |           this.$router.go(-1);
35 |         },
36 | 
37 |         async submit () {
38 |           let valid = await this.$validator.validateAll();
39 |           if (valid) {
40 |             await (new Form({'id': this.formId}))
41 |               .fields()
42 |               .attach(this.payload)
43 |               .then(response => {
44 |                 this.alertSuccess('Successfully created field!');
45 |                 this.$router.go(-1);
46 |               })
47 |               .catch(error => {
48 |                 this.alertError(this.formatErrorMessage(error.response));
49 |               });
50 |           } else {
51 |             this.alertError('Invalid input provided');
52 |           }
53 |         },
54 |       },
55 | 
56 |       mounted() {
57 |         this.formId = this.$route.params.id;
58 |         this.getFieldTypes();
59 |       },
60 |     }
61 | </script>
62 | 
63 | <template>
64 |   <v-card class="pl-2 pr-2 pt-2 pb-2">
65 |     <h1 class="primary--text mb-1">New Field</h1>
66 |     <div v-if="fieldTypes">
67 |       <form>
68 | 
69 |       <v-select
70 |         :items="getItems()"
71 |         label="Field Type"
72 |         v-model="payload.field_type"
73 |         :error-messages="errors.collect('field_type')"
74 |         v-validate="'required'"
75 |         outline
76 |       ></v-select>
77 | 
78 |       <v-text-field
79 |         outline
80 |         v-validate="'required'"
81 |         v-model="payload.label"
82 |         :error-messages="errors.collect('label')"
83 |         label="Label"
84 |         data-vv-name="label"
85 |         required
86 |       ></v-text-field>
87 | 
88 |       <v-btn @click="submit" color="primary">save</v-btn>
89 |       <v-btn @click="cancel">cancel</v-btn>
90 | 
91 |       </form>
92 |     </div>
93 |   </v-card>
94 | </template>
95 | 


--------------------------------------------------------------------------------
/tests/Unit/Fields/FieldsRenderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\Form\Tests\Unit;
 4 | 
 5 | use Form;
 6 | use Musonza\Form\Fields\Password;
 7 | use Musonza\Form\Fields\Radio;
 8 | use Musonza\Form\Fields\Select;
 9 | use Musonza\Form\Fields\Text;
10 | use Musonza\Form\Fields\TextArea;
11 | use Musonza\Form\Tests\TestCase;
12 | 
13 | class FieldsRenderTest extends TestCase
14 | {
15 |     protected $form;
16 |     protected $question;
17 | 
18 |     public function setUp(): void
19 |     {
20 |         parent::setUp();
21 |         $this->form = Form::create(['title' => 'Contact Form']);
22 |     }
23 | 
24 |     /**
25 |      * @dataProvider fieldsDataProvider
26 |      */
27 |     public function testFieldRender($field, $options, $expected)
28 |     {
29 |         $question = $this->createQuestion($field, $options);
30 | 
31 |         $this->assertEquals($expected, $question->field()->render());
32 |     }
33 | 
34 |     public function fieldsDataProvider()
35 |     {
36 |         return [
37 |             [
38 |                 TextArea::class, [],
39 |                 '<textarea name="field_1" id="field_1" class="form-control"></textarea>',
40 |             ],
41 |             [
42 |                 Text::class, [],
43 |                 '<input name="field_1" id="field_1" class="form-control" type="text" value="">',
44 |             ],
45 |             [
46 |                 Password::class, [],
47 |                 '<input name="field_1" id="field_1" class="form-control" type="password" value="">',
48 |             ],
49 |             [
50 |                 Radio::class,
51 |                 ['male'],
52 |                 '<input type="radio"  name="field_1" id="field_1" class="" value="0"> male<br>',
53 |             ],
54 | 
55 |             [
56 |                 Select::class,
57 |                 ['male', 'female'],
58 |                 '<select name="field_1" id="field_1" class="form-control"><option value="0" selected="selected">male</option><option value="1">female</option></select>',
59 |             ],
60 |             [
61 |                 Select::class,
62 |                 ['m' => 'male', 'f' => 'female'],
63 |                 '<select name="field_1" id="field_1" class="form-control"><option value="m">male</option><option value="f">female</option></select>',
64 |             ],
65 |         ];
66 |     }
67 | 
68 |     public function createQuestion($field, $options)
69 |     {
70 |         return Form::createQuestion(
71 |             [
72 |                 'label' => 'First Name',
73 |                 'description' => 'Description',
74 |                 'field_type' => $field,
75 |                 'options' => $options,
76 |                 'form_id' => $this->form->id,
77 |             ]
78 |         );
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/resources/js/components/FormsComponent.vue:
--------------------------------------------------------------------------------
 1 | <script>
 2 | import Form from "@/models/Form";
 3 | export default {
 4 |   name: "FormsComponent",
 5 |   data: () => ({
 6 |     headers: [
 7 |       { text: "ID", value: "id" },
 8 |       { text: "Title", value: "title" },
 9 |       { text: "Status", value: "status.label", sortable: false },
10 |       { text: "Submissions", value: "submissions_count" },
11 |       { text: "", value: "", sortable: false }
12 |     ],
13 |     forms: []
14 |   }),
15 | 
16 |   methods: {
17 |     async getForms() {
18 |       this.forms = await Form.$get();
19 |     },
20 | 
21 |     previewForm(form) {
22 |       window.open(`/forms/${form.id}/submissions/create`, "_blank");
23 |     },
24 | 
25 |     editForm(form) {
26 |       this.$router.push({ name: "forms-edit", params: { id: form.id } });
27 |     },
28 | 
29 |     deleteForm(form) {
30 |       const confirmation = this.getConfirmationMessages().delete_form;
31 |       this.alertConfirm(
32 |         confirmation.message,
33 |         async () => {
34 |           let formModel = await Form.find(form.id);
35 |           formModel
36 |             .delete()
37 |             .then(response => {
38 |               this.forms.splice(this.forms.indexOf(form), 1);
39 |               this.alertWarning("Successfully deleted the form!");
40 |             })
41 |             .catch(error => {
42 |               this.alertError(this.formatErrorMessage(error.response));
43 |             });
44 |         },
45 |         null,
46 |         confirmation.title
47 |       );
48 |     },
49 | 
50 |     newForm() {
51 |       this.$router.push({ name: "forms-edit", params: { id: 0 } });
52 |     }
53 |   },
54 | 
55 |   created() {
56 |     this.getForms();
57 |   }
58 | };
59 | </script>
60 | 
61 | <template>
62 |   <div>
63 |     <v-btn color="primary" class="right" @click="newForm()">Create Form</v-btn>
64 |     <v-data-table :headers="headers" :items="forms" class="elevation-1">
65 |       <template slot="items" slot-scope="props">
66 |         <td>{{ props.item.id }}</td>
67 |         <td>{{ props.item.title }}</td>
68 |         <td>
69 |           <v-chip
70 |             label
71 |             small
72 |             :color="props.item.status.class"
73 |             text-color="white"
74 |             class="status-label font-weight-bold ml-0"
75 |           >{{ props.item.status.label }}</v-chip>
76 |         </td>
77 |         <td>{{ props.item.submissions_count }}</td>
78 |         <td>
79 |           <v-icon small class="mr-2" @click="previewForm(props.item)">visibility</v-icon>
80 | 
81 |           <v-icon small color="blue" class="mr-2" @click="editForm(props.item)">edit</v-icon>
82 | 
83 |           <v-icon small color="red" @click="deleteForm(props.item)">delete</v-icon>
84 |         </td>
85 |       </template>
86 |     </v-data-table>
87 |   </div>
88 | </template>
89 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/FormController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\Form\Http\Controllers;
  4 | 
  5 | use Musonza\Form\Form;
  6 | use Musonza\Form\Http\Requests\CreateFormRequest;
  7 | use Musonza\Form\Http\Requests\DeleteFormRequest;
  8 | use Musonza\Form\Http\Requests\ListFormRequest;
  9 | use Musonza\Form\Http\Requests\UpdateFormRequest;
 10 | use Musonza\Form\Models\Form as FormModel;
 11 | use Musonza\Form\Transformers\FormTransformer;
 12 | 
 13 | class FormController extends Controller
 14 | {
 15 |     private $formTransformer;
 16 |     /**
 17 |      * @var Form
 18 |      */
 19 |     private $form;
 20 | 
 21 |     /**
 22 |      * FormController constructor.
 23 |      *
 24 |      * @param FormTransformer $formTransformer
 25 |      */
 26 |     public function __construct(FormTransformer $formTransformer, Form $form)
 27 |     {
 28 |         $this->formTransformer = $formTransformer;
 29 |         $this->form = $form;
 30 |     }
 31 | 
 32 |     /**
 33 |      * List forms.
 34 |      *
 35 |      * @param  ListFormRequest $request
 36 |      * @return \Illuminate\Http\Response
 37 |      */
 38 |     public function index(ListFormRequest $request)
 39 |     {
 40 |         $forms = FormModel::all();
 41 | 
 42 |         return response($this->formTransformer->transformCollection($forms));
 43 |     }
 44 | 
 45 |     /**
 46 |      * Gets the form by id.
 47 |      *
 48 |      * @param  FormModel $form
 49 |      * @return \Illuminate\Http\Response
 50 |      */
 51 |     public function show(FormModel $form)
 52 |     {
 53 |         request()->query->add(['include' => 'questions']);
 54 | 
 55 |         return response($this->formTransformer->transformItem($form));
 56 |     }
 57 | 
 58 |     /**
 59 |      * Stores the created form.
 60 |      *
 61 |      * @param  CreateFormRequest $request
 62 |      * @return \Illuminate\Http\Response
 63 |      */
 64 |     public function store(CreateFormRequest $request)
 65 |     {
 66 |         $form = $this->form->create($request->validated());
 67 | 
 68 |         return response($this->formTransformer->transformItem($form));
 69 |     }
 70 | 
 71 |     /**
 72 |      * Updates form details.
 73 |      *
 74 |      * @param  UpdateFormRequest $request
 75 |      * @param  FormModel         $form
 76 |      * @return \Illuminate\Http\Response
 77 |      */
 78 |     public function update(UpdateFormRequest $request, FormModel $form)
 79 |     {
 80 |         $form->update($request->validated());
 81 | 
 82 |         return response($this->formTransformer->transformItem($form));
 83 |     }
 84 | 
 85 |     /**
 86 |      * Deletes a form.
 87 |      *
 88 |      * @param DeleteFormRequest $request
 89 |      * @param FormModel $form
 90 |      * @return \Illuminate\Http\Response
 91 |      * @throws \Exception
 92 |      */
 93 |     public function destroy(DeleteFormRequest $request, FormModel $form)
 94 |     {
 95 |         $form->delete();
 96 | 
 97 |         return response('', 201);
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Fields/FormField.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\Form\Fields;
  4 | 
  5 | use Musonza\Form\Models\Form;
  6 | use Musonza\Form\Models\Question;
  7 | 
  8 | abstract class FormField
  9 | {
 10 |     protected $controlType = null;
 11 |     protected $validations = '';
 12 |     protected $required = false;
 13 |     protected $name;
 14 |     protected $fieldHtmlId;
 15 |     protected $hasChoices = false;
 16 |     protected $question;
 17 | 
 18 |     /**
 19 |      * [__construct description]
 20 |      * @param string $name    [description]
 21 |      * @param array  $options [description]
 22 |      */
 23 |     public function __construct(Question $question, $options = [])
 24 |     {
 25 |         $this->question = $question;
 26 |         $this->name = "field_{$question->id}";
 27 |         $this->options = $options;
 28 |         $this->fieldHtmlId = $this->nameToId();
 29 |     }
 30 | 
 31 |     protected function input()
 32 |     {
 33 |         $this->attributes['type'] = $this->controlType;
 34 |         $this->attributes['value'] = $this->question->value;
 35 |         $this->attributes['placeholder'] = $this->question->placeholder;
 36 |         $this->attributes = $this->attributes($this->attributes);
 37 | 
 38 |         $input = '<input' . $this->attributes . '>';
 39 | 
 40 |         //dd($input);
 41 | 
 42 |         return '<input' . $this->attributes . '>';
 43 |     }
 44 | 
 45 |     /**
 46 |      * [attributes description]
 47 |      * @param  array  $attributes [description]
 48 |      * @return [type]             [description]
 49 |      */
 50 |     protected function attributes(array $attributes)
 51 |     {
 52 |         $html = array();
 53 | 
 54 |         foreach ((array) $attributes as $key => $value) {
 55 |             if (is_numeric($key)) {
 56 |                 $key = $value;
 57 |             }
 58 |             if ($value !== null) {
 59 |                 $html[] = $key . '="' . e($value) . '"';
 60 |             }
 61 |         }
 62 |         return empty($html) ? '' : ' ' . implode(' ', $html);
 63 |     }
 64 | 
 65 |     /**
 66 |      * [nameToId description]
 67 |      * @return [type] [description]
 68 |      */
 69 |     protected function nameToId()
 70 |     {
 71 |         return str_replace(array('.', '[]', '[', ']'), array('_', '', '_', ''), $this->name);
 72 |     }
 73 | 
 74 |     /**
 75 |      * [render description]
 76 |      * @return [type] [description]
 77 |      */
 78 |     public function render()
 79 |     {
 80 |         if (!isset($this->attributes['name'])) {
 81 |             $this->attributes['name'] = $this->name;
 82 |         }
 83 | 
 84 |         if ($this->question->is_required) {
 85 |             $this->attributes['required'] = true;
 86 |         }
 87 | 
 88 |         if (!isset($this->attributes['id'])) {
 89 |             $this->attributes['id'] = $this->nameToId();
 90 |         }
 91 | 
 92 |         $this->attributes['class'] = "form-control";
 93 | 
 94 |         return $this->input();
 95 |     }
 96 | 
 97 |     public function hasChoices()
 98 |     {
 99 |         return $this->hasChoices;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/FormSubmissionController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\Form\Http\Controllers;
  4 | 
  5 | use Illuminate\Http\Request;
  6 | use Musonza\Form\Form;
  7 | use Musonza\Form\Http\Requests\CreateFormSubmissionRequest;
  8 | use Musonza\Form\Models\Form as FormModel;
  9 | use Musonza\Form\Models\Submission;
 10 | use Musonza\Form\Transformers\FormTransformer;
 11 | use Musonza\Form\Transformers\SubmissionTransformer;
 12 | 
 13 | class FormSubmissionController extends Controller
 14 | {
 15 |     /**
 16 |      * @var FormTransformer
 17 |      */
 18 |     protected $formTransformer;
 19 | 
 20 |     /**
 21 |      * @var SubmissionTransformer
 22 |      */
 23 |     private $submissionTransformer;
 24 | 
 25 |     /**
 26 |      * @var Form
 27 |      */
 28 |     private $form;
 29 | 
 30 |     public function __construct(
 31 |         FormTransformer $formTransformer,
 32 |         SubmissionTransformer $submissionTransformer,
 33 |         Form $form
 34 |     ){
 35 |         $this->formTransformer = $formTransformer;
 36 |         $this->submissionTransformer = $submissionTransformer;
 37 |         $this->form = $form;
 38 |     }
 39 | 
 40 |     public function index(FormModel $form)
 41 |     {
 42 |         $submissions = $this->submissionTransformer->transformCollection($form->submissions()->orderBy('id', 'DESC')->get());
 43 |         $data = ['form' => $this->formTransformer->transformItem($form), 'submissions' => $submissions];
 44 | 
 45 |         return response($data);
 46 |     }
 47 | 
 48 |     public function create(Request $request, FormModel $form)
 49 |     {
 50 |         request()->query->add(['include' => 'questions']);
 51 | 
 52 |         $form = $this->formTransformer->transformItem($form);
 53 | 
 54 |         if (request()->wantsJson()) {
 55 |             return response($form);
 56 |         }
 57 | 
 58 |         $googleRecaptchaEnabled = $this->form->googleRecaptchaEnabled();
 59 | 
 60 |         return view('laravel-forms::submissions.edit', compact('form', 'googleRecaptchaEnabled'));
 61 |     }
 62 | 
 63 |     public function store(CreateFormSubmissionRequest $request, FormModel $form)
 64 |     {
 65 |         $data = $request->except([
 66 |           'g-recaptcha-response',
 67 |           '_token'
 68 |         ]);
 69 | 
 70 |         $submission = $form->addSubmission($data);
 71 |         $answers = [];
 72 | 
 73 |         foreach ($data as $key => $value) {
 74 |             // if ($value) {
 75 |             $questionId = str_replace('field_', '', $key);
 76 |             $answers[$questionId]['question_id'] = $questionId;
 77 |             $answers[$questionId]['value'] = $value;
 78 |             $answers[$questionId]['submission_id'] = $submission->id;
 79 |             // }
 80 |         }
 81 | 
 82 |         $submission->answers()->insert($answers);
 83 | 
 84 |         // Do this in an event listener
 85 |         $submission->is_complete = true;
 86 |         $submission->save();
 87 | 
 88 |         $this->flashSuccess('Your submission was stored');
 89 | 
 90 |         return back();
 91 |     }
 92 | 
 93 |     public function show(FormModel $form, Submission $submission)
 94 |     {
 95 |         request()->query->add(['include' => 'answers']);
 96 | 
 97 |         return response($this->submissionTransformer->transformItem($submission));
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/database/migrations/create_form_tables.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateFormTables extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('mc_forms', function (Blueprint $table) {
17 |             $table->increments('id');
18 |             $table->string('title');
19 |             $table->string('description')->nullable();
20 |             $table->unsignedInteger('status')->default(0);
21 |             $table->boolean('enable_captcha')->default(true);
22 |             $table->timestamps();
23 |         });
24 | 
25 |         Schema::create('mc_questions', function (Blueprint $table) {
26 |             $table->increments('id');
27 |             $table->unsignedInteger('form_id');
28 |             $table->string('label')->nullable();
29 |             $table->string('placeholder')->nullable();
30 |             $table->string('help_text')->nullable();
31 |             $table->boolean('is_required')->default(true);
32 |             $table->text('description')->nullable();
33 |             $table->text('field_type');
34 |             $table->text('validations')->nullable();
35 |             $table->json('properties')->nullable();
36 |             $table->json('options')->default();
37 |             $table->text('default_value')->nullable();
38 |             $table->unsignedInteger('columns')->default(12);
39 |             $table->unsignedInteger('position')->nullable();
40 |             $table->timestamps();
41 | 
42 |             $table->foreign('form_id')
43 |                 ->references('id')
44 |                 ->on('mc_forms')
45 |                 ->onDelete('cascade');
46 |         });
47 | 
48 |         Schema::create('mc_answers', function (Blueprint $table) {
49 |             $table->increments('id');
50 |             $table->unsignedInteger('question_id');
51 |             $table->unsignedInteger('submission_id');
52 |             $table->text('value');
53 |             $table->timestamps();
54 | 
55 |             $table->foreign('question_id')
56 |                 ->references('id')
57 |                 ->on('mc_questions')
58 |                 ->onDelete('cascade');
59 | 
60 |             $table->foreign('submission_id')
61 |                 ->references('id')
62 |                 ->on('mc_submissions')
63 |                 ->onDelete('cascade');
64 |         });
65 | 
66 |         Schema::create('mc_submissions', function (Blueprint $table) {
67 |             $table->increments('id');
68 |             $table->unsignedInteger('form_id');
69 |             $table->unsignedInteger('user_id')->nullable();
70 |             $table->json('ip_address')->nullable();
71 |             $table->json('response')->nullable();
72 |             $table->boolean('is_complete')->default(false);
73 |             $table->timestamps();
74 | 
75 |             $table->foreign('form_id')
76 |                 ->references('id')
77 |                 ->on('mc_forms')
78 |                 ->onDelete('cascade');
79 |         });
80 |     }
81 | 
82 |     /**
83 |      * Reverse the migrations.
84 |      *
85 |      * @return void
86 |      */
87 |     public function down()
88 |     {
89 |         Schema::dropIfExists('mc_forms');
90 |         Schema::dropIfExists('mc_questions');
91 |         Schema::dropIfExists('mc_answers');
92 |         Schema::dropIfExists('mc_submissions');
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Http/Controllers/FormFieldController.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\Form\Http\Controllers;
  4 | 
  5 | use Illuminate\Http\Request;
  6 | use Musonza\Form\Http\Requests\CreateFormQuestionRequest;
  7 | use Musonza\Form\Http\Requests\UpdateFormQuestionRequest;
  8 | use Musonza\Form\Models\Form as FormModel;
  9 | use Musonza\Form\Models\Question;
 10 | use Musonza\Form\Transformers\FieldTransformer;
 11 | use Musonza\Form\Transformers\FieldTypeTransformer;
 12 | 
 13 | class FormFieldController extends Controller
 14 | {
 15 |     /**
 16 |      * @var FieldTypeTransformer
 17 |      */
 18 |     private $fieldTypeTransformer;
 19 | 
 20 |     /**
 21 |      * @var FieldTransformer
 22 |      */
 23 |     private $fieldTransformer;
 24 | 
 25 |     public function __construct(FieldTransformer $fieldTransformer, FieldTypeTransformer $fieldTypeTransformer)
 26 |     {
 27 |         $this->fieldTransformer = $fieldTransformer;
 28 |         $this->fieldTypeTransformer = $fieldTypeTransformer;
 29 |     }
 30 | 
 31 |     public function index(FormModel $form)
 32 |     {
 33 |         $fields = $form->questions()->orderBy('position')->get();
 34 | 
 35 |         $fields = $this->fieldTransformer->transformCollection($fields);
 36 | 
 37 |         return response($fields);
 38 |     }
 39 | 
 40 |     public function create(FormModel $form)
 41 |     {
 42 |         $fieldTypes = $this->fieldTypes();
 43 | 
 44 |         $field = [];
 45 | 
 46 |         return view('laravel-forms::forms.fields.create', compact('form', 'fieldTypes', 'field'));
 47 |     }
 48 | 
 49 |     public function show(FormModel $form, Question $field)
 50 |     {
 51 |         return response($field);
 52 |     }
 53 | 
 54 |     public function store(CreateFormQuestionRequest $request, FormModel $form)
 55 |     {
 56 |         $data = $request->all();
 57 |         $data['options'] = [];
 58 | 
 59 |         if ($request->options) {
 60 |             $options = $this->normalizeOptions($request->options);
 61 |             $data['options'] = $options;
 62 |         }
 63 | 
 64 |         $field = $form->questions()->create($data);
 65 |         return response($field);
 66 |     }
 67 | 
 68 |     public function destroy(Request $request, FormModel $form, Question $field)
 69 |     {
 70 |         $field->delete();
 71 |         return response('', 201);
 72 |     }
 73 | 
 74 |     public function edit(FormModel $form, Question $field)
 75 |     {
 76 |         $field = $this->fieldTransformer->transformItem($field);
 77 |         $fieldTypes = $this->fieldTypes();
 78 |         return view('laravel-forms::forms.fields.edit', compact('form', 'field', 'fieldTypes'));
 79 |     }
 80 | 
 81 |     public function update(UpdateFormQuestionRequest $request, FormModel $form, Question $field)
 82 |     {
 83 |         $data = $request->validated();
 84 |         $data['options'] = [];
 85 | 
 86 |         if ($request->options) {
 87 |             $options = $this->normalizeOptions($request->options);
 88 |             $data['options'] = $options;
 89 |         }
 90 | 
 91 |         if ($request->position && $request->position != $field->position) {
 92 |             $field->insertAt($request->position);
 93 |         }
 94 | 
 95 |         $field->update($data);
 96 | 
 97 |         return response($this->fieldTransformer->transformItem($field));
 98 |     }
 99 | 
100 |     protected function normalizeOptions($options)
101 |     {
102 |         $options = array_unique($options);
103 |         return array_values($options);
104 |     }
105 | 
106 |     protected function fieldTypes($value = '')
107 |     {
108 |         return $this->fieldTypeTransformer->transformCollection(config('laravel_forms.fields'));
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/resources/js/components/FormSubmissionsComponent.vue:
--------------------------------------------------------------------------------
  1 | <script>
  2 |     import Form from '@/models/Form';
  3 |     import Submission from '@/models/Submission';
  4 |     import { EventBus } from '../event-bus.js';
  5 |     export default {
  6 |       name: 'FormSubmissionsComponent',
  7 | 
  8 |       data: () => ({
  9 |         form: null,
 10 |         formSubmissions: [],
 11 |         formId: null,
 12 |         currentSubmission: {},
 13 |         headers: [
 14 |           { text: 'ID', value: 'id' },
 15 |           { text: 'Created', value: 'created_at_readable' },
 16 |           { text: 'Status', value: 'is_complete' },
 17 |         ],
 18 |       }),
 19 | 
 20 |       methods: {
 21 | 
 22 |         async getFormSubmissions() {
 23 |           let form = new Form({id: this.formId});
 24 |           let response = await form.submissions().get();
 25 |           this.formSubmissions = response[0].submissions.data;
 26 |         },
 27 | 
 28 |         // store in vuex for current session
 29 |         async getSubmission(props) {
 30 |           props.expanded = !props.expanded;
 31 |           this.form = new Form({id: this.formId});
 32 |           this.currentSubmission = await this.form.submissions().find(props.item.id);
 33 |         },
 34 | 
 35 |         async deleteSubmission() {
 36 |           const confirmation = this.getConfirmationMessages().delete_submission;
 37 |           this.alertConfirm(confirmation.message, async() => {
 38 |             this.currentSubmission.delete()
 39 |             .then(response => {
 40 |               this.formSubmissions.splice(this.formSubmissions.indexOf(this.currentSubmission), 1);
 41 |               this.alertWarning('Successfully deleted the submission!');
 42 |               EventBus.$emit('delete_submission');
 43 |             })
 44 |             .catch(error => {
 45 |               this.alertError(this.formatErrorMessage(error.response));
 46 |             });
 47 |           }, null, confirmation.title);
 48 |         },
 49 |       },
 50 | 
 51 |       mounted() {
 52 |         this.formId = this.$route.params.id;
 53 |         this.getFormSubmissions();
 54 |       }
 55 |     }
 56 | </script>
 57 | 
 58 | <template>
 59 |     <v-data-table
 60 |       :headers="headers"
 61 |       :items="formSubmissions"
 62 |       class="elevation-1"
 63 |     >
 64 |       <template slot="items" slot-scope="props">
 65 |         <tr @click="getSubmission(props)">
 66 |           <td>{{ props.item.id }}</td>
 67 |           <td>{{ props.item.created_at_readable }}</td>
 68 |           <td>
 69 |             <v-chip
 70 |             label
 71 |             small
 72 |             :color="(props.item.is_complete) ? 'success' : 'warning'"
 73 |             text-color="white"
 74 |             class="status-label font-weight-bold ml-0">
 75 |               <span v-if="props.item.is_complete">Complete</span>
 76 |               <span v-else>In Progress</span>
 77 |             </v-chip>
 78 |           </td>
 79 |         </tr>
 80 |       </template>
 81 |       <template slot="expand" slot-scope="props">
 82 |         <v-card
 83 |           flat
 84 |           v-if="currentSubmission && currentSubmission.answers"
 85 |           class="pa-3"
 86 |         >
 87 |           <div class="right">
 88 |             <v-card-actions>
 89 |               <v-tooltip bottom>
 90 |                 <a slot="activator" @click="deleteSubmission()">
 91 |                   <v-icon>delete</v-icon>
 92 |                 </a>
 93 |                 <span>Delete submission</span>
 94 |               </v-tooltip>
 95 | 
 96 |             </v-card-actions>
 97 |           </div>
 98 |           <div
 99 |             v-for="(answer, i) in currentSubmission.answers.data"
100 |             :key="i"
101 |             class="pa-2"
102 |             >
103 |               <h3>{{ answer.question.label }}</h3>
104 |               <span>{{ answer.response }}</span>
105 |           </div>
106 |         </v-card>
107 |     </template>
108 |     </v-data-table>
109 | </template>
110 | 


--------------------------------------------------------------------------------
/resources/js/pages/forms/edit.vue:
--------------------------------------------------------------------------------
  1 | <script>
  2 | import Form from "@/models/Form";
  3 | import FormActionsComponent from "@/components/FormActionsComponent";
  4 | import FormFieldsComponent from "@/components/FormFieldsComponent";
  5 | import FormSubmissionsComponent from "@/components/FormSubmissionsComponent";
  6 | import { EventBus } from "../../event-bus.js";
  7 | export default {
  8 |   name: "FormEditPage",
  9 |   $_veeValidate: {
 10 |     validator: "new"
 11 |   },
 12 | 
 13 |   components: {
 14 |     FormActionsComponent,
 15 |     FormFieldsComponent,
 16 |     FormSubmissionsComponent
 17 |   },
 18 | 
 19 |   data: () => ({
 20 |     payload: {
 21 |       title: "",
 22 |       description: "",
 23 |       status: null
 24 |     },
 25 |     formModel: {
 26 |       submissions_count: 0
 27 |     },
 28 |     creatingForm: true,
 29 |     panel: [true]
 30 |   }),
 31 |   methods: {
 32 |     async getForm(id) {
 33 |       this.formModel = await Form.find(id);
 34 |       this.payload = {
 35 |         title: this.formModel.title,
 36 |         description: this.formModel.description,
 37 |         status: parseInt(this.formModel.status.value)
 38 |       };
 39 |     },
 40 | 
 41 |     async submit() {
 42 |       let valid = await this.$validator.validateAll();
 43 |       if (valid) {
 44 |         this.formModel.id ? this.updateForm() : this.createForm();
 45 |       }
 46 |     },
 47 | 
 48 |     async createForm() {
 49 |       this.payload.status = 0;
 50 |       let form = new Form(this.payload);
 51 |       form
 52 |         .save()
 53 |         .then(response => {
 54 |           this.alertSuccess("Successfully created!");
 55 |           this.$router.push({
 56 |             name: "forms-edit",
 57 |             params: { id: response.id }
 58 |           });
 59 |           this.$router.go();
 60 |         })
 61 |         .catch(error => {
 62 |           this.alertError(this.formatErrorMessage(error.response));
 63 |         });
 64 |     },
 65 | 
 66 |     async updateForm() {
 67 |       await this.formModel
 68 |         .sync(this.payload)
 69 |         .then(response => {
 70 |           this.alertSuccess("Successfully saved!");
 71 |         })
 72 |         .catch(error => {
 73 |           this.alertError(this.formatErrorMessage(error.response));
 74 |         });
 75 |     },
 76 | 
 77 |     clear() {
 78 |       this.title = "";
 79 |       this.description = "";
 80 |       this.status = null;
 81 |       this.$validator.reset();
 82 |     },
 83 | 
 84 |     cancel() {
 85 |       this.$router.go(-1);
 86 |     }
 87 |   },
 88 | 
 89 |   created() {
 90 |     EventBus.$on("delete_submission", () => {
 91 |       this.formModel.submissions_count--;
 92 |     });
 93 |   },
 94 |   created() {
 95 |     EventBus.$on("delete_submission", () => {
 96 |       this.formModel.submissions_count--;
 97 |     });
 98 |   },
 99 | 
100 |   mounted() {
101 |     const id = this.$route.params.id;
102 |     if (id && id != 0) {
103 |       this.creatingForm = false;
104 |       this.getForm(id);
105 |     }
106 |   }
107 | };
108 | </script>
109 | 
110 | <template>
111 |   <div>
112 |     <h2 class="primary--text mb-1" v-if="formModel.id">Form #{{ formModel.id }}</h2>
113 |     <h2 class="primary--text mb-1" v-else>New Form</h2>
114 |     <v-tabs fixed-tabs>
115 |       <v-tab>Fields</v-tab>
116 |       <v-tab>
117 |         <span class="mr-2">Submissions</span>
118 |         <v-badge right>
119 |           <span slot="badge">{{ formModel.submissions_count }}</span>
120 |         </v-badge>
121 |       </v-tab>
122 |       <!-- <v-tab>Settings</v-tab> -->
123 |       <v-tabs-items>
124 |         <v-tab-item>
125 |           <v-expansion-panel v-model="panel" expand>
126 |             <v-expansion-panel-content>
127 |               <div slot="header">
128 |                 <h2 class="primary--text mb-1" v-if="formModel.id">Details</h2>
129 |               </div>
130 |               <v-card class="pl-2 pr-2 pt-2 pb-2">
131 |                 <form>
132 |                   <v-text-field
133 |                     outline
134 |                     v-validate="'required'"
135 |                     v-model="payload.title"
136 |                     :error-messages="errors.collect('title')"
137 |                     label="Title"
138 |                     data-vv-name="title"
139 |                     required
140 |                   ></v-text-field>
141 | 
142 |                   <v-textarea
143 |                     outline
144 |                     v-model="payload.description"
145 |                     name="description"
146 |                     label="Description"
147 |                   ></v-textarea>
148 | 
149 |                   <v-radio-group v-model="payload.status">
150 |                     <v-radio
151 |                       v-for="(status, index) in formModel.statuses"
152 |                       :key="index"
153 |                       :label="`${status.label}`"
154 |                       :value="index"
155 |                     ></v-radio>
156 |                   </v-radio-group>
157 | 
158 |                   <v-btn @click="submit" color="primary">save</v-btn>
159 |                   <v-btn @click="cancel">cancel</v-btn>
160 |                   <!-- <v-btn @click="clear">clear</v-btn> -->
161 |                 </form>
162 |               </v-card>
163 |             </v-expansion-panel-content>
164 |           </v-expansion-panel>
165 |           <form-fields-component :form-model="formModel" v-if="!creatingForm"></form-fields-component>
166 |         </v-tab-item>
167 |         <v-tab-item v-if="formModel.id">
168 |           <form-submissions-component></form-submissions-component>
169 |         </v-tab-item>
170 |         <!-- <v-tab-item v-if="formModel.id">Settings here...</v-tab-item> -->
171 |       </v-tabs-items>
172 |     </v-tabs>
173 |   </div>
174 | </template>
175 | 


--------------------------------------------------------------------------------
/resources/js/components/FormFieldsComponent.vue:
--------------------------------------------------------------------------------
  1 | <script>
  2 | import Form from "@/models/Form";
  3 | import Sortable from "sortablejs";
  4 | 
  5 | export default {
  6 |   name: "FormFieldsComponent",
  7 | 
  8 |   data: () => ({
  9 |     formFields: null,
 10 |     items: []
 11 |   }),
 12 | 
 13 |   props: ["formModel"],
 14 | 
 15 |   methods: {
 16 |     remove(item, field) {
 17 |       field.options.splice(field.options.indexOf(item), 1);
 18 |       field.options = [...field.options];
 19 |     },
 20 | 
 21 |     addField() {
 22 |       this.$router.push({
 23 |         name: "formFieldCreate",
 24 |         params: { id: this.$route.params.id }
 25 |       });
 26 |     },
 27 | 
 28 |     async updateField(field) {
 29 |       field
 30 |         .save()
 31 |         .then(response => {
 32 |           field = response;
 33 |           this.alertSuccess("Successfully updated the field!");
 34 |         })
 35 |         .catch(error => {
 36 |           this.alertError(this.formatErrorMessage(error.response));
 37 |         });
 38 |     },
 39 | 
 40 |     async getFormFields() {
 41 |       this.formFields = await new Form({ id: this.formId }).fields().$get();
 42 |     },
 43 | 
 44 |     async deleteField(field) {
 45 |       const confirmation = this.getConfirmationMessages().delete_field;
 46 |       this.alertConfirm(
 47 |         confirmation.message,
 48 |         async () => {
 49 |           field
 50 |             .delete()
 51 |             .then(response => {
 52 |               this.formFields.splice(this.formFields.indexOf(field), 1);
 53 |               this.alertWarning("Successfully deleted the field!");
 54 |             })
 55 |             .catch(error => {
 56 |               this.alertError(this.formatErrorMessage(error.response));
 57 |             });
 58 |         },
 59 |         null,
 60 |         confirmation.title
 61 |       );
 62 |     },
 63 | 
 64 |     //Move this to vuex state
 65 |     getItems() {
 66 |       return [
 67 |         "Musonza\\Form\\Fields\\CheckBox",
 68 |         "Musonza\\Form\\Fields\\Date",
 69 |         "Musonza\\Form\\Fields\\File",
 70 |         "Musonza\\Form\\Fields\\Password",
 71 |         "Musonza\\Form\\Fields\\Radio",
 72 |         "Musonza\\Form\\Fields\\Select",
 73 |         "Musonza\\Form\\Fields\\Text",
 74 |         "Musonza\\Form\\Fields\\TextArea",
 75 |         "Musonza\\Form\\Fields\\Email",
 76 |         "Musonza\\Form\\Fields\\Number"
 77 |       ];
 78 |     }
 79 |   },
 80 | 
 81 |   mounted() {
 82 |     this.formId = this.$route.params.id;
 83 |     this.getFormFields();
 84 |     let fieldsList = document.querySelector("#form-fields-list");
 85 |     const _self = this;
 86 |     Sortable.create(fieldsList, {
 87 |       ghostClass: "sortable-ghost",
 88 |       sort: true,
 89 |       handle: ".sorting-handle",
 90 |       onEnd({ newIndex, oldIndex }) {
 91 |         if (newIndex == oldIndex) {
 92 |           return;
 93 |         }
 94 |         const fieldSelected = _self.formFields.splice(oldIndex, 1)[0];
 95 |         _self.formFields.splice(newIndex, 0, fieldSelected);
 96 |         fieldSelected.position = fieldSelected.position + (newIndex - oldIndex);
 97 |         fieldSelected.save().then(resp => {
 98 |           // _self.$router.go();
 99 |           // _self.$forceUpdate();
100 |           _self.$router.go();
101 |         });
102 |       }
103 |     });
104 |   }
105 | };
106 | </script>
107 | 
108 | <template>
109 |   <div class="mt-3">
110 |     <v-btn color="primary" small @click="addField()" class="right mb-3">Add Field</v-btn>
111 |     <div>
112 |       <h2>Fields</h2>
113 | 
114 |       <v-expansion-panel popout id="form-fields-list">
115 |         <v-expansion-panel-content
116 |           v-for="(field, i) in formFields"
117 |           :key="i"
118 |           class="fields-expansion-panel"
119 |         >
120 |           <div slot="header">
121 |             <div class="left">
122 |               <span class="sorting-handle">:::</span>
123 |               {{ field.label }}
124 |             </div>
125 |           </div>
126 | 
127 |           <v-card class="pl-2 pr-2 pt-2 pb-2">
128 |             <!-- move / refactor this -->
129 |             <div class>
130 |               <v-card-actions>
131 |                 <v-tooltip bottom class="mr-3">
132 |                   <a slot="activator" @click="updateField(field)">
133 |                     <v-icon>save</v-icon>
134 |                   </a>
135 |                   <span>Save</span>
136 |                 </v-tooltip>
137 |               </v-card-actions>
138 |             </div>
139 |             <v-text-field
140 |               outline
141 |               v-model="field.label"
142 |               label="Label"
143 |               data-vv-name="label"
144 |               @change="updateField(field)"
145 |             ></v-text-field>
146 | 
147 |             <v-select
148 |               :items="getItems()"
149 |               label="Field Type"
150 |               v-model="field.field_type"
151 |               outline
152 |               @change="updateField(field)"
153 |             ></v-select>
154 | 
155 |             <!-- Choices -->
156 |             <div v-if="field.has_choices">
157 |               <template>
158 |                 <v-combobox
159 |                   v-model="field.options"
160 |                   :items="items"
161 |                   label="Choices"
162 |                   chips
163 |                   clearable
164 |                   solo
165 |                   multiple
166 |                 >
167 |                   <template slot="selection" slot-scope="data">
168 |                     <v-chip :selected="data.selected" close @input="remove(data.item, field)">
169 |                       <strong>{{ data.item }}</strong>&nbsp;
170 |                     </v-chip>
171 |                   </template>
172 |                 </v-combobox>
173 |               </template>
174 |             </div>
175 |             <!-- Choices -->
176 |             <v-card-actions>
177 |               <v-tooltip bottom class="mr-3">
178 |                 <a slot="activator">
179 |                   <v-icon>file_copy</v-icon>
180 |                 </a>
181 |                 <span>Duplicate</span>
182 |               </v-tooltip>
183 | 
184 |               <v-tooltip bottom>
185 |                 <a slot="activator" @click="deleteField(field)">
186 |                   <v-icon>delete</v-icon>
187 |                 </a>
188 |                 <span>Delete</span>
189 |               </v-tooltip>
190 | 
191 |               <v-divider class="mx-3" inset vertical></v-divider>
192 | 
193 |               <v-switch label="Required" v-model="field.is_required" @change="updateField(field)"></v-switch>
194 |             </v-card-actions>
195 |           </v-card>
196 |         </v-expansion-panel-content>
197 |       </v-expansion-panel>
198 |     </div>
199 |   </div>
200 | </template>
201 | 
202 | <style>
203 | .sorting-handle {
204 |   max-width: 30px;
205 |   cursor: move !important;
206 |   cursor: -webkit-grabbing !important;
207 |   font-weight: bolder;
208 | }
209 | .sortable-ghost {
210 |   border: thick solid #3477cb;
211 | }
212 | </style>
213 | 
214 | 


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