├── .editorconfig
├── .gitignore
├── LICENSE
├── README.md
├── composer.json
├── config
    └── domain_verifier.php
├── database
    └── migrations
    │   └── 2019_08_01_000001_create_domain_verifications_table.php
├── phpcs.xml
├── phpunit.xml
├── resources
    └── views
    │   ├── mail.blade.php
    │   ├── verification_failed.blade.php
    │   └── verification_succeeded.blade.php
├── src
    ├── Contracts
    │   ├── Models
    │   │   └── DomainVerifiable.php
    │   ├── Repositories
    │   │   └── VerificationRepository.php
    │   └── Strategies
    │   │   └── VerifierStrategy.php
    ├── DomainVerificationFacade.php
    ├── DomainVerifierServiceProvider.php
    ├── Enums
    │   └── VerifierStrategy.php
    ├── Factories
    │   └── VerifierFactory.php
    ├── Http
    │   ├── Controller
    │   │   └── DomainVerifierController.php
    │   └── routes.php
    ├── Mail
    │   └── ActivationMail.php
    ├── Models
    │   └── DomainVerification.php
    ├── Repositories
    │   └── DomainVerification.php
    ├── Results
    │   └── VerifyResult.php
    ├── Strategies
    │   ├── BaseStrategy.php
    │   ├── DNSRecord.php
    │   ├── HTMLFile.php
    │   ├── HTMLMeta.php
    │   └── SendingMail.php
    ├── Supports
    │   └── URL.php
    ├── Traits
    │   └── DomainVerifiable.php
    └── VerifierFactoryFacade.php
└── tests
    ├── .gitkeep
    ├── Strategies
        ├── DNSRecordTest.php
        ├── HTMLFileTest.php
        ├── HTMLMetaTest.php
        └── StrategyTestCase.php
    ├── Supports
        └── URLTest.php
    └── TestCase.php


/.editorconfig:
--------------------------------------------------------------------------------
 1 | # editorconfig.org
 2 | root = true
 3 | 
 4 | [*]
 5 | indent_style = space
 6 | indent_size = 4
 7 | end_of_line = lf
 8 | charset = utf-8
 9 | trim_trailing_whitespace = true
10 | insert_final_newline = true
11 | 
12 | [*.md]
13 | trim_trailing_whitespace = false
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Dependencies:
 2 | /vendor
 3 | composer.phar
 4 | composer.lock
 5 | 
 6 | # IDE/editors:
 7 | .idea
 8 | .vscode
 9 | .phpunit.result.cache
10 | 
11 | # OS:
12 | .DS_Store
13 | Thumbs.db
14 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Sun* Research
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # sun-asterisk/laravel-domain-verify
 2 | 
 3 | Verify domain ownership for the Laravel application. We provide three ways to verify the domain ownership (like Google):
 4 | 
 5 | - [x] Via domain's DNS record
 6 | - [x] Via HTML tag
 7 | - [x] Via HTML file
 8 | - [x] Via Adminstrator's email address: `admin@domain.example`, `webmaster@domain.example`.
 9 | 
10 | ## Installation
11 | 
12 | First, install Domain Verifier via the Composer package manager:
13 | 
14 | ```bash
15 | # install this package:
16 | composer require sun-asterisk/laravel-domain-verify
17 | 
18 | # create config/domain_verifier.php and:
19 | php artisan vendor:publish --provider="SunAsterisk\DomainVerifier\DomainVerifierServiceProvider"
20 | 
21 | # migrate database:
22 | php artisan migrate
23 | ```
24 | 
25 | ## Usage
26 | 
27 | Integrate with your model.
28 | 
29 | ```php
30 | <?php
31 | 
32 | namespace App\Models;
33 | 
34 | // ...
35 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
36 | use SunAsterisk\DomainVerifier\Traits\DomainVerifiable as DomainVerifiableTrait;
37 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
38 | 
39 | class Website extends Model implements DomainVerifiable
40 | {
41 |     use DomainVerifiableTrait;
42 | 
43 |     //..
44 | }
45 | ```
46 | 
47 | ## Requirements
48 | 
49 | - Laravel `>= 5.6.0`
50 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "sun-asterisk/laravel-domain-verify",
 3 |     "description": "Verify domain ownership for Laravel application",
 4 |     "type": "library",
 5 |     "license": "MIT",
 6 |     "require": {
 7 |         "php": "^7.4|^8.0",
 8 |         "illuminate/config": "~5.0|~5.7.0|~5.8.0|^6.0|^7.0|^8.0|^9.0",
 9 |         "illuminate/database": "~5.0|~5.7.0|~5.8.0|^6.0|^7.0|^8.0|^9.0",
10 |         "illuminate/hashing": "~5.0|~5.7.0|~5.8.0|^6.0|^7.0|^8.0|^9.0",
11 |         "illuminate/support": "~5.0|~5.7.0|~5.8.0|^6.0|^7.0|^8.0|^9.0",
12 |         "nesbot/carbon": "~1.0|~2.0",
13 |         "spatie/dns": "^2.5"
14 |     },
15 |     "require-dev": {
16 |         "mockery/mockery": "^1.2",
17 |         "orchestra/testbench": "^5.3",
18 |         "phpunit/phpunit": "^7.5|^8.0",
19 |         "sun-asterisk/coding-standard": "^0.2.1"
20 |     },
21 |     "autoload": {
22 |         "psr-4": {
23 |             "SunAsterisk\\DomainVerifier\\": "src/"
24 |         }
25 |     },
26 |     "autoload-dev": {
27 |         "psr-4": {
28 |             "SunAsterisk\\DomainVerifier\\Tests\\": "tests/"
29 |         }
30 |     },
31 |     "config": {
32 |         "sort-packages": true,
33 |         "allow-plugins": {
34 |             "dealerdirect/phpcodesniffer-composer-installer": true
35 |         }
36 |     },
37 |     "prefer-stable": true,
38 |     "extra": {
39 |         "laravel": {
40 |             "providers": [
41 |                 "SunAsterisk\\DomainVerifier\\DomainVerifierServiceProvider"
42 |             ],
43 |             "aliases": {
44 |                 "DomainVerification": "SunAsterisk\\DomainVerifier\\DomainVerificationFacade",
45 |                 "VerifierFactory": "SunAsterisk\\DomainVerifier\\VerifierFactoryFacade"
46 |             }
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/config/domain_verifier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 |     'verification_name' => env('DOMAIN_VERIFICATION_NAME', 'domain-verification'),
 5 |     'base_url' => env('DOMAIN_VERIFICATION_BASE_URL', 'http://localhost'),
 6 | 
 7 |     'mail' => [
 8 |         'from' => env('DOMAIN_VERIFY_MAIL_FROM', 'noreply@example.localhost'),
 9 |         'subject' => env('DOMAIN_VERIFY_MAIL_SUBJECT', 'Domain Verification'),
10 |         'view' => env('DOMAIN_VERIFY_MAIL_VIEW', 'laravel-domain-verify::mail'),
11 |     ],
12 | 
13 |     'page' => [
14 |         'verification_succeeded' => env(
15 |             'DOMAIN_VERIFY_VERIFICATION_SUCCEEDED_VIEW',
16 |             'laravel-domain-verify::verification_succeeded'
17 |         ),
18 |         'verification_failed' => env(
19 |             'DOMAIN_VERIFY_VERIFICATION_FAILED_VIEW',
20 |             'laravel-domain-verify::verification_failed'
21 |         ),
22 |     ],
23 | ];
24 | 


--------------------------------------------------------------------------------
/database/migrations/2019_08_01_000001_create_domain_verifications_table.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 CreateDomainVerificationsTable extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('domain_verifications', function (Blueprint $table) {
17 |             $table->increments('id');
18 |             $table->string('verifiable_type')->index();
19 |             $table->integer('verifiable_id')->index();
20 |             $table->string('url')->index();
21 |             $table->string('token')->index();
22 |             $table->string('activation_token')->index();
23 |             $table->enum('status', ['pending', 'verified'])->default('pending')->index();
24 |             $table->timestamp('email_sent_at')->nullable();
25 |             $table->timestamp('verified_at')->nullable();
26 |             $table->timestamps();
27 |         });
28 |     }
29 | 
30 |     /**
31 |      * Reverse the migrations.
32 |      *
33 |      * @return void
34 |      */
35 |     public function down()
36 |     {
37 |         Schema::dropIfExists('domain_verifications');
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/phpcs.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <ruleset name="LaravelDomainVerifier" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 3 |     <file>app</file>
 4 |     <file>config</file>
 5 |     <file>database</file>
 6 |     <file>resources</file>
 7 |     <file>routes</file>
 8 |     <file>tests</file>
 9 | 
10 |     <exclude-pattern>vendor/</exclude-pattern>
11 | 
12 |     <rule ref="SunAsteriskLaravel"/>
13 | 
14 |     <rule ref="SlevomatCodingStandard.Commenting.InlineDocCommentDeclaration.MissingVariable">
15 |         <exclude-pattern>database/factories</exclude-pattern>
16 |     </rule>
17 | </ruleset>
18 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 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="Domain Verifier Test Suite">
14 |             <directory suffix="Test.php">./tests</directory>
15 |         </testsuite>
16 |     </testsuites>
17 |     <filter>
18 |         <whitelist processUncoveredFilesFromWhitelist="true">
19 |             <directory suffix=".php">./src</directory>
20 |         </whitelist>
21 |     </filter>
22 |     <php>
23 |         <env name="DB_CONNECTION" value="testing"/>
24 |     </php>
25 | </phpunit>
26 | 


--------------------------------------------------------------------------------
/resources/views/mail.blade.php:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 |     <head>
 4 |         <meta charset="utf-8">
 5 |     </head>
 6 |     <body>
 7 |         Open the link below to confirm your ownership on domain {{ $domainName }}.
 8 |         <br>
 9 |         <a href="{{ $activationUrl }}">{{ $activationUrl }}</a>
10 |     </body>
11 | </html>
12 | 


--------------------------------------------------------------------------------
/resources/views/verification_failed.blade.php:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |     <head>
  4 |         <meta charset="utf-8">
  5 |         <title>Verification failed!</title>
  6 |         <style>
  7 |         /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
  8 | 
  9 |         html {
 10 |             line-height: 1.15; /* 1 */
 11 |             -webkit-text-size-adjust: 100%; /* 2 */
 12 |         }
 13 | 
 14 |         body {
 15 |             margin: 0;
 16 |         }
 17 | 
 18 |         main {
 19 |             display: block;
 20 |         }
 21 | 
 22 |         h3 {
 23 |             margin: 0;
 24 |         }
 25 | 
 26 |         html {
 27 |             font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; /* 1 */
 28 |             line-height: 1.5; /* 2 */
 29 |         }
 30 | 
 31 |         *,
 32 |         ::before,
 33 |         ::after {
 34 |             box-sizing: border-box; /* 1 */
 35 |             border-width: 0; /* 2 */
 36 |             border-style: solid; /* 2 */
 37 |             border-color: #e2e8f0; /* 2 */
 38 |         }
 39 | 
 40 |         h3 {
 41 |             font-size: inherit;
 42 |             font-weight: inherit;
 43 |         }
 44 | 
 45 |         .bg-white {
 46 |             --bg-opacity: 1;
 47 |             background-color: #fff;
 48 |             background-color: rgba(255, 255, 255, var(--bg-opacity));
 49 |         }
 50 | 
 51 |         .bg-gray-300 {
 52 |             --bg-opacity: 1;
 53 |             background-color: #e2e8f0;
 54 |             background-color: rgba(226, 232, 240, var(--bg-opacity));
 55 |         }
 56 | 
 57 |         .rounded {
 58 |             border-radius: 0.25rem;
 59 |         }
 60 | 
 61 |         .flex {
 62 |             display: flex;
 63 |         }
 64 | 
 65 |         .items-center {
 66 |             align-items: center;
 67 |         }
 68 | 
 69 |         .justify-center {
 70 |             justify-content: center;
 71 |         }
 72 | 
 73 |         .font-bold {
 74 |             font-weight: 700;
 75 |         }
 76 | 
 77 |         .h-screen {
 78 |             height: 100vh;
 79 |         }
 80 | 
 81 |         .m-2 {
 82 |             margin: 0.5rem;
 83 |         }
 84 | 
 85 |         .max-w-screen-xl {
 86 |             max-width: 1280px;
 87 |         }
 88 | 
 89 |         .p-6 {
 90 |             padding: 1.5rem;
 91 |         }
 92 | 
 93 |         .shadow {
 94 |             box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06);
 95 |         }
 96 | 
 97 |         .text-red-800 {
 98 |             --text-opacity: 1;
 99 |             color: #9b2c2c;
100 |             color: rgba(155, 44, 44, var(--text-opacity));
101 |         }
102 | 
103 |         .text-green-800 {
104 |             --text-opacity: 1;
105 |             color: #276749;
106 |             color: rgba(39, 103, 73, var(--text-opacity));
107 |         }
108 | 
109 |         .w-screen {
110 |             width: 100vw;
111 |         }
112 | 
113 |         @keyframes spin {
114 |             from {
115 |                 transform: rotate(0deg);
116 |             }
117 | 
118 |             to {
119 |                 transform: rotate(360deg);
120 |             }
121 |         }
122 | 
123 |         @keyframes ping {
124 |             0% {
125 |                 transform: scale(1);
126 |                 opacity: 1;
127 |             }
128 | 
129 |             75%, 100% {
130 |                 transform: scale(2);
131 |                 opacity: 0;
132 |             }
133 |         }
134 | 
135 |         @keyframes pulse {
136 |             0%, 100% {
137 |                 opacity: 1;
138 |             }
139 | 
140 |             50% {
141 |                 opacity: .5;
142 |             }
143 |         }
144 | 
145 |         @keyframes bounce {
146 |             0%, 100% {
147 |                 transform: translateY(-25%);
148 |                 animation-timing-function: cubic-bezier(0.8,0,1,1);
149 |             }
150 | 
151 |             50% {
152 |                 transform: translateY(0);
153 |                 animation-timing-function: cubic-bezier(0,0,0.2,1);
154 |             }
155 |         }
156 |         </style>
157 |     </head>
158 |     <body class="bg-gray-300 flex items-center justify-center w-screen h-screen">
159 |         <main class="bg-white rounded max-w-screen-xl shadow m-2">
160 |             <h3 class="font-bold text-red-800 p-6">Verification failed because invalid or expired activation token.</h3>
161 |         </main>
162 |     </body>
163 | </html>
164 | 


--------------------------------------------------------------------------------
/resources/views/verification_succeeded.blade.php:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html>
  3 |     <head>
  4 |         <meta charset="utf-8">
  5 |         <title>Verification succeeded!</title>
  6 |         <style>
  7 |         /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */
  8 | 
  9 |         html {
 10 |             line-height: 1.15; /* 1 */
 11 |             -webkit-text-size-adjust: 100%; /* 2 */
 12 |         }
 13 | 
 14 |         body {
 15 |             margin: 0;
 16 |         }
 17 | 
 18 |         main {
 19 |             display: block;
 20 |         }
 21 | 
 22 |         h3 {
 23 |             margin: 0;
 24 |         }
 25 | 
 26 |         html {
 27 |             font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"; /* 1 */
 28 |             line-height: 1.5; /* 2 */
 29 |         }
 30 | 
 31 |         *,
 32 |         ::before,
 33 |         ::after {
 34 |             box-sizing: border-box; /* 1 */
 35 |             border-width: 0; /* 2 */
 36 |             border-style: solid; /* 2 */
 37 |             border-color: #e2e8f0; /* 2 */
 38 |         }
 39 | 
 40 |         h3 {
 41 |             font-size: inherit;
 42 |             font-weight: inherit;
 43 |         }
 44 | 
 45 |         .bg-white {
 46 |             --bg-opacity: 1;
 47 |             background-color: #fff;
 48 |             background-color: rgba(255, 255, 255, var(--bg-opacity));
 49 |         }
 50 | 
 51 |         .bg-gray-300 {
 52 |             --bg-opacity: 1;
 53 |             background-color: #e2e8f0;
 54 |             background-color: rgba(226, 232, 240, var(--bg-opacity));
 55 |         }
 56 | 
 57 |         .rounded {
 58 |             border-radius: 0.25rem;
 59 |         }
 60 | 
 61 |         .flex {
 62 |             display: flex;
 63 |         }
 64 | 
 65 |         .items-center {
 66 |             align-items: center;
 67 |         }
 68 | 
 69 |         .justify-center {
 70 |             justify-content: center;
 71 |         }
 72 | 
 73 |         .font-bold {
 74 |             font-weight: 700;
 75 |         }
 76 | 
 77 |         .h-screen {
 78 |             height: 100vh;
 79 |         }
 80 | 
 81 |         .m-2 {
 82 |             margin: 0.5rem;
 83 |         }
 84 | 
 85 |         .max-w-screen-xl {
 86 |             max-width: 1280px;
 87 |         }
 88 | 
 89 |         .p-6 {
 90 |             padding: 1.5rem;
 91 |         }
 92 | 
 93 |         .shadow {
 94 |             box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06);
 95 |         }
 96 | 
 97 |         .text-red-800 {
 98 |             --text-opacity: 1;
 99 |             color: #9b2c2c;
100 |             color: rgba(155, 44, 44, var(--text-opacity));
101 |         }
102 | 
103 |         .text-green-800 {
104 |             --text-opacity: 1;
105 |             color: #276749;
106 |             color: rgba(39, 103, 73, var(--text-opacity));
107 |         }
108 | 
109 |         .w-screen {
110 |             width: 100vw;
111 |         }
112 | 
113 |         @keyframes spin {
114 |             from {
115 |                 transform: rotate(0deg);
116 |             }
117 | 
118 |             to {
119 |                 transform: rotate(360deg);
120 |             }
121 |         }
122 | 
123 |         @keyframes ping {
124 |             0% {
125 |                 transform: scale(1);
126 |                 opacity: 1;
127 |             }
128 | 
129 |             75%, 100% {
130 |                 transform: scale(2);
131 |                 opacity: 0;
132 |             }
133 |         }
134 | 
135 |         @keyframes pulse {
136 |             0%, 100% {
137 |                 opacity: 1;
138 |             }
139 | 
140 |             50% {
141 |                 opacity: .5;
142 |             }
143 |         }
144 | 
145 |         @keyframes bounce {
146 |             0%, 100% {
147 |                 transform: translateY(-25%);
148 |                 animation-timing-function: cubic-bezier(0.8,0,1,1);
149 |             }
150 | 
151 |             50% {
152 |                 transform: translateY(0);
153 |                 animation-timing-function: cubic-bezier(0,0,0.2,1);
154 |             }
155 |         }
156 |         </style>
157 |     </head>
158 |     <body class="bg-gray-300 flex items-center justify-center w-screen h-screen">
159 |         <main class="bg-white rounded max-w-screen-xl shadow m-2">
160 | 	        <h3 class="font-bold text-green-800 p-6">Your domain ownership is verified successfully! Thank you for using our service.</h3>
161 |         </main>
162 |     </body>
163 | </html>
164 | 


--------------------------------------------------------------------------------
/src/Contracts/Models/DomainVerifiable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Contracts\Models;
 4 | 
 5 | interface DomainVerifiable
 6 | {
 7 |     /**
 8 |      * Get unique key of domain verifiable
 9 |      *
10 |      */
11 |     public function getKey();
12 | 
13 |     /**
14 |      * Get all the domain verification records
15 |      *
16 |      */
17 |     public function domainVerifications();
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Contracts/Repositories/VerificationRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Contracts\Repositories;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\Models\DomainVerification as DomainVerificationModel;
 7 | 
 8 | interface VerificationRepository
 9 | {
10 |     /**
11 |      * Get an existing or create a new domain verification record
12 |      *
13 |      * @param  string  $url
14 |      * @param  \SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable  $domainVerifiable
15 |      * @return \SunAsterisk\DomainVerifier\Models\DomainVerification
16 |      */
17 |     public function firstOrCreate(string $url, DomainVerifiable $domainVerifiable): DomainVerificationModel;
18 | 
19 |     /**
20 |      * Get existing domain verification record by activation token
21 |      *
22 |      * @param  string  $activationToken
23 |      * @return \SunAsterisk\DomainVerifier\Models\DomainVerification
24 |      */
25 |     public function findByActivationToken(string $activationToken): ?DomainVerificationModel;
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Contracts/Strategies/VerifierStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Contracts\Strategies;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 7 | 
 8 | interface VerifierStrategy
 9 | {
10 |     /**
11 |      * Scan and check domain ownership
12 |      *
13 |      * @param  string  $url
14 |      * @param  \SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable  $domainVerifiable
15 |      * @return bool
16 |      */
17 |     public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult;
18 | 
19 |     /**
20 |      * Get verification token for URL and model
21 |      *
22 |      * @param  string  $url
23 |      * @param  \SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable  $domainVerifiable
24 |      * @return string
25 |      */
26 |     public function getToken(string $url, DomainVerifiable $domainVerifiable): string;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/DomainVerificationFacade.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier;
 4 | 
 5 | use Illuminate\Support\Facades\Facade as IlluminateFacade;
 6 | use SunAsterisk\DomainVerifier\Repositories\DomainVerification;
 7 | 
 8 | class DomainVerificationFacade extends IlluminateFacade
 9 | {
10 |     protected static function getFacadeAccessor()
11 |     {
12 |         return DomainVerification::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/DomainVerifierServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier;
 4 | 
 5 | use Illuminate\Contracts\Foundation\Application;
 6 | use Illuminate\Support\ServiceProvider;
 7 | use SunAsterisk\DomainVerifier\Factories\VerifierFactory;
 8 | use SunAsterisk\DomainVerifier\Repositories\DomainVerification;
 9 | 
10 | class DomainVerifierServiceProvider extends ServiceProvider
11 | {
12 |     /**
13 |      * Bootstrap the application services.
14 |      *
15 |      * @return void
16 |      */
17 |     public function boot()
18 |     {
19 |         if ($this->app->runningInConsole()) {
20 |             $this->loadMigrationsFrom(__DIR__.'/../database/migrations');
21 | 
22 |             $this->publishes([
23 |                 __DIR__.'/../database/migrations' => database_path('migrations'),
24 |             ], 'migrations');
25 | 
26 |             $this->publishes([
27 |                 __DIR__.'/../config/domain_verifier.php' => config_path('domain_verifier.php'),
28 |             ], 'config');
29 |             $this->publishes([
30 |                 __DIR__.'/../resources/assets' => public_path('vendor/domain-verify'),
31 |             ], 'public');
32 |         }
33 | 
34 |         $this->loadViewsFrom(__DIR__.'/../resources/views', 'laravel-domain-verify');
35 |         $this->loadRoutesFrom(__DIR__.'/Http/routes.php');
36 |     }
37 | 
38 |     /**
39 |      * Register the service provider.
40 |      *
41 |      * @return void
42 |      */
43 |     public function register()
44 |     {
45 |         $this->app->singleton(DomainVerification::class, function (Application $app) {
46 |             $connection = $app->make('db')->connection();
47 |             $table = 'domain_verifications';
48 |             $hasher = $app->make('hash');
49 |             $hashKey = $app->make('config')->get('app.key');
50 | 
51 |             return new DomainVerification($connection, $table, $hasher, $hashKey);
52 |         });
53 | 
54 |         $this->app->singleton(VerifierFactory::class, function () {
55 |             return new VerifierFactory();
56 |         });
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Enums/VerifierStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Enums;
 4 | 
 5 | class VerifierStrategy
 6 | {
 7 |     public const DNS_RECORD = 'dns-record';
 8 |     public const HTML_FILE = 'html-file';
 9 |     public const HTML_META = 'html-meta';
10 |     public const SENDING_MAIL = 'sending-mail';
11 | 
12 |     public static function getAlls()
13 |     {
14 |         return collect([
15 |             self::DNS_RECORD,
16 |             self::HTML_FILE,
17 |             self::HTML_META,
18 |             self::SENDING_MAIL,
19 |         ]);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Factories/VerifierFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Factories;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Strategies\VerifierStrategy;
 6 | use SunAsterisk\DomainVerifier\Enums\VerifierStrategy as EnumsVerifierStrategy;
 7 | use SunAsterisk\DomainVerifier\Strategies\DNSRecord;
 8 | use SunAsterisk\DomainVerifier\Strategies\HTMLFile;
 9 | use SunAsterisk\DomainVerifier\Strategies\HTMLMeta;
10 | use SunAsterisk\DomainVerifier\Strategies\SendingMail;
11 | 
12 | class VerifierFactory
13 | {
14 |     public function strategy(string $strategyName): VerifierStrategy
15 |     {
16 |         switch ($strategyName) {
17 |             case EnumsVerifierStrategy::DNS_RECORD:
18 |                 return new DNSRecord();
19 |             case EnumsVerifierStrategy::HTML_FILE:
20 |                 return new HTMLFile();
21 |             case EnumsVerifierStrategy::HTML_META:
22 |                 return new HTMLMeta();
23 |             case EnumsVerifierStrategy::SENDING_MAIL:
24 |                 return new SendingMail();
25 |         }
26 | 
27 |         throw new \InvalidArgumentException("Unsupported domain verification strategy: $strategyName");
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Http/Controller/DomainVerifierController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Http\Controller;
 4 | 
 5 | use Illuminate\Routing\Controller;
 6 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
 7 | use SunAsterisk\DomainVerifier\VerifierFactoryFacade as VerifierFactory;
 8 | use Illuminate\Support\Facades\Log;
 9 | 
10 | class DomainVerifierController extends Controller
11 | {
12 |     public function getHtmlFile($id)
13 |     {
14 |         $domainVerification = DomainVerification::findOrFail($id);
15 |         $verificationName = config('domain_verifier.verification_name');
16 |         $fileName = "$verificationName.html";
17 | 
18 |         $content = $domainVerification->token;
19 | 
20 |         $headers = [
21 |             'Content-type' => 'text/plain',
22 |             'Content-Disposition' => sprintf('attachment; filename="%s"', $fileName),
23 |             'Content-Length' => strlen($content),
24 |         ];
25 | 
26 |         return response()->make($content, 200, $headers);
27 |     }
28 | 
29 |     public function verify($token)
30 |     {
31 |         $viewSucceeded = config('domain_verifier.page.verification_succeeded');
32 |         $viewFailed = config('domain_verifier.page.verification_failed');
33 | 
34 |         $verifier = VerifierFactory::strategy('sending-mail');
35 |         try {
36 |             $result = $verifier->verifyByActivationToken($token);
37 | 
38 |             if ($result->isVerified()) {
39 |                 $verifiable = $result->getVerifiable();
40 |                 $record = $result->getRecord();
41 | 
42 |                 return view($viewSucceeded);
43 |             }
44 | 
45 |             return view($viewFailed);
46 |         } catch (\Exception $exception) {
47 |             Log::error($exception);
48 |             return view($viewFailed);
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Http/routes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\Facades\Route;
 4 | 
 5 | Route::get('/domain-verify/html-file/{id}', [
 6 |     'uses' => 'SunAsterisk\DomainVerifier\Http\Controller\DomainVerifierController@getHtmlFile',
 7 |     'as' => 'domain_verify.get_html_file',
 8 | ]);
 9 | 
10 | Route::get('/domain-verify/activate/{token}', [
11 |     'uses' => 'SunAsterisk\DomainVerifier\Http\Controller\DomainVerifierController@verify',
12 |     'as' => 'domain_verify.verify',
13 | ]);
14 | 


--------------------------------------------------------------------------------
/src/Mail/ActivationMail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Mail;
 4 | 
 5 | use Illuminate\Mail\Mailable;
 6 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 7 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
 8 | 
 9 | class ActivationMail extends Mailable
10 | {
11 |     public $verifiable;
12 | 
13 |     public $verification;
14 | 
15 |     public $domainName;
16 | 
17 |     public $activationToken;
18 | 
19 |     public $emailTo;
20 | 
21 |     /**
22 |      * Constructor
23 |      *
24 |      * @param  \SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable $verifiable
25 |      * @param  \SunAsterisk\DomainVerifier\Models\DomainVerification $verification
26 |      * @param  string $url
27 |      * @param  string $domainName
28 |      * @param  string $activationToken
29 |      * @param  string $emailTo
30 |      */
31 |     public function __construct(
32 |         DomainVerifiable $verifiable,
33 |         DomainVerification $verification,
34 |         string $url,
35 |         string $domainName,
36 |         string $activationToken,
37 |         string $emailTo
38 |     ) {
39 |         $this->verifiable = $verifiable;
40 |         $this->verification = $verification;
41 |         $this->url = $url;
42 |         $this->domainName = $domainName;
43 |         $this->activationToken = $activationToken;
44 |         $this->emailTo = $emailTo;
45 |     }
46 | 
47 |     public function build()
48 |     {
49 |         $mailFrom = config('domain_verifier.mail.from');
50 |         $mailTo = $this->emailTo.'@'.$this->domainName;
51 |         $mailSubject = config('domain_verifier.mail.subject');
52 |         $mailView = config('domain_verifier.mail.view');
53 |         $baseUrl = config('domain_verifier.base_url');
54 | 
55 |         $activationUrl = $baseUrl.'/domain-verify/activate/'.$this->activationToken;
56 | 
57 |         return $this
58 |             ->from($mailFrom)
59 |             ->to($mailTo)
60 |             ->subject($mailSubject)
61 |             ->view($mailView)
62 |             ->with([
63 |                 'url' => $this->url,
64 |                 'domainName' => $this->domainName,
65 |                 'activationToken' => $this->activationToken,
66 |                 'activationUrl' => $activationUrl,
67 |                 'verifiable' => $this->verifiable,
68 |             ]);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/Models/DomainVerification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class DomainVerification extends Model
 8 | {
 9 |     protected $table = 'domain_verifications';
10 | 
11 |     protected $fillable = [
12 |         'verifiable_type',
13 |         'verifiable_id',
14 |         'url',
15 |         'status',
16 |         'token',
17 |         'activation_token',
18 |         'email_sent_at',
19 |         'verified_at',
20 |     ];
21 | 
22 |     /**
23 |      * Get the owning verifiable model
24 |      *
25 |      */
26 |     public function verifiable()
27 |     {
28 |         return $this->morphTo();
29 |     }
30 | 
31 |     /**
32 |      * Set verified domain
33 |      *
34 |      * @return DomainVerification
35 |      */
36 |     public function setVerified()
37 |     {
38 |         $this->update([
39 |             'verified_at' => now(),
40 |             'status' => 'verified',
41 |         ]);
42 | 
43 |         return $this;
44 |     }
45 | 
46 |     /**
47 |      * Unverify domain
48 |      *
49 |      * @return DomainVerification
50 |      */
51 |     public function setNotVerified()
52 |     {
53 |         $this->update([
54 |             'verified_at' => null,
55 |             'status' => 'pending',
56 |         ]);
57 | 
58 |         return $this;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/Repositories/DomainVerification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Repositories;
 4 | 
 5 | use Illuminate\Contracts\Hashing\Hasher;
 6 | use Illuminate\Database\ConnectionInterface;
 7 | use Illuminate\Support\Str;
 8 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 9 | use SunAsterisk\DomainVerifier\Contracts\Repositories\VerificationRepository;
10 | use SunAsterisk\DomainVerifier\Models\DomainVerification as DomainVerificationModel;
11 | 
12 | class DomainVerification implements VerificationRepository
13 | {
14 |     /** @var \Illuminate\Database\ConnectionInterface */
15 |     protected $connection;
16 | 
17 |     /** @var string */
18 |     protected $table;
19 | 
20 |     /** @var \Illuminate\Contracts\Hashing\Hasher */
21 |     protected $hasher;
22 | 
23 |     /** @var string */
24 |     protected $hashKey;
25 | 
26 |     public function __construct(ConnectionInterface $connection, string $table, Hasher $hasher, string $hashKey)
27 |     {
28 |         $this->connection = $connection;
29 |         $this->table = $table;
30 |         $this->hasher = $hasher;
31 |         $this->hashKey = $hashKey;
32 |     }
33 | 
34 |     /**
35 |      * Undocumented function
36 |      *
37 |      * @param  string $url
38 |      * @param  \SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable $verifiable
39 |      * @return \SunAsterisk\DomainVerifier\Models\DomainVerification
40 |      */
41 |     public function firstOrCreate(string $url, DomainVerifiable $verifiable): DomainVerificationModel
42 |     {
43 |         return $verifiable->domainVerifications()->firstOrCreate(
44 |             ['url' => $url],
45 |             [
46 |                 'status' => 'pending',
47 |                 'token' => $this->generateToken(),
48 |                 'activation_token' => $this->generateToken(),
49 |             ]
50 |         );
51 |     }
52 | 
53 |     public function findByActivationToken(string $activationToken): ?DomainVerificationModel
54 |     {
55 |         return DomainVerificationModel::where('activation_token', $activationToken)->first();
56 |     }
57 | 
58 |     /**
59 |      * Create a new randoom token
60 |      *
61 |      * @return string
62 |      */
63 |     protected function generateToken()
64 |     {
65 |         return hash_hmac('sha256', Str::random(48), $this->hashKey);
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/src/Results/VerifyResult.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Results;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
 7 | 
 8 | class VerifyResult
 9 | {
10 |     protected $domainVerifiable;
11 |     protected $url;
12 |     protected $record;
13 | 
14 |     public function __construct(?DomainVerifiable $domainVerifiable, string $url, DomainVerification $record)
15 |     {
16 |         $this->domainVerifiable = $domainVerifiable;
17 |         $this->url = $url;
18 |         $this->record = $record;
19 |     }
20 | 
21 |     public function getVerifiable()
22 |     {
23 |         return $this->domainVerifiable;
24 |     }
25 | 
26 |     public function getRecord()
27 |     {
28 |         return $this->record;
29 |     }
30 | 
31 |     public function isVerified()
32 |     {
33 |         return $this->record->status === 'verified';
34 |     }
35 | 
36 |     public function getStatus()
37 |     {
38 |         return $this->record->status;
39 |     }
40 | 
41 |     public function getUrl()
42 |     {
43 |         return $this->url;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Strategies/BaseStrategy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Strategies;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\Contracts\Strategies\VerifierStrategy;
 7 | use SunAsterisk\DomainVerifier\DomainVerificationFacade;
 8 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
 9 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
10 | use SunAsterisk\DomainVerifier\Supports\URL;
11 | 
12 | abstract class BaseStrategy implements VerifierStrategy
13 | {
14 |     abstract public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult;
15 | 
16 |     /**
17 |      * Get token for verification process
18 |      *
19 |      * @param  string  $url
20 |      * @param  DomainVerifiable  $domainVerifiable
21 |      * @return string
22 |      */
23 |     public function getToken(string $url, DomainVerifiable $domainVerifiable): string
24 |     {
25 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
26 | 
27 |         return $record->token;
28 |     }
29 | 
30 |     public function getDomainName(string $url): string
31 |     {
32 |         return URL::getDomainName($url);
33 |     }
34 | 
35 |     public function getRecord(string $url, DomainVerifiable $domainVerifiable): DomainVerification
36 |     {
37 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
38 | 
39 |         return $record->token;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Strategies/DNSRecord.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Strategies;
 4 | 
 5 | use Spatie\Dns\Dns;
 6 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 7 | use SunAsterisk\DomainVerifier\DomainVerificationFacade;
 8 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 9 | 
10 | class DNSRecord extends BaseStrategy
11 | {
12 |     /**
13 |      * Verify domain ownership via TXT record
14 |      *
15 |      * @param string $url
16 |      * @param DomainVerifiable $domainVerifiable
17 |      * @return VerifyResult
18 |      */
19 |     public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult
20 |     {
21 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
22 | 
23 |         if ($this->tokenExists($url, $record->token)) {
24 |             $record->setVerified();
25 |         } else {
26 |             $record->setNotVerified();
27 |         }
28 | 
29 |         return new VerifyResult($domainVerifiable, $url, $record);
30 |     }
31 | 
32 |     protected function getTxtRecordValues($url)
33 |     {
34 |         $dns = new Dns($url);
35 |         $txtRecords = $dns->getRecords('TXT');
36 | 
37 |         if (preg_match_all('/"([^"]+)"/', $txtRecords, $m)) {
38 |             return $m[1];
39 |         }
40 | 
41 |         return [];
42 |     }
43 | 
44 |     protected function tokenExists($url, $token)
45 |     {
46 |         $verificationName = config('domain_verifier.verification_name');
47 |         $txtRecordValues = $this->getTxtRecordValues($url);
48 |         $verificationValue = "$verificationName=$token";
49 | 
50 |         return in_array($verificationValue, $txtRecordValues);
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/Strategies/HTMLFile.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Strategies;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\DomainVerificationFacade;
 7 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 8 | 
 9 | class HTMLFile extends BaseStrategy
10 | {
11 |     /**
12 |      * Verify domain ownership via HTML meta tag
13 |      *
14 |      * @param  string  $url
15 |      * @param  DomainVerifiable  $domainVerifiable
16 |      * @return VerifyResult
17 |      */
18 |     public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult
19 |     {
20 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
21 |         $verificationToken = $record->token;
22 |         $domainToken = substr($this->getHtmlFileToken($url), 0, strlen($verificationToken));
23 | 
24 |         if ($domainToken === $verificationToken) {
25 |             $record->setVerified();
26 |         } else {
27 |             $record->setNotVerified();
28 |         }
29 | 
30 |         return new VerifyResult($domainVerifiable, $url, $record);
31 |     }
32 | 
33 |     public function getHtmlFileUrl(string $url, DomainVerifiable $domainVerifiable): string
34 |     {
35 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
36 | 
37 |         $baseUrl = config('domain_verifier.base_url');
38 | 
39 |         return $baseUrl.'/domain-verify/html-file/'.$record->id;
40 |     }
41 | 
42 |     protected function fileGetContents($url)
43 |     {
44 |         return file_get_contents($url);
45 |     }
46 | 
47 |     protected function getHtmlFileToken($url)
48 |     {
49 |         $verificationName = config('domain_verifier.verification_name');
50 |         $urlFile = $url.'/'.$verificationName.'.html';
51 | 
52 |         return $this->fileGetContents($urlFile);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/Strategies/HTMLMeta.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Strategies;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 6 | use SunAsterisk\DomainVerifier\DomainVerificationFacade;
 7 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 8 | 
 9 | class HTMLMeta extends BaseStrategy
10 | {
11 |     /**
12 |      * Verify domain ownership via HTML meta tag
13 |      *
14 |      * @param  string  $url
15 |      * @param  DomainVerifiable  $domainVerifiable
16 |      * @return VerifyResult
17 |      */
18 |     public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult
19 |     {
20 |         $metaTags = $this->getMetaTags($url);
21 |         $domainToken = $this->getMetaTagToken($metaTags);
22 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
23 | 
24 |         if ($record->token === $domainToken) {
25 |             $record->setVerified();
26 |         } else {
27 |             $record->setNotVerified();
28 |         }
29 | 
30 |         return new VerifyResult($domainVerifiable, $url, $record);
31 |     }
32 | 
33 |     protected function getMetaTags($url)
34 |     {
35 |         return get_meta_tags($url);
36 |     }
37 | 
38 |     protected function getMetaTagToken(array $metaTags)
39 |     {
40 |         $verificationName = config('domain_verifier.verification_name');
41 |         if (!isset($metaTags[$verificationName])) {
42 |             return '';
43 |         }
44 | 
45 |         return $metaTags[$verificationName];
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Strategies/SendingMail.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Strategies;
 4 | 
 5 | use Carbon\Carbon;
 6 | use Illuminate\Support\Facades\Mail;
 7 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiable;
 8 | use SunAsterisk\DomainVerifier\DomainVerificationFacade;
 9 | use SunAsterisk\DomainVerifier\Mail\ActivationMail;
10 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
11 | use SunAsterisk\DomainVerifier\Supports\URL;
12 | 
13 | class SendingMail extends BaseStrategy
14 | {
15 |     /**
16 |      * Verfiy domain ownership via administrator mail
17 |      *
18 |      * @param string $url
19 |      * @param DomainVerifiable $domainVerifiable
20 |      * @return VerifyResult
21 |      */
22 |     public function verify(string $url, DomainVerifiable $domainVerifiable): VerifyResult
23 |     {
24 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
25 | 
26 |         return new VerifyResult($domainVerifiable, $url, $record);
27 |     }
28 | 
29 |     public function verifyByActivationToken(string $activationToken): VerifyResult
30 |     {
31 |         $record = DomainVerificationFacade::findByActivationToken($activationToken);
32 | 
33 |         if ($record) {
34 |             $record->setVerified();
35 |             $domainVerifiable = $record->verifiable;
36 | 
37 |             return new VerifyResult($domainVerifiable, $record->url, $record);
38 |         }
39 | 
40 |         throw new \Exception('Activation token doesn\'t match to any verifiable object.');
41 |     }
42 | 
43 |     public function sendMail(string $url, DomainVerifiable $domainVerifiable, string $emailTo): void
44 |     {
45 |         $allowedEmailTo = ['admin', 'webmaster'];
46 |         if (!in_array($emailTo, $allowedEmailTo)) {
47 |             throw new \Exception('This mailbox name is not allowed.');
48 |         }
49 | 
50 |         $domainName = URL::getDomainName($url);
51 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
52 |         $domainVerifiable = $record->verifiable;
53 | 
54 |         Mail::send(
55 |             new ActivationMail($domainVerifiable, $record, $url, $domainName, $record->activation_token, $emailTo)
56 |         );
57 | 
58 |         $record->update(['email_sent_at' => Carbon::now()]);
59 |     }
60 | 
61 |     public function setVerified(string $url, DomainVerifiable $domainVerifiable): VerifyResult
62 |     {
63 |         $record = DomainVerificationFacade::firstOrCreate($url, $domainVerifiable);
64 |         $record->setVerified();
65 | 
66 |         return new VerifyResult($domainVerifiable, $url, $record);
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/Supports/URL.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Supports;
 4 | 
 5 | class URL
 6 | {
 7 |     /**
 8 |      * Reformat URL
 9 |      *
10 |      * @param  string  $url
11 |      * @return string
12 |      */
13 |     public static function normalize(string $url)
14 |     {
15 |         $matched = preg_match('/^(http[s]?:\/\/(?:[a-zA-Z0-9-.:]+))(\/.*)?/', $url, $data);
16 | 
17 |         return $matched ? trim($data[1]) : '';
18 |     }
19 | 
20 |     /**
21 |      * get Domain name from URL
22 |      *
23 |      * @param string $url
24 |      * @return string
25 |      */
26 |     public static function getDomainName(string $url)
27 |     {
28 |         $parsedUrl = parse_url($url);
29 | 
30 |         if (array_key_exists('host', $parsedUrl)) {
31 |             return $parsedUrl['host'];
32 |         }
33 | 
34 |         throw new \InvalidArgumentException('Provided URL\'s domain name cannot be parsed.');
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Traits/DomainVerifiable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Traits;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Models\DomainVerification;
 6 | 
 7 | trait DomainVerifiable
 8 | {
 9 |     public function domainVerifications()
10 |     {
11 |         return $this->morphMany(DomainVerification::class, 'verifiable');
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/VerifierFactoryFacade.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | use SunAsterisk\DomainVerifier\Factories\VerifierFactory;
 7 | 
 8 | class VerifierFactoryFacade extends Facade
 9 | {
10 |     protected static function getFacadeAccessor()
11 |     {
12 |         return VerifierFactory::class;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/tests/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sun-asterisk-research/laravel-domain-verify/f585d16982a9e5e31e752e4cb4d26cbee3558e4d/tests/.gitkeep


--------------------------------------------------------------------------------
/tests/Strategies/DNSRecordTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests\Strategies;
 4 | 
 5 | use Mockery;
 6 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 7 | use SunAsterisk\DomainVerifier\Strategies\DNSRecord;
 8 | 
 9 | class DNSRecordTest extends StrategyTestCase
10 | {
11 |     protected $verifier;
12 |     protected $url;
13 |     protected $token;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->url = 'https://domain.local';
20 | 
21 |         $this->token = (new DNSRecord())->getToken($this->url, $this->verifiable);
22 |     }
23 | 
24 |     public function testItCanCheckValidToken()
25 |     {
26 |         $result = $this->verifyWith($this->token);
27 |         $this->assertInstanceOf(VerifyResult::class, $result);
28 |         $this->assertTrue($result->isVerified());
29 |         $this->assertEquals('verified', $result->getStatus());
30 |     }
31 | 
32 |     public function testItCanCheckInvalidToken()
33 |     {
34 |         $result = $this->verifyWith('some wrong token');
35 |         $this->assertFalse($result->isVerified());
36 |         $this->assertEquals('pending', $result->getStatus());
37 |     }
38 | 
39 |     protected function verifyWith(string $token): VerifyResult
40 |     {
41 |         $this->verifier = Mockery::mock(DNSRecord::class)
42 |             ->makePartial()
43 |             ->shouldAllowMockingProtectedMethods()
44 |             ->allows(['getTxtRecordValues' => [self::VERIFICATION_NAME.'='.$token]]);
45 | 
46 |         return $this->verifier->verify($this->url, $this->verifiable);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Strategies/HTMLFileTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests\Strategies;
 4 | 
 5 | use Mockery;
 6 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 7 | use SunAsterisk\DomainVerifier\Strategies\HTMLFile;
 8 | 
 9 | class HTMLFileTest extends StrategyTestCase
10 | {
11 |     protected $verifier;
12 |     protected $url;
13 |     protected $token;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->url = 'https://domain.local';
20 | 
21 |         $this->token = (new HTMLFile())->getToken($this->url, $this->verifiable);
22 |     }
23 | 
24 |     public function testItCanCheckValidToken()
25 |     {
26 |         $result = $this->verifyWith($this->token);
27 |         $this->assertInstanceOf(VerifyResult::class, $result);
28 |         $this->assertTrue($result->isVerified());
29 |         $this->assertEquals('verified', $result->getStatus());
30 |     }
31 | 
32 |     public function testItCanCheckInvalidToken()
33 |     {
34 |         $result = $this->verifyWith('some wrong token');
35 |         $this->assertFalse($result->isVerified());
36 |         $this->assertEquals('pending', $result->getStatus());
37 |     }
38 | 
39 |     protected function verifyWith(string $token): VerifyResult
40 |     {
41 |         $this->verifier = Mockery::mock(HTMLFile::class)
42 |             ->makePartial()
43 |             ->shouldAllowMockingProtectedMethods()
44 |             ->allows(['fileGetContents' => $token]);
45 | 
46 |         return $this->verifier->verify($this->url, $this->verifiable);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Strategies/HTMLMetaTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests\Strategies;
 4 | 
 5 | use Mockery;
 6 | use SunAsterisk\DomainVerifier\Results\VerifyResult;
 7 | use SunAsterisk\DomainVerifier\Strategies\HTMLMeta;
 8 | 
 9 | class HTMLMetaTest extends StrategyTestCase
10 | {
11 |     protected $verifier;
12 |     protected $url;
13 |     protected $token;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         $this->url = 'https://domain.local';
20 | 
21 |         $this->token = (new HTMLMeta())->getToken($this->url, $this->verifiable);
22 |     }
23 | 
24 |     public function testItCanCheckValidToken()
25 |     {
26 |         $result = $this->verifyWith($this->token);
27 |         $this->assertInstanceOf(VerifyResult::class, $result);
28 |         $this->assertTrue($result->isVerified());
29 |         $this->assertEquals('verified', $result->getStatus());
30 |     }
31 | 
32 |     public function testItCanCheckInvalidToken()
33 |     {
34 |         $result = $this->verifyWith('some wrong token');
35 |         $this->assertFalse($result->isVerified());
36 |         $this->assertEquals('pending', $result->getStatus());
37 |     }
38 | 
39 |     protected function verifyWith(string $token): VerifyResult
40 |     {
41 |         $this->verifier = Mockery::mock(HTMLMeta::class)
42 |             ->makePartial()
43 |             ->shouldAllowMockingProtectedMethods()
44 |             ->allows(['getMetaTags' => [self::VERIFICATION_NAME => $token]]);
45 | 
46 |         return $this->verifier->verify($this->url, $this->verifiable);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/Strategies/StrategyTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests\Strategies;
 4 | 
 5 | use Mockery;
 6 | use SunAsterisk\DomainVerifier\Contracts\Models\DomainVerifiableInterface;
 7 | use SunAsterisk\DomainVerifier\Tests\TestCase;
 8 | 
 9 | class StrategyTestCase extends TestCase
10 | {
11 |     protected $verifiable;
12 | 
13 |     public function setUp(): void
14 |     {
15 |         parent::setUp();
16 | 
17 |         $this->verifiable = Mockery::mock(DomainVerifiableInterface::class)
18 |             ->makePartial()->allows()
19 |             ->getKey()
20 |             ->andReturns('1')
21 |             ->getMock();
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/Supports/URLTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests\Supports;
 4 | 
 5 | use SunAsterisk\DomainVerifier\Supports\URL;
 6 | use SunAsterisk\DomainVerifier\Tests\TestCase;
 7 | 
 8 | class URLTest extends TestCase
 9 | {
10 |     private $httpsURL = 'https://demo-example.domain.local/hello?fbclick=111&src=example';
11 |     private $httpURL = 'http://demo-example.domain.local/hello?fbclick=111&src=example';
12 |     private $httpURLWithPort = 'http://demo-example.domain.local:8000/hello?fbclick=111&src=example';
13 | 
14 |     public function testItCanNormalizeUrl()
15 |     {
16 |         $normalizedHttpsURL = URL::normalize($this->httpsURL);
17 |         $normalizedHttpURL = URL::normalize($this->httpURL);
18 |         $normalizedHttpURLWithPort = URL::normalize($this->httpURLWithPort);
19 | 
20 |         $this->assertSame('https://demo-example.domain.local', $normalizedHttpsURL);
21 |         $this->assertSame('http://demo-example.domain.local', $normalizedHttpURL);
22 |         $this->assertSame('http://demo-example.domain.local:8000', $normalizedHttpURLWithPort);
23 |     }
24 | 
25 |     public function testItCanGetDomainName()
26 |     {
27 |         $domainHttpsURL = URL::getDomainName($this->httpsURL);
28 |         $domainHttpURL = URL::getDomainName($this->httpURL);
29 |         $domainHttpURLWithPort = URL::getDomainName($this->httpURLWithPort);
30 | 
31 |         $this->assertSame('demo-example.domain.local', $domainHttpsURL);
32 |         $this->assertSame('demo-example.domain.local', $domainHttpURL);
33 |         $this->assertSame('demo-example.domain.local', $domainHttpURLWithPort);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace SunAsterisk\DomainVerifier\Tests;
 4 | 
 5 | use Illuminate\Foundation\Testing\DatabaseMigrations;
 6 | use Illuminate\Support\Facades\Config;
 7 | use SunAsterisk\DomainVerifier\DomainVerifierServiceProvider;
 8 | 
 9 | class TestCase extends \Orchestra\Testbench\TestCase
10 | {
11 |     use DatabaseMigrations;
12 | 
13 |     public const VERIFICATION_NAME = 'domain-verification';
14 | 
15 |     public function setUp(): void
16 |     {
17 |         parent::setUp();
18 | 
19 |         Config::set('domain_verifier.verification_name', self::VERIFICATION_NAME);
20 |         Config::set('app.key', 'test_app_key');
21 |     }
22 | 
23 |     protected function getPackageProviders($app)
24 |     {
25 |         return [
26 |             DomainVerifierServiceProvider::class,
27 |         ];
28 |     }
29 | 
30 |     protected function getEnvironmentSetUp($app)
31 |     {
32 |     }
33 | }
34 | 


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