LaravelInvites::validFrom() - Code Metrics - Inspection of "Merge branch 'release/beta'" - mathewparet/laravel-invites - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 146b61...80e19c )

by Mathew
created 2019-01-25 04:08 UTC
LaravelInvites::validFrom() A

↳ Parent: LaravelInvites
Complexity

Conditions	2
Paths	1
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	2
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	2
nc	1
nop	1
<?php

namespace mathewparet\LaravelInvites;

use mathewparet\LaravelInvites\Exceptions\InvalidInvitationCodeException;
use mathewparet\LaravelInvites\Exceptions\InvalidEmailIdException;
use mathewparet\LaravelInvites\Exceptions\InvitationNotYetActiveException;
use mathewparet\LaravelInvites\Exceptions\InvitationExpiredException;
use mathewparet\LaravelInvites\Exceptions\InvitationNotValidWithEmailException;
use mathewparet\LaravelInvites\Exceptions\MaximumUseOfCodeException;
use mathewparet\LaravelInvites\Exceptions\LaravelInvitesException;
use mathewparet\LaravelInvites\Exceptions\AnEmailCanHaveOnlyOneInvitation;

use mathewparet\LaravelInvites\Mail\InvitationMail;

use Illuminate\Support\Facades\Mail;

use Carbon\Carbon;
use Validator;

use mathewparet\LaravelInvites\Models\Invite;

/**
 * Usage
 * use mathewparet\LaravelInvites\LaravelInvites;
 * 
 * $invitation = LaravelInvites::withoutExpiry()->allowUses(10)->generate(100);
 */

class LaravelInvites
{
    private $number_of_invites = 1;
    private $data = [];

    private function initializeData()
    {
        $this->data = ['allow_count' => 1];
    }

    public function __construct()
    {
        $this->initializeData();
    }

    public function get()
    {
        if(!blank(optional($this->data)['email']))
            $result =  Invite::valid()->whereEmail($this->data['email'])->first();
        else
            $result = Invite::valid()->get();

        $this->initializeData();

        return $result;
    }

    public function for($email=null)
    {
        if(!$email)
        {
            unset($this->data['email']);
            return $this;
        }

        $validator = Validator::make(compact('email'),[
            'email'=>'required|email'
        ]);
        if($validator->fails())
            throw new InvalidEmailIdException;

        $this->data['email'] = $email;

        return $this;
    }

    private function prepareSingle()
    {
        $invite = Invite::create($this->data);

        if($invite->email && config('laravelinvites.mail.enabled', true))

            Mail::to($invite->email)->send(new InvitationMail($invite));

        return $invite;
    }

    public function validFrom($date = null)
    {
        $this->data['valid_from'] = $date ? : now();

        return $this;
    }

    /**
     * Generate the requested invitations
     * 
     * @return \mathewparet\LaravelInvites\Model\Invite::clss $invite
filter:
    dependency_paths: ["lib/*"]
     */
    private function prepare()
    {
        if($this->number_of_invites == 1)
            return $this->prepareSingle();


        $invites = [];

        for($i = 0; $i < $this->number_of_invites; $i++)
        {
            $invites[] = $this->prepareSingle();
        }

        return $invites;

    }

    /**
     * Generate invitations
     * 
     * @param intiger $number_of_invites | default = 1
filter:
    dependency_paths: ["lib/*"]
     * 
     * @return mixed array of invitations generated
     */
    public function generate($number_of_invites = 1)
    {
        if(optional($this->data)['email'] && !blank($this->data['email']))
        {
            if($number_of_invites > 1)
                throw new AnEmailCanHaveOnlyOneInvitation;

            $validator = Validator::make($this->data,[
                'email'=>'unique:'.config('laravelinvites.table').',email'
            ]);

            if($validator->fails())
                throw new AnEmailCanHaveOnlyOneInvitation;
        }

        $this->number_of_invites = $number_of_invites;

        $invitations =  $this->prepare();
        
        $this->initializeData();

        return $invitations;
    }

    /**
     * Set the number of uses allowed for this invite
     * 
     * @param integer $num_allowed
     * 
     * @return $this
     */
    public function allow($num_allowed = 1)
    {
        $this->data['allowed_count'] = $num_allowed;

        return $this;
    }

    /**
     * Generate a single invitiation to be used only by a specific email
     * 
     * @param string $email
     * 
     * @return mixed the invitation record
     */
    public function generateFor($email)
    {
        $this->for($email);

        return $this->generate(1);
        return $this->generate(/** @scrutinizer ignore-type */ 1);
    }

    /**
     * Set expiry to never expire
     * 
     * @return reference to self
filter:
    dependency_paths: ["lib/*"]
     */
    public function withoutExpiry()
    {
        $this->data['valid_upto'] = null;

        return $this;

    }

    /**
     * Set an expiry date
     * 
     * @param \Carbon\Carbon $data
     */
    public function setExpiry(Carbon $date)
    {
        $this->data['valid_upto'] = $date;

        return $this;
    }

    /**
     * Find an invitation by code
     * 
     * @param string $code
     *
     * @return \mathewparet\LaravelInvites\Model\Invite $invite
     */
    public function find($code)
    {
        return Invite::whereCode($code)->firstOrFail();

    }

    private function getEmailParameter($parameters)
    {
        return $parameters[0] ? : 'email' ;
    }
    
    public function validate($attribute, $value, $parameters, $validator)
    public function validate(/** @scrutinizer ignore-unused */ $attribute, $value, $parameters, $validator)
    {
        $emailFieldName = $this->getEmailParameter($parameters);

        try {        
            $email = $validator->data[$emailFieldName];

            $this->check($code, $email);

            return true;
        }
        catch(InvalidInvitationCodeException $e)
        {
            $validator->errors()->add($emailFieldName, ':attribute is invalid');
            return false;
        }
        catch(InvitationNotYetActiveException $e)
        {
            $validator->errors()->add($emailFieldName, ':attribute is not valid yet');
            return false;
        }
        catch(InvitationExpiredException $e)
        {
            $validator->errors()->add($emailFieldName, ':attribute expired');
            return false;
        }
        catch(InvitationNotValidWithEmailException $e)
        {
            $validator->errors()->add($emailFieldName, ':attribute is not valid with the provided '.$emailFieldName);
            return false;
        }
        catch(MaximumUseOfCodeException $e)
        {
            $validator->errors()->add($emailFieldName, ':attribute has been used for the maximum possible times');
            return false;
        }
    }

    /**
     * Check whether an invitation is valid with the provided email
     * 
     * @param string $code
     * @param string $email to be checked against
     */

    public function isValid($code, $email = null)
    {
        try
        {
            $this->check($code, $email);

            return true;
        }
        catch(LaravelInvitesException $e)
        {
            return false;
        }
    }

    /**
     * Check the validity of the invitiation code
     * 
     * @param string $code
     * @param string $email
     */
    public function check($code, $email=null)
    {
        $invite = Invite::whereCode($code)->first();

        if(!$invite)
            throw new InvalidInvitationCodeException;
        
        if($invite->valid_from > now())
            throw new InvitationNotYetActiveException($invite->valid_from);

        if($invite->valid_upto && $invite->valid_upto <= now())
            throw new InvitationExpiredException($invite->valid_upto);

        if($invite->used_count > ($invite->allowed_count-1))

            throw new MaximumUseOfCodeException($invite->allowed_count);

        if($invite->email !== $email && !blank($invite->email))

            throw new InvitationNotValidWithEmailException($email, $invite->email);

        return true;
    }

    /**
     * Redeem the invitation code. Make sure the form field is validated before this calls to avoid exceptions
     * 
     * @param string $code
     * @param string $email (optional)
     * 
     * @return mixed
     */

    public function redeem($code, $email = null)
    {
        $this->check($code, $email);
     
        $this->find($code)->redeem();

        return true;
    }

    /**
     * Set a validity start date for the invitation
     * 
     * @param \Carbon\Carbon $date
     */
    public function notBefore(Carbon $date)
    {
        $this->data['valid_from'] = $date;
        return $this;
    }

}
mathewparet / laravel-invites

Push — master ( 146b61...80e19c )

LaravelInvites::validFrom() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
