1397 lines
33 KiB
PHP
1397 lines
33 KiB
PHP
<?php
|
|
|
|
namespace App\Models;
|
|
|
|
use Exception;
|
|
use Illuminate\Database\Eloquent\Casts\AsCollection;
|
|
use Illuminate\Database\Eloquent\Collection as DatabaseCollection;
|
|
use Illuminate\Database\Eloquent\Factories\HasFactory;
|
|
use Illuminate\Database\Eloquent\Model;
|
|
use Illuminate\Database\Eloquent\Relations\BelongsTo;
|
|
use Illuminate\Database\Eloquent\Relations\HasMany;
|
|
use Illuminate\Database\Eloquent\Relations\HasOne;
|
|
use Illuminate\Database\Eloquent\Relations\MorphTo;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Collection;
|
|
use Illuminate\Support\Facades\Auth;
|
|
use Leenooks\Carbon;
|
|
use Symfony\Component\HttpKernel\Exception\HttpException;
|
|
|
|
use App\Interfaces\IDs;
|
|
use App\Traits\NextKey;
|
|
|
|
/**
|
|
* Class Service
|
|
* Services that belong to an account
|
|
*
|
|
* Attributes for services:
|
|
* + billing_period : The period that this service is billed for by default
|
|
* + name : Service short name with service address
|
|
* + name_short : Service Product short name, eg: phone number, domain name, certificate CN
|
|
* + name_detail : Service Detail, eg: service_address
|
|
* + sid : System ID for service
|
|
*
|
|
* @package App\Models
|
|
*/
|
|
class Service extends Model implements IDs
|
|
{
|
|
use NextKey,HasFactory;
|
|
|
|
const RECORD_ID = 'service';
|
|
public $incrementing = FALSE;
|
|
|
|
protected $table = 'ab_service';
|
|
const CREATED_AT = 'date_orig';
|
|
const UPDATED_AT = 'date_last';
|
|
|
|
protected $appends = [
|
|
'account_name',
|
|
'admin_service_id_url',
|
|
'billing_price',
|
|
'name_short',
|
|
'next_invoice',
|
|
'product_category',
|
|
'product_name',
|
|
'service_id',
|
|
'service_id_url',
|
|
'status',
|
|
];
|
|
|
|
protected $dates = [
|
|
'date_last_invoice',
|
|
'date_next_invoice',
|
|
'date_start',
|
|
'date_end',
|
|
];
|
|
|
|
protected $casts = [
|
|
'order_info'=>AsCollection::class,
|
|
];
|
|
public $dateFormat = 'U';
|
|
|
|
protected $visible = [
|
|
'account_name',
|
|
'admin_service_id_url',
|
|
'active',
|
|
'billing_price',
|
|
'data_orig',
|
|
'id',
|
|
'name_short',
|
|
'next_invoice',
|
|
'product_category',
|
|
'product_name',
|
|
'service_id',
|
|
'service_id_url',
|
|
'status',
|
|
];
|
|
|
|
protected $with = [
|
|
'account.language',
|
|
'charges',
|
|
'invoice_items',
|
|
'product',
|
|
'type',
|
|
];
|
|
|
|
// @todo Change to self::INACTIVE_STATUS
|
|
private $inactive_status = [
|
|
'CANCELLED',
|
|
'ORDER-REJECTED',
|
|
'ORDER-CANCELLED',
|
|
];
|
|
|
|
public const INACTIVE_STATUS = [
|
|
'CANCELLED',
|
|
'ORDER-REJECTED',
|
|
'ORDER-CANCELLED',
|
|
];
|
|
|
|
/**
|
|
* Valid status shows the applicable next status for an action on a service
|
|
* Each status can be
|
|
*
|
|
* The structure of each item is:
|
|
* <ORDER_STATUS> => [
|
|
* 'next' == next possible levels, initiated by who (array).
|
|
* who = 'role','system'
|
|
* 'enter_method' == the method run when we enter this stage - could be used to send email for example, if this method doesnt complete successfully, we dont enter this stage
|
|
* + If it returns NULL, An error condition
|
|
* + If it returns FALSE, the service cannot enter this stage
|
|
* + If it returns TRUE, the service has successfully changed to this stage
|
|
* + If it returns a VIEW/REDIRECT, that resulting page will handle the status change
|
|
* 'exit_method' == the method that determines that the order can leave this status (true = can, false = cant)
|
|
* + If it returns NULL, An error condition
|
|
* + If it returns FALSE, the service CANNOT leave this stage
|
|
* + If it returns TRUE, the service CAN leave this stage
|
|
* it will receive the next method as an argument
|
|
* 'title' == title shown on the menu, for the user to choose
|
|
* ]
|
|
* So when an order goes to the next state, the exit method will be tested immediately (if there is only 1 exit method for the user)
|
|
* to see if it can proceed further if not, it'll wait here for user/admin intervention
|
|
*
|
|
* @var array
|
|
*/
|
|
private const ACTION_PROGRESS = [
|
|
// Order Submitted @todo redo
|
|
'ORDER-SUBMIT' => [
|
|
'fail'=>FALSE,
|
|
// Progress to next stages by who
|
|
'next'=>[
|
|
'ORDER-ACCEPT'=>['customer'],
|
|
'SETUP-PAYMENT-WAIT'=>['reseller','wholesaler']
|
|
],
|
|
// Manual or System moves to the next stage
|
|
'system'=>TRUE,
|
|
'method'=>'action_order_submit',
|
|
'title'=>'Order Submit',
|
|
],
|
|
// Client accepts order, if performed by RW @todo redo
|
|
'ORDER-ACCEPT' => [
|
|
'fail'=>FALSE,
|
|
'next'=>[
|
|
'SETUP-PAYMENT-WAIT'=>['customer'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_order_accept',
|
|
'title'=>'Client Accept Order',
|
|
],
|
|
// If the product has a setup, collect payment information @todo redo
|
|
'SETUP-PAYMENT-WAIT' => [
|
|
'fail'=>FALSE,
|
|
'next'=>[
|
|
'PAYMENT-WAIT'=>['customer'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_setup_payment_wait',
|
|
'title'=>'Setup Payment',
|
|
],
|
|
// @todo redo
|
|
'PAYMENT-WAIT' => [
|
|
'fail'=>FALSE,
|
|
'next'=>[
|
|
'PAYMENT-CHECK'=>['reseller','wholesaler'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_payment_wait',
|
|
'title'=>'Service Payment',
|
|
],
|
|
// @todo redo
|
|
'PAYMENT-CHECK' => [
|
|
'fail'=>'ORDER-HOLD',
|
|
'next'=>[
|
|
'ORDER-SENT'=>[],
|
|
],
|
|
'system'=>TRUE,
|
|
'method'=>'action_payment_check',
|
|
'title'=>'Validate Payment Method',
|
|
],
|
|
// Order On Hold (Reason) @todo redo
|
|
'ORDER-HOLD' => ['release'=>'ORDER-SUBMIT','update_reference'=>'ORDER-SENT'],
|
|
// Order Rejected (Reason) @todo redo
|
|
'ORDER-REJECTED' => [],
|
|
// Order Cancelled @todo redo
|
|
'ORDER-CANCELLED' => [],
|
|
// Order Sent to Supplier @todo redo
|
|
'ORDER-SENT' => [
|
|
'fail'=>'ORDER-HOLD',
|
|
'next'=>[
|
|
'ORDERED'=>['wholesaler'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_order_sent',
|
|
'title'=>'Send Order',
|
|
],
|
|
// Order Confirmed by Supplier @todo redo
|
|
'ORDERED' => [
|
|
'fail'=>false,
|
|
'next'=>[
|
|
'PROVISION-HOLD'=>['wholesaler'],
|
|
'PROVISION-PLANNED'=>['wholesaler'],
|
|
'PROVISIONED'=>['wholesaler'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_ordered',
|
|
'title'=>'Service Ordered',
|
|
],
|
|
// Service confirmed by supplier, optional connection date @todo redo
|
|
'PROVISION-PLANNED' => [
|
|
'fail'=>false,
|
|
'next'=>[
|
|
'PROVISIONED'=>['wholesaler'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_provision_planned',
|
|
'title'=>'Provision Planned',
|
|
],
|
|
// Service has been provisioned by supplier @todo redo
|
|
'PROVISIONED' => [
|
|
'fail'=>false,
|
|
'next'=>[
|
|
'ACTIVE'=>['wholesaler'],
|
|
],
|
|
'system'=>FALSE,
|
|
'method'=>'action_provisioned',
|
|
'title'=>'Provisioned',
|
|
],
|
|
// Service is Active
|
|
'ACTIVE' => [
|
|
'next'=>[
|
|
'CANCEL-REQUEST'=>['customer'],
|
|
'CHANGE-REQUEST'=>['customer'],
|
|
],
|
|
'exit'=>'action_active_exit',
|
|
'title'=>'Service Active',
|
|
],
|
|
// Service to be Upgraded
|
|
'CANCEL-CANCEL' => [
|
|
'next'=>[
|
|
'ACTIVE'=>['wholesaler'],
|
|
],
|
|
'enter_method'=>'action_cancel_cancel',
|
|
'title'=>'Cancel Cancellation Request',
|
|
],
|
|
// Service to be Cancelled
|
|
'CANCEL-REQUEST' => [
|
|
'next'=>[
|
|
'CANCEL-CANCEL'=>['wholesaler'],
|
|
'CANCEL-PENDING'=>['wholesaler'],
|
|
],
|
|
'enter_method'=>'action_request_enter_redirect',
|
|
'exit_method'=>'action_cancel_request_exit',
|
|
'title'=>'Cancel Request',
|
|
],
|
|
// Service Cancellation being processed
|
|
'CANCEL-PENDING' => [
|
|
'next'=>[
|
|
'CANCELLED'=>['wholesaler'],
|
|
],
|
|
'enter_method'=>'action_cancel_pending_enter',
|
|
'exit_method'=>'action_cancel_pending_exit',
|
|
'title'=>'Cancel Pending',
|
|
],
|
|
// Service to be Upgraded
|
|
'CHANGE-CANCEL' => [
|
|
'next'=>[
|
|
'ACTIVE'=>['wholesaler'],
|
|
],
|
|
'enter_method'=>'action_change_cancel',
|
|
'title'=>'Cancel Change Request',
|
|
],
|
|
// Service to be Upgraded
|
|
'CHANGE-REQUEST' => [
|
|
'next'=>[
|
|
'CHANGE-PENDING'=>['wholesaler'],
|
|
'CHANGE-CANCEL'=>['wholesaler'],
|
|
],
|
|
'enter_method'=>'action_request_enter_redirect',
|
|
'title'=>'Change Service',
|
|
],
|
|
];
|
|
|
|
/* RELATIONS */
|
|
|
|
/**
|
|
* Account the service belongs to
|
|
*
|
|
* @return BelongsTo
|
|
*/
|
|
public function account()
|
|
{
|
|
return $this->belongsTo(Account::class);
|
|
}
|
|
|
|
/**
|
|
* Return automatic billing details
|
|
*
|
|
* @return HasOne
|
|
*/
|
|
public function billing()
|
|
{
|
|
return $this->hasOne(AccountBilling::class);
|
|
}
|
|
|
|
/**
|
|
* Return Charges associated with this Service
|
|
*
|
|
* @return HasMany
|
|
*/
|
|
public function charges()
|
|
{
|
|
return $this->hasMany(Charge::class)
|
|
->where('active','=',TRUE)
|
|
->orderBy('date_orig');
|
|
}
|
|
|
|
// @todo changed to invoiced_items
|
|
public function invoice_items($active=TRUE)
|
|
{
|
|
$query = $this->hasMany(InvoiceItem::class)
|
|
->where('item_type','=',0)
|
|
->orderBy('date_start');
|
|
|
|
// @todo Change to $query->active();
|
|
if ($active)
|
|
$query->where('active','=',TRUE);
|
|
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Invoices for this service
|
|
*
|
|
*/
|
|
public function invoices($active=TRUE)
|
|
{
|
|
$query = $this->hasManyThrough(Invoice::class,InvoiceItem::class,NULL,'id',NULL,'invoice_id')
|
|
->distinct('id')
|
|
->where('ab_invoice.site_id','=',$this->site_id)
|
|
->where('ab_invoice_item.site_id','=',$this->site_id)
|
|
->orderBy('date_orig')
|
|
->orderBy('due_date');
|
|
|
|
if ($active)
|
|
$query->where('ab_invoice_item.active','=',TRUE)
|
|
->where('ab_invoice.active','=',TRUE);
|
|
|
|
return $query;
|
|
}
|
|
|
|
/**
|
|
* Account that ordered the service
|
|
*
|
|
* @return BelongsTo
|
|
*/
|
|
public function orderedby()
|
|
{
|
|
return $this->belongsTo(Account::class);
|
|
}
|
|
|
|
/**
|
|
* Product of the service
|
|
*
|
|
* @return BelongsTo
|
|
* @deprecated use type->product
|
|
*/
|
|
public function product()
|
|
{
|
|
return $this->belongsTo(Product::class);
|
|
}
|
|
|
|
/**
|
|
* The site this service is configured for
|
|
*
|
|
* @todo It may be more appropriate to get this from the account->user attribute (ie: for mail actions)
|
|
* @return \Illuminate\Database\Eloquent\Relations\BelongsTo
|
|
*/
|
|
public function site()
|
|
{
|
|
return $this->belongsTo(Site::class);
|
|
}
|
|
|
|
/**
|
|
* Return a child model with details of the service
|
|
*
|
|
* @return MorphTo
|
|
*/
|
|
public function type()
|
|
{
|
|
return $this->morphTo(null,'model','id','service_id');
|
|
}
|
|
|
|
/* SCOPES */
|
|
|
|
/**
|
|
* Only query active categories
|
|
*/
|
|
public function scopeActive($query)
|
|
{
|
|
return $query->where(function () use ($query) {
|
|
$query->where($this->getTable().'.active',TRUE)
|
|
->orWhereNotIn('order_status',$this->inactive_status);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Only query records that the user is authorised to see
|
|
*/
|
|
public function scopeAuthorised($query,User $uo)
|
|
{
|
|
return $query
|
|
->whereIN($this->getTable().'.account_id',$uo->all_accounts()->pluck('id')->unique()->toArray());
|
|
}
|
|
|
|
/**
|
|
* Find inactive services.
|
|
*
|
|
* @param $query
|
|
* @return mixed
|
|
*/
|
|
public function scopeInActive($query)
|
|
{
|
|
return $query->where(function () use ($query) {
|
|
$query->where($this->getTable().'.active',FALSE)
|
|
->orWhereIn('order_status',$this->inactive_status);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Enable to perform queries without eager loading
|
|
*
|
|
* @param $query
|
|
* @return mixed
|
|
*/
|
|
public function scopeNoEagerLoads($query){
|
|
return $query->setEagerLoads([]);
|
|
}
|
|
|
|
/**
|
|
* Search for a record
|
|
*
|
|
* @param $query
|
|
* @param string $term
|
|
* @return
|
|
*/
|
|
public function scopeSearch($query,string $term)
|
|
{
|
|
return $query->where('id','like','%'.$term.'%');
|
|
}
|
|
|
|
/* ATTRIBUTES */
|
|
|
|
/**
|
|
* Name of the account for this service
|
|
*
|
|
* @return mixed
|
|
* @deprecated use $this->>account->name directly
|
|
*/
|
|
public function getAccountNameAttribute(): string
|
|
{
|
|
return $this->account->name;
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use getUrlAdminAttribute()
|
|
*/
|
|
public function getAdminServiceIdUrlAttribute()
|
|
{
|
|
return $this->getUrlAdminAttribute();
|
|
}
|
|
|
|
/**
|
|
* Return the auto billing details
|
|
*
|
|
* @return mixed
|
|
* @deprecated use billing directly?
|
|
*/
|
|
public function getAutoPayAttribute()
|
|
{
|
|
return $this->billing;
|
|
}
|
|
|
|
public function getBillingPriceAttribute(): float
|
|
{
|
|
// @todo Temporary for services that dont have recur_schedule set.
|
|
if (is_null($this->recur_schedule) OR is_null($this->product->price($this->recur_schedule)))
|
|
$this->price=0;
|
|
|
|
return $this->addTax(is_null($this->price) ? $this->product->price($this->recur_schedule) : $this->price);
|
|
}
|
|
|
|
public function getBillingMonthlyPriceAttribute(): float
|
|
{
|
|
$d = 0;
|
|
switch ($this->recur_schedule) {
|
|
case 0: $d = 12/52; break;
|
|
case 1: $d = 1; break;
|
|
case 2: $d = 3; break;
|
|
case 3: $d = 6; break;
|
|
case 4: $d = 12; break;
|
|
case 5: $d = 24; break;
|
|
case 6: $d = 36; break;
|
|
}
|
|
|
|
return number_format($this->getBillingPriceAttribute()/$d,2);
|
|
}
|
|
|
|
/**
|
|
* Return the service billing period
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getBillingPeriodAttribute(): string
|
|
{
|
|
return Arr::get($this->product->PricePeriods(),$this->recur_schedule,'Unknown');
|
|
}
|
|
|
|
/**
|
|
* Date the service expires, also represents when it is paid up to
|
|
*
|
|
* @return string
|
|
* @todo
|
|
*/
|
|
public function getExpiresAttribute(): string
|
|
{
|
|
return 'TBA';
|
|
}
|
|
|
|
/**
|
|
* Return the date for the next invoice
|
|
*
|
|
* @todo Change date_next_invoice to connect_date/invoice_start_date
|
|
* @return Carbon|string
|
|
*/
|
|
public function getInvoiceNextAttribute()
|
|
{
|
|
$last = $this->getInvoiceToAttribute();
|
|
$date = $last
|
|
? $last->addDay()
|
|
: ($this->date_next_invoice ? $this->date_next_invoice->clone()
|
|
: ($this->date_start ?: Carbon::now()));
|
|
|
|
return request()->wantsJson() ? $date->format('Y-m-d') : $date;
|
|
}
|
|
|
|
/**
|
|
* Return the end date for the next invoice
|
|
*
|
|
* @return mixed
|
|
* @throws Exception
|
|
*/
|
|
public function getInvoiceNextEndAttribute()
|
|
{
|
|
switch ($this->recur_schedule) {
|
|
// Weekly
|
|
case 0: $date = $this->product->price_recurr_strict
|
|
? $this->getInvoiceNextAttribute()->endOfWeek()
|
|
: $this->getInvoiceNextAttribute()->addWeek()->subDay();
|
|
break;
|
|
|
|
// Monthly
|
|
case 1:
|
|
$date = $this->product->price_recurr_strict
|
|
? $this->getInvoiceNextAttribute()->endOfMonth()
|
|
: $this->getInvoiceNextAttribute()->addMonth()->subDay();
|
|
break;
|
|
|
|
// Quarterly
|
|
case 2:
|
|
$date = $this->product->price_recurr_strict
|
|
? $this->getInvoiceNextAttribute()->endOfQuarter()
|
|
: $this->getInvoiceNextAttribute()->addQuarter()->subDay();
|
|
break;
|
|
|
|
// Half Yearly
|
|
case 3:
|
|
$date = $this->product->price_recurr_strict
|
|
? $this->getInvoiceNextAttribute()->endOfHalf()
|
|
: $this->getInvoiceNextAttribute()->addQuarter(2)->subDay();
|
|
break;
|
|
|
|
// Yearly
|
|
case 4:
|
|
$date = $this->product->price_recurr_strict
|
|
? $this->getInvoiceNextAttribute()->endOfYear()
|
|
: $this->getInvoiceNextAttribute()->addYear()->subDay();
|
|
break;
|
|
|
|
// Two Yearly
|
|
case 5:
|
|
if (!$this->product->price_recurr_strict)
|
|
$date = $this->getInvoiceNextAttribute()->addYear(2)->subDay();
|
|
else {
|
|
$date = $this->getInvoiceNextAttribute()->addYear(2)->subDay()->endOfYear();
|
|
|
|
if ($date->clone()->addDay()->year % 2) {
|
|
$date = $date->subYear();
|
|
}
|
|
}
|
|
break;
|
|
|
|
// Three Yearly
|
|
// NOTE: price_recurr_strict ignored
|
|
case 6: $date = $this->getInvoiceNextAttribute()->addYear(3)->subDay(); break;
|
|
|
|
default: throw new Exception('Unknown recur_schedule');
|
|
}
|
|
|
|
// If the invoice has an end date, our invoice period shouldnt be greater than that.
|
|
if ($this->date_end AND $this->date_end < $date)
|
|
$date = $this->date_end;
|
|
|
|
return $date;
|
|
}
|
|
|
|
public function getInvoiceNextQuantityAttribute()
|
|
{
|
|
// If we are not rounding to the first day of the cycle, then it is always a full cycle
|
|
if (! $this->product->price_recurr_strict)
|
|
return 1;
|
|
|
|
$n = $this->invoice_next->diff($this->invoice_next_end)->days+1;
|
|
|
|
switch ($this->recur_schedule) {
|
|
// Weekly
|
|
case 0:
|
|
$d = $this->invoice_next->addWeek()->startOfWeek()->diff($this->invoice_next_end->startOfWeek())->days;
|
|
break;
|
|
|
|
// Monthly
|
|
case 1:
|
|
$d = $this->invoice_next->addMonth()->startOfMonth()->diff($this->invoice_next_end->startOfMonth())->days;
|
|
break;
|
|
|
|
// Quarterly
|
|
case 2:
|
|
$d = $this->invoice_next->addQuarter()->startOfQuarter()->diff($this->invoice_next_end->startOfQuarter())->days;
|
|
break;
|
|
|
|
// Half Yearly
|
|
case 3:
|
|
$d = $this->invoice_next->addQuarter(2)->startOfHalf()->diff($this->invoice_next_end->startOfHalf())->days;
|
|
break;
|
|
|
|
// Yearly
|
|
case 4:
|
|
$d = $this->invoice_next->addYear()->startOfYear()->diff($this->invoice_next_end->startOfYear())->days;
|
|
break;
|
|
|
|
// Two Yearly
|
|
case 5:
|
|
$d = $this->invoice_next->addYear(2)->startOfYear()->diff($this->invoice_next_end->subyear(2))->days-1;
|
|
break;
|
|
|
|
// Three Yearly
|
|
case 6:
|
|
$d = $this->invoice_next->addYear(3)->startOfYear()->diff($this->invoice_next_end->subyear(3))->days-1;
|
|
break;
|
|
|
|
default: throw new Exception('Unknown recur_schedule');
|
|
}
|
|
|
|
return round($n/$d,2);
|
|
}
|
|
|
|
/**
|
|
* Get the date that the service has been invoiced to
|
|
*/
|
|
public function getInvoiceToAttribute()
|
|
{
|
|
$result = ($x=$this->invoice_items->filter(function($item) { return $item->item_type === 0;}))->count()
|
|
? $x->last()->date_stop
|
|
: NULL;
|
|
|
|
// For SSL Certificates, the invoice_to date is the expiry date of the Cert
|
|
if (is_null($result) AND $this->type AND $this->type->type == 'ssl' AND $this->type->valid_to)
|
|
return $this->type->valid_to;
|
|
|
|
return $result;
|
|
}
|
|
|
|
/**
|
|
* Service Local ID
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getLIDattribute(): string
|
|
{
|
|
return sprintf('%05s',$this->id);
|
|
}
|
|
|
|
public function getNameAttribute(): string
|
|
{
|
|
return $this->getNameShortAttribute().(($x=$this->getNameDetailAttribute()) ? ': '.$x : '');
|
|
}
|
|
|
|
/**
|
|
* Return the short name for the service.
|
|
*
|
|
* EG:
|
|
* + For ADSL, this would be the phone number,
|
|
* + For Hosting, this would be the domain name, etc
|
|
*/
|
|
public function getNameShortAttribute()
|
|
{
|
|
return $this->type ? $this->type->service_name : $this->id;
|
|
}
|
|
|
|
public function getNameDetailAttribute()
|
|
{
|
|
return $this->type ? $this->type->service_address : $this->id;
|
|
}
|
|
|
|
/**
|
|
* @deprecated see getInvoiceNextAttribute()
|
|
*/
|
|
public function getNextInvoiceAttribute()
|
|
{
|
|
return $this->getInvoiceNextAttribute();
|
|
}
|
|
|
|
public function getOrderInfoNotesAttribute(): ?string
|
|
{
|
|
return $this->getOrderInfoValue('notes');
|
|
}
|
|
|
|
public function getOrderInfoReferenceAttribute(): ?string
|
|
{
|
|
return $this->getOrderInfoValue('reference');
|
|
}
|
|
|
|
/**
|
|
* Work out when this service has been paid to.
|
|
*
|
|
* @todo This might need to be optimised
|
|
*/
|
|
public function getPaidToAttribute()
|
|
{
|
|
foreach ($this->invoices->reverse() as $o) {
|
|
if ($o->due == 0) {
|
|
return $o->items
|
|
->filter(function($item) {
|
|
return $item->item_type === 0;
|
|
})
|
|
->last()
|
|
->date_stop;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the Product's Category for this service
|
|
*
|
|
* @deprecated use product->category directly
|
|
*/
|
|
public function getProductCategoryAttribute(): string
|
|
{
|
|
return $this->product->category;
|
|
}
|
|
|
|
/**
|
|
* Get the Product's Short Name for the service
|
|
*
|
|
* @return string
|
|
* @deprecated use product->name directly
|
|
*/
|
|
public function getProductNameAttribute(): string
|
|
{
|
|
return $this->product->name($this->account->language);
|
|
}
|
|
|
|
public function getRecurScheduleAttribute($value): int
|
|
{
|
|
// If recur_schedule not set, default to 2
|
|
return $value ?? 2;
|
|
}
|
|
|
|
/**
|
|
* @deprecated see getSIDAttribute()
|
|
*/
|
|
public function getServiceIdAttribute(): string
|
|
{
|
|
return $this->getSIDAttribute();
|
|
}
|
|
|
|
/**
|
|
* @deprecated see getUrlUserAttribute()
|
|
*/
|
|
public function getServiceIdUrlAttribute()
|
|
{
|
|
return $this->getUrlUserAttribute();
|
|
}
|
|
|
|
/**
|
|
* @deprecated see getServiceIdAttribute()
|
|
*/
|
|
public function getServiceNumberAttribute()
|
|
{
|
|
return $this->getSIDAttribute();
|
|
}
|
|
|
|
/**
|
|
* Services System ID
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSIDAttribute(): string
|
|
{
|
|
return sprintf('%02s-%04s.%s',$this->site_id,$this->account_id,$this->getLIDattribute());
|
|
}
|
|
|
|
/**
|
|
* Return the service description.
|
|
* For:
|
|
* + Broadband, this is the service address
|
|
* + Domains, blank
|
|
* + Hosting, blank
|
|
* + SSL, blank
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSDescAttribute(): string
|
|
{
|
|
return ($this->type AND $this->type->service_description)
|
|
? $this->type->service_description
|
|
: 'Service Description NOT Defined for :'.($this->type ? $this->type->type : $this->id);
|
|
}
|
|
|
|
/**
|
|
* Return the service name.
|
|
* For:
|
|
* + Broadband, this is the service number
|
|
* + Domains, this is the full domain name
|
|
* + Hosting, this is the full domain name
|
|
* + SSL, this is the DN
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSNameAttribute(): string
|
|
{
|
|
return ($this->type AND $this->type->service_name)
|
|
? $this->type->service_name
|
|
: 'Service Name NOT Defined for :'.($this->type ? $this->type->type : $this->id);
|
|
}
|
|
|
|
/**
|
|
* Return the service product type
|
|
* This is used for view specific details
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getSTypeAttribute(): string
|
|
{
|
|
switch($this->product->model) {
|
|
case 'App\Models\Product\Adsl': return 'broadband';
|
|
default: return $this->type->type;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the Service Status
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getStatusAttribute(): string
|
|
{
|
|
if (! $this->order_status)
|
|
return $this->active ? 'ACTIVE' : 'INACTIVE';
|
|
else
|
|
return $this->order_status;
|
|
}
|
|
|
|
/**
|
|
* Return the detailed order Status, with order reference numbers.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getStatusDetailAttribute(): string
|
|
{
|
|
return in_array($this->order_status,['ORDER-SENT','ORDER-HOLD','ORDERED'])
|
|
? sprintf('%s: <span class="white-space: nowrap"><small><b>#%s</b></small></span>',$this->order_status,Arr::get($this->order_info,'order_reference','Unknown'))
|
|
: '';
|
|
}
|
|
|
|
/**
|
|
* Return a HTML status box
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getStatusHTMLAttribute(): string
|
|
{
|
|
$class = NULL;
|
|
|
|
if ($this->isPending())
|
|
$class = 'badge-warning';
|
|
|
|
else
|
|
switch ($this->status)
|
|
{
|
|
case 'ACTIVE':
|
|
$class = 'badge-success';
|
|
break;
|
|
case 'INACTIVE':
|
|
$class = 'badge-danger';
|
|
break;
|
|
}
|
|
|
|
return $class
|
|
? sprintf('<span class="badge %s">%s</span>',$class,$this->status)
|
|
: $this->status;
|
|
}
|
|
|
|
/**
|
|
* URL used by an admin to administer the record
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getUrlAdminAttribute(): string
|
|
{
|
|
return sprintf('<a href="/a/service/%s">%s</a>',$this->id,$this->service_id);
|
|
}
|
|
|
|
/**
|
|
* URL used by an user to see the record
|
|
*
|
|
* @return string
|
|
*/
|
|
public function getUrlUserAttribute(): string
|
|
{
|
|
return sprintf('<a href="/u/service/%s">%s</a>',$this->id,$this->service_id);
|
|
}
|
|
|
|
/* SETTERS */
|
|
|
|
// @todo is this required?
|
|
public function setDateOrigAttribute($value)
|
|
{
|
|
$this->attributes['date_orig'] = $value->timestamp;
|
|
}
|
|
|
|
// @todo is this required?
|
|
public function setDateLastAttribute($value)
|
|
{
|
|
$this->attributes['date_last'] = $value->timestamp;
|
|
}
|
|
|
|
/* METHODS */
|
|
|
|
/**
|
|
* Processing when service has been ordered.
|
|
*
|
|
* @return bool|null
|
|
* @todo Check
|
|
*/
|
|
private function action_ordered(): ?bool
|
|
{
|
|
// N/A
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Process for an order when status ORDER-ACCEPT stage.
|
|
* This method should have the client confirm/accept the order, if it was placed by a reseller/wholesaler.
|
|
*
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_order_accept(): ?bool
|
|
{
|
|
// @todo TO IMPLEMENT
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Action method when status ORDER_SENT
|
|
* This method redirects to a form, where updating the form will progress to the next stage.
|
|
*
|
|
* @todo Check
|
|
*/
|
|
private function action_order_sent(string $next)
|
|
{
|
|
// We can proceed to the ordered status
|
|
if ($next == 'ORDERED' AND $this->order_info_reference)
|
|
return TRUE;
|
|
|
|
throw new HttpException(301,url('r/service/update',$this->id));
|
|
}
|
|
|
|
/**
|
|
* Action method when status ORDER_SUBMIT
|
|
*
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_order_submit(): ?bool
|
|
{
|
|
// @todo TO IMPLEMENT
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Action when supplier has confirmed provisioning.
|
|
*
|
|
* @param string $next
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_provision_planned(string $next)
|
|
{
|
|
throw new HttpException(301,url('r/service/update',$this->id));
|
|
}
|
|
|
|
/**
|
|
* Process for an order when status SETUP-PAYMENT-WAIT stage.
|
|
* This method should collect any setup fees payment.
|
|
*
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_setup_payment_wait(): ?bool
|
|
{
|
|
// @todo TO IMPLEMENT
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Process for an order when status PAYMENT-CHECK stage.
|
|
* This method should validate any payment details.
|
|
*
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_payment_check(): ?bool
|
|
{
|
|
// @todo TO IMPLEMENT
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Process for an order when status PAYMENT-WAIT stage.
|
|
* This method should collect any service payment details.
|
|
*
|
|
* @return bool
|
|
* @todo Check
|
|
*/
|
|
private function action_payment_wait(): ?bool
|
|
{
|
|
// @todo TO IMPLEMENT
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Work out the next applicable actions for this service status, taking into account the user's role
|
|
*
|
|
* @notes
|
|
* + Clients can only progress 1 step, if they are in the next step.
|
|
* + Resellers/Wholesales can progress to the next Reseller/Wholesaler and any steps in between.
|
|
* @return Collection
|
|
*/
|
|
public function actions(): Collection
|
|
{
|
|
$next = $this->getStageParameters($this->order_status)->get('next');
|
|
return $next
|
|
? $next->map(function($item,$key) {
|
|
$authorized = FALSE;
|
|
|
|
if ($x=Arr::get(self::ACTION_PROGRESS,$key))
|
|
foreach ($item as $role) {
|
|
if ($this->isAuthorised($role)) {
|
|
$authorized = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $authorized ? $x['title'] : NULL;
|
|
})->filter()->sort()
|
|
: collect();
|
|
}
|
|
|
|
private function getOrderInfoValue(string $key): ?string
|
|
{
|
|
return $this->order_info ? $this->order_info->get($key) : NULL;
|
|
}
|
|
|
|
/**
|
|
* Get the stage parameters
|
|
*
|
|
* @param string $stage
|
|
* @return Collection
|
|
*/
|
|
public function getStageParameters(string $stage): Collection
|
|
{
|
|
$result = Arr::get(self::ACTION_PROGRESS,$stage);
|
|
$myrole = array_search(Auth::user()->role(),User::$role_order);
|
|
|
|
// If we have no valid next stage, return an empty collection.
|
|
if (($myrole === FALSE) || (! $result))
|
|
return collect();
|
|
|
|
// Filter the result based on who we are
|
|
$next = collect();
|
|
|
|
if (array_key_exists('next',$result) && count($result['next'])) {
|
|
foreach ($result['next'] as $action => $roles) {
|
|
// Can the current user do this role?
|
|
$cando = FALSE;
|
|
|
|
foreach ($roles as $role) {
|
|
if ($myrole <= array_search($role,User::$role_order)) {
|
|
$cando = TRUE;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ($cando)
|
|
$next->put($action,$roles);
|
|
}
|
|
|
|
$result['next'] = $next;
|
|
}
|
|
|
|
return collect($result);
|
|
}
|
|
|
|
/**
|
|
* Add applicable tax to the cost
|
|
*
|
|
* @todo This needs to be calculated, not fixed at 1.1
|
|
* @param float $value
|
|
* @return float
|
|
*/
|
|
private function addTax(float $value): float
|
|
{
|
|
return round($value*1.1,2);
|
|
}
|
|
|
|
public function invoices_due(): DatabaseCollection
|
|
{
|
|
$this->load('invoice_items.invoice');
|
|
|
|
return $this->invoice_items->filter(function($item) {
|
|
return $item->invoice->due > 0;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Does this service have traffic data to be graphed
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function hasUsage(): bool
|
|
{
|
|
return $this->product->hasUsage();
|
|
}
|
|
|
|
/**
|
|
* Determine if a service is active. It is active, if active=1, or the order_status is not in inactive_status[]
|
|
*
|
|
* @return bool
|
|
* @todo Remove active and have order_status reflect whether active or not
|
|
*/
|
|
public function isActive(): bool
|
|
{
|
|
return $this->active OR ($this->order_status AND ! in_array($this->order_status,$this->inactive_status));
|
|
}
|
|
|
|
/**
|
|
* Determine if the current user has the role for this service
|
|
*
|
|
* @param string $role
|
|
* @return bool
|
|
*/
|
|
public function isAuthorised(string $role): bool
|
|
{
|
|
switch(Auth::user()->role()) {
|
|
// Wholesalers are site admins, they can see everything
|
|
case 'wholesaler':
|
|
return TRUE;
|
|
|
|
case 'reseller':
|
|
switch ($role) {
|
|
case 'wholesaler':
|
|
return FALSE;
|
|
|
|
// Check service is in the resellers/customers list
|
|
case 'reseller':
|
|
case 'customer':
|
|
return TRUE;
|
|
|
|
default:
|
|
abort(500,'Unknown role for reseller: '.$role);
|
|
}
|
|
|
|
case 'customer':
|
|
switch ($role) {
|
|
case 'reseller':
|
|
case 'wholesaler':
|
|
return FALSE;
|
|
|
|
// Check service is in the customers list
|
|
case 'customer':
|
|
return TRUE;
|
|
|
|
default:
|
|
abort(500,'Unknown role for customer: '.$role);
|
|
}
|
|
|
|
default:
|
|
abort(500,'Unknown user role: ',Auth::user()->role());
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Do we bill for this service
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isBilled(): bool
|
|
{
|
|
return ! ($this->external_billing && $this->suspend_billing);
|
|
}
|
|
|
|
/**
|
|
* Should this service be invoiced soon
|
|
*
|
|
* @todo get the number of days from account setup
|
|
* @todo Use self::isBilled();
|
|
* @return bool
|
|
*/
|
|
public function isInvoiceDueSoon($days=30): bool
|
|
{
|
|
return (! $this->external_billing) AND (! $this->suspend_billing) AND $this->getInvoiceNextAttribute()->lessThan(now()->addDays($days));
|
|
}
|
|
|
|
/**
|
|
* Identify if a service is being ordered
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function isPending(): bool
|
|
{
|
|
return ! $this->active
|
|
AND ! is_null($this->order_status)
|
|
AND ! in_array($this->order_status,array_merge($this->inactive_status,['INACTIVE']));
|
|
}
|
|
|
|
/**
|
|
* Generate a collection of invoice_item objects that will be billed for the next invoice
|
|
*
|
|
* @param bool $future Next item to be billed (not in the next x days)
|
|
* @return Collection
|
|
* @throws Exception
|
|
* @todo Use self::isBilled();
|
|
*/
|
|
public function next_invoice_items(bool $future,Carbon $billdate=NULL): Collection
|
|
{
|
|
if ($this->wasCancelled() OR $this->suspend_billing OR $this->external_billing OR (! $future AND ! $this->active))
|
|
return collect();
|
|
|
|
if (is_null($billdate))
|
|
$billdate = Carbon::now()->addDays(30);
|
|
|
|
// If pending, add any connection charges
|
|
// Connection charges are only charged once
|
|
if ((! $this->invoice_items->filter(function($item) { return $item->item_type==4; })->sum('total'))
|
|
AND ($this->isPending() OR is_null($this->invoice_to))
|
|
AND $this->product->price($this->recur_schedule,'price_setup'))
|
|
{
|
|
$o = new InvoiceItem;
|
|
|
|
$o->active = TRUE;
|
|
$o->service_id = $this->id;
|
|
$o->product_id = $this->product_id;
|
|
$o->item_type = 4; // @todo change to const or something
|
|
$o->price_base = $this->product->price($this->recur_schedule,'price_setup'); // @todo change to a method in this class
|
|
//$o->recurring_schedule = $this->recur_schedule;
|
|
$o->date_start = $this->invoice_next;
|
|
$o->date_stop = $this->invoice_next;
|
|
$o->quantity = 1;
|
|
$o->site_id = 1; // @todo
|
|
|
|
$o->addTaxes($this->account->country->taxes);
|
|
$this->invoice_items->push($o);
|
|
}
|
|
|
|
// If the service is active, there will be service charges
|
|
if ((! $this->invoice_items->filter(function($item) { return $item->item_type==0 AND ! $item->exists; })->count())
|
|
AND ($this->active OR $this->isPending())
|
|
AND (
|
|
(($future == TRUE) AND $this->invoice_next < $this->invoice_next_end) OR
|
|
(($future == FALSE) AND ($this->invoice_to < ($this->date_end ?: $billdate)))
|
|
))
|
|
{
|
|
do {
|
|
$o = new InvoiceItem;
|
|
$o->active = TRUE;
|
|
$o->service_id = $this->id;
|
|
$o->product_id = $this->product_id;
|
|
$o->item_type = 0;
|
|
$o->price_base = is_null($this->price)
|
|
? (is_null($this->price_override) ? $this->product->price($this->recur_schedule) : $this->price_override)
|
|
: $this->price; // @todo change to a method in this class
|
|
$o->recurring_schedule = $this->recur_schedule;
|
|
$o->date_start = $this->invoice_next;
|
|
$o->date_stop = $this->invoice_next_end;
|
|
$o->quantity = $this->invoice_next_quantity;
|
|
$o->site_id = 1; // @todo
|
|
|
|
$o->addTaxes($this->account->country->taxes);
|
|
$this->invoice_items->push($o);
|
|
} while ($future == FALSE AND ($this->invoice_to < ($this->date_end ?: $billdate)));
|
|
}
|
|
|
|
// Add additional charges
|
|
if ((($future == TRUE) OR (($future == FALSE) AND ($this->invoice_to >= $billdate)))
|
|
AND ! $this->invoice_items->filter(function($item) { return $item->module_id == 30 AND ! $item->exists; })->count())
|
|
{
|
|
foreach ($this->charges->filter(function($item) { return ! $item->processed; }) as $oo) {
|
|
$o = new InvoiceItem;
|
|
$o->active = TRUE;
|
|
$o->service_id = $oo->service_id;
|
|
$o->product_id = $this->product_id;
|
|
$o->quantity = $oo->quantity;
|
|
$o->item_type = $oo->type;
|
|
$o->price_base = $oo->amount;
|
|
$o->date_start = $oo->date_charge;
|
|
$o->date_stop = $oo->date_charge;
|
|
$o->module_id = 30; // @todo This shouldnt be hard coded
|
|
$o->module_ref = $oo->id;
|
|
$o->site_id = 1; // @todo
|
|
|
|
$o->addTaxes($this->account->country->taxes);
|
|
$this->invoice_items->push($o);
|
|
}
|
|
}
|
|
|
|
return $this->invoice_items->filter(function($item) { return ! $item->exists; });
|
|
}
|
|
|
|
/**
|
|
* This function will return the associated service model for the product type
|
|
* @deprecated use $this->type
|
|
*/
|
|
private function ServicePlugin()
|
|
{
|
|
// @todo: All services should be linked to a product. This might require data cleaning for old services not linked to a product.
|
|
if (! is_object($this->product))
|
|
return NULL;
|
|
|
|
switch ($this->product->prod_plugin_file)
|
|
{
|
|
case 'ADSL': return $this->service_adsl;
|
|
case 'DOMAIN': return $this->service_domain;
|
|
case 'HOST': return $this->service_host;
|
|
case 'SSL': return $this->service_ssl;
|
|
case 'VOIP': return $this->service_voip;
|
|
|
|
default: return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Store order info details
|
|
*
|
|
* @param string $key
|
|
* @param string $value
|
|
*/
|
|
public function setOrderInfo(string $key,?string $value): void
|
|
{
|
|
$x = is_null($this->order_info) ? collect() : $this->order_info;
|
|
$x->put($key,$value);
|
|
|
|
$this->order_info = $x;
|
|
}
|
|
|
|
/**
|
|
* Service that was cancelled or never provisioned
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function wasCancelled(): bool
|
|
{
|
|
return in_array($this->order_status,$this->inactive_status);
|
|
}
|
|
}
|