clrghouz/app/Models/Address.php

852 lines
21 KiB
PHP
Raw Normal View History

<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
2021-09-06 13:39:32 +00:00
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use App\Classes\FTN\{Message,Packet};
use App\Http\Controllers\DomainController;
2022-01-01 05:59:35 +00:00
use App\Traits\ScopeActive;
class Address extends Model
{
private const LOGKEY = 'MA-';
2022-01-01 05:59:35 +00:00
use ScopeActive,SoftDeletes;
protected $with = ['zone'];
// http://ftsc.org/docs/frl-1028.002
public const ftn_regex = '([0-9]+):([0-9]+)/([0-9]+)(\.([0-9]+))?(@([a-z0-9\-_~]{0,8}))?';
public const NODE_ZC = 1<<0; // Zone
public const NODE_RC = 1<<1; // Region
public const NODE_NC = 1<<2; // Host
public const NODE_HC = 1<<3; // Hub
public const NODE_ACTIVE = 1<<4; // Node
public const NODE_PVT = 1<<5; // Pvt
public const NODE_HOLD = 1<<6; // Hold
public const NODE_DOWN = 1<<7; // Down
public const NODE_POINT = 1<<8; // Point
public const NODE_UNKNOWN = 1<<15; // Unknown
public static function boot()
{
parent::boot();
// For indexes when deleting, we need to change active to FALSE
static::softDeleted(function($model) {
Log::debug(sprintf('%s:Deleting [%d], updating active to FALSE',self::LOGKEY,$model->id));
$model->active = FALSE;
$model->save();
});
}
2023-07-29 03:17:36 +00:00
protected $visible = ['zone_id','region_id','host_id','node_id','point_id','security'];
/* SCOPES */
public function scopeActiveFTN($query)
{
return $query->select($this->getTable().'.*')
->join('zones',['zones.id'=>'addresses.zone_id'])
->join('domains',['domains.id'=>'zones.domain_id'])
->where('addresses.active',TRUE)
->where('zones.active',TRUE)
->where('domains.active',TRUE)
->orderBy('domains.name')
->FTNorder();
}
public function scopeTrashed($query)
{
return $query->select($this->getTable().'.*')
->withTrashed()
->FTNorder();
}
public function scopeFTNOrder($query)
{
return $query
->orderBy('region_id')
->orderBy('host_id')
->orderBy('node_id')
->orderBy('point_id');
}
/* RELATIONS */
/**
* Find children dependent on this record
*/
2021-07-02 13:19:50 +00:00
public function children()
{
// We have no session data for this address, by definition it has no children
if (! $this->session('sespass'))
return $this->hasMany(self::class,'id','void');
2021-08-09 13:35:22 +00:00
if (! $this->session('default')) {
switch ($this->role) {
case self::NODE_ZC:
2021-08-09 13:35:22 +00:00
$children = self::select('addresses.*')
->where('zone_id',$this->zone_id);
2021-08-09 13:35:22 +00:00
break;
case self::NODE_RC:
2021-08-09 13:35:22 +00:00
$children = self::select('addresses.*')
->where('zone_id',$this->zone_id)
->where('region_id',$this->region_id);
2021-08-09 13:35:22 +00:00
break;
case self::NODE_NC:
2021-08-09 13:35:22 +00:00
$children = self::select('addresses.*')
->where('zone_id',$this->zone_id)
->where('region_id',$this->region_id)
->where('host_id',$this->host_id);
2021-08-09 13:35:22 +00:00
break;
case self::NODE_HC:
2021-08-09 13:35:22 +00:00
// Identify our children.
$children = self::select('addresses.*')
2023-07-30 01:49:21 +00:00
->where('zone_id',$this->zone_id)
->where('region_id',$this->region_id)
2021-08-09 13:35:22 +00:00
->where('hub_id',$this->id);
2021-08-09 13:35:22 +00:00
break;
case self::NODE_UNKNOWN:
case self::NODE_ACTIVE:
case self::NODE_POINT:
case self::NODE_PVT:
2021-08-09 13:35:22 +00:00
// Nodes dont have children, but must return a relationship instance
return $this->hasOne(self::class,NULL,'void');
2021-08-09 13:35:22 +00:00
default:
2023-06-27 07:39:11 +00:00
throw new \Exception('Unknown role: '.serialize($this->role));
2021-08-09 13:35:22 +00:00
}
2021-08-09 13:35:22 +00:00
} else {
$children = self::select('addresses.*')
->where('zone_id',$this->zone_id);
}
2023-07-30 01:49:21 +00:00
// I cant have myself as a child, and have a high role than me
$children->where('id','<>',$this->id)
->where('role','>',$this->role);
// Remove any children that we have session details for (SAME AS HC)
$sessions = self::select('hubnodes.*')
->join('system_zone',['system_zone.system_id'=>'addresses.system_id','system_zone.zone_id'=>'addresses.zone_id'])
->join('addresses as hubnodes',['hubnodes.zone_id'=>'addresses.zone_id','hubnodes.id'=>'addresses.id'])
->where('addresses.zone_id',$this->zone_id)
->where('addresses.system_id','<>',$this->system_id)
->whereIN('addresses.system_id',$children->get()->pluck('system_id'));
// For each of the session, identify their children
$session_kids = collect();
foreach ($sessions->get() as $so)
$session_kids = $session_kids->merge(($x=$so->children) ? $x->pluck('id') : []);
// ZC's receive all mail, except for defined nodes, and defined hubs/hosts/rcs
return $this->hasMany(self::class,'zone_id','zone_id')
->whereIn('id',$children->get()->pluck('id')->toArray())
->whereNotIn('id',$sessions->get()->pluck('id')->toArray())
->whereNotIn('id',$session_kids->toArray())
->where('system_id','<>',$this->system_id)
->select('addresses.*')
->orderBy('region_id')
->orderBy('host_id')
->orderBy('node_id')
->orderBy('point_id')
->with(['zone.domain']);
}
/**
* Echoareas this address is subscribed to
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
2021-08-25 12:13:49 +00:00
public function echoareas()
{
return $this->belongsToMany(Echoarea::class)
->withPivot(['subscribed']);
}
/**
* Echomails that this address has seen
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
public function echomails()
{
return $this->belongsToMany(Echomail::class,'echomail_seenby')
->withPivot(['export_at','sent_at','sent_pkt']);
2022-11-01 11:24:36 +00:00
}
2022-11-25 10:44:03 +00:00
public function echomail_from()
{
return $this->hasMany(Echomail::class,'fftn_id','id');
}
2022-11-01 11:24:36 +00:00
/**
* Files that this address has seen
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
public function files()
{
return $this->belongsToMany(File::class,'file_seenby')
->withPivot(['sent_at','export_at']);
}
/**
* Echoareas this address is subscribed to
*
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
public function fileareas()
{
return $this->belongsToMany(Filearea::class)
->withPivot(['subscribed']);
}
/**
* Who we send this systems mail to.
*
* @return Address|null
2023-06-27 07:39:11 +00:00
* @throws \Exception
*/
public function parent(): ?Address
{
// If we are have session password, then we dont have a parent
if ($this->session('sespass'))
return $this;
switch ($this->role) {
2021-08-09 13:35:22 +00:00
// ZCs dont have parents, but we may have a default
case self::NODE_ZC:
2021-08-09 13:35:22 +00:00
if (($x=$this->zone->systems->where('pivot.default',TRUE))->count())
return $x->first()->match($this->zone,255)->first();
2021-08-09 13:35:22 +00:00
else
return NULL;
// RC
case self::NODE_RC:
$parent = self::where('zone_id',$this->zone_id)
->where('region_id',0)
->where('host_id',0)
->where('node_id',0)
->single();
break;
// Hosts
case self::NODE_NC:
// See if we have a RC
$parent = self::where('zone_id',$this->zone_id)
->where('region_id',$this->region_id)
->where('host_id',0)
->where('node_id',0)
->single();
if (! $parent) {
// See if we have a RC
$parent = self::where('zone_id',$this->zone_id)
->where('region_id',0)
->where('host_id',0)
->where('node_id',0)
->single();
}
break;
// Hubs
case self::NODE_HC:
// Normal Nodes
case self::NODE_ACTIVE:
// If we are a child of a hub, then check our hub
$parent = (($this->hub_id)
? self::where('id',$this->hub_id)
: self::where('zone_id',$this->zone_id)
->where('region_id',$this->region_id)
->where('host_id',$this->host_id)
->where('node_id',0))
->where('role','<',$this->role)
->single();
break;
case self::NODE_UNKNOWN:
case self::NODE_POINT:
case self::NODE_DOWN:
// @todo Points - if the boss is defined, we should return it.
return NULL;
default:
2023-07-26 09:44:07 +00:00
throw new \Exception(sprintf('Unknown role: %s (%d)',serialize($this->role),$this->id));
}
return $parent?->parent();
2021-07-02 13:19:50 +00:00
}
public function system()
{
return $this->belongsTo(System::class);
}
public function zone()
{
return $this->belongsTo(Zone::class);
}
/* ATTRIBUTES */
/**
* Return if this address is active
*
* @param bool $value
* @return bool
*/
public function getActiveAttribute(bool $value): bool
{
2023-07-29 03:17:36 +00:00
return $value && $this->getActiveDomainAttribute();
}
public function getActiveDomainAttribute(): bool
{
return $this->zone->active && $this->zone->domain->active;
}
/**
* Render the node name in full 5D
*
* @return string
*/
public function getFTNAttribute(): string
{
2021-06-26 01:48:55 +00:00
return sprintf('%s@%s',$this->getFTN4DAttribute(),$this->zone->domain->name);
}
2021-08-29 01:48:27 +00:00
public function getFTN2DAttribute(): string
{
return sprintf('%d/%d',$this->host_id ?: $this->region_id,$this->node_id);
}
public function getFTN3DAttribute(): string
2021-06-26 01:48:55 +00:00
{
return sprintf('%d:%s',$this->zone->zone_id,$this->getFTN2DAttribute());
2021-06-26 01:48:55 +00:00
}
public function getFTN4DAttribute(): string
2021-06-26 01:48:55 +00:00
{
return sprintf('%s.%d',$this->getFTN3DAttribute(),$this->point_id);
}
public function getRoleNameAttribute(): string
{
switch ($this->role) {
case self::NODE_ZC:
return 'ZC';
case self::NODE_RC:
return 'RC';
case self::NODE_NC:
return 'NC';
case self::NODE_HC:
return 'HUB';
case self::NODE_ACTIVE:
return 'NODE';
case self::NODE_POINT:
return 'POINT';
default:
return '?';
}
}
/* METHODS */
/**
* Find a record in the DB for a node string, eg: 10:1/1.0
*
* @param string $address
* @param bool $create
* @param System|null $so
* @param bool $trashed
2021-06-29 10:43:29 +00:00
* @return Address|null
2023-06-27 07:39:11 +00:00
* @throws \Exception
*/
public static function findFTN(string $address,bool $create=FALSE,System $so=NULL,bool $trashed=FALSE): ?self
{
$ftn = self::parseFTN($address);
// Are we looking for a region address
if (($ftn['f'] === 0) && $ftn['p'] === 0) {
$o = (new self)
->select('addresses.*')
->join('zones',['zones.id'=>'addresses.zone_id'])
->join('domains',['domains.id'=>'zones.domain_id'])
->when($trashed,function($query) {
$query->trashed();
},function($query) {
$query->active();
})
->where('zones.zone_id',$ftn['z'])
->where(function($q) use ($ftn) {
return $q
->where(function($q) use ($ftn) {
return $q->where('region_id',$ftn['n'])
->where('host_id',$ftn['n']);
});
})
->where('node_id',$ftn['f'])
->where('point_id',$ftn['p'])
->when($ftn['d'],function($query,$domain) {
$query->where('domains.name',$domain);
})
->when((! $ftn['d']),function($query) {
2021-08-16 12:26:33 +00:00
$query->where('zones.default',TRUE);
})
->single();
if ($o && $o->system->active)
return $o;
}
// Look for a normal address
$o = ($x=(new self)
->select('addresses.*')
->join('zones',['zones.id'=>'addresses.zone_id'])
->join('domains',['domains.id'=>'zones.domain_id'])
->when($trashed,function($query) {
$query->trashed();
},function($query) {
$query->active();
})
2021-06-29 10:43:29 +00:00
->where('zones.zone_id',$ftn['z'])
->where(function($q) use ($ftn) {
return $q->where(function($qq) use ($ftn) {
return $qq
->where('region_id',$ftn['n'])
->where('host_id',$ftn['n']);
})
->orWhere(function($qq) use ($ftn) {
return $qq
->where('host_id',$ftn['n']);
});
})
->where('node_id',$ftn['f'])
->where('point_id',$ftn['p'])
2021-06-29 10:43:29 +00:00
->when($ftn['d'],function($query,$domain) {
$query->where('domains.name',$domain);
})
2021-06-29 10:43:29 +00:00
->when((! $ftn['d']),function($query) {
2021-08-16 12:26:33 +00:00
$query->where('zones.default',TRUE);
}))
->single();
if ($o && $o->system->active)
return $o;
// Check and see if we are a flattened domain, our address might be available with a different zone.
if ($ftn['p'] === 0) {
if ($ftn['d'])
$do = Domain::where(['name'=>$ftn['d']])->single();
else {
$zo = Zone::where('zone_id',$ftn['z'])->where('default',TRUE)->single();
$do = $zo?->domain;
}
if ($do && $do->flatten) {
$o = self::findZone($do,$ftn['n'],$ftn['f'],$ftn['p'],$trashed);
if ($o && $o->system->active)
return $o;
}
}
if ($create) {
if (! $so)
2023-06-27 07:39:11 +00:00
throw new \Exception(sprintf('%s:AKA create requested for [%s], but system not provided',self::LOGKEY,$address));
if (! $ftn['d']) {
Log::alert(sprintf('%s:! Refusing to create address [%s] no domain available',self::LOGKEY,$address));
return NULL;
}
Log::debug(sprintf('%s:Creating AKA [%s] for [%s]',self::LOGKEY,$address,$so->name));
// Check Domain exists
Domain::unguard();
$do = Domain::singleOrNew(['name'=>$ftn['d']]);
Domain::reguard();
if (! $do->exists) {
$do->public = TRUE;
$do->active = TRUE;
$do->notes = 'Auto created';
$do->save();
}
// Create zone
Zone::unguard();
$zo = Zone::singleOrNew(['domain_id'=>$do->id,'zone_id'=>$ftn['z']]);
Zone::reguard();
if (! $zo->exists) {
$zo->active = TRUE;
$zo->notes = 'Auto created';
$zo->system_id = System::where('name','Discovered System')->single()->id;
$do->zones()->save($zo);
}
if (! $zo->active || ! $do->active) {
Log::alert(sprintf('%s:! Refusing to create address [%s] in disabled zone or domain',self::LOGKEY,$address));
return NULL;
}
// Create Address, assigned to $so
$o = new self;
$o->active = TRUE;
$o->zone_id = $zo->id;
$o->region_id = 0;
$o->host_id = $ftn['n'];
$o->node_id = $ftn['f'];
$o->point_id = $ftn['p'];
$o->role = $ftn['p'] ? self::NODE_POINT : self::NODE_UNKNOWN;
try {
$so->addresses()->save($o);
} catch (\Exception $e) {
Log::error(sprintf('%s:! ERROR creating address [%s] (%s)',self::LOGKEY,$x->toSql(),get_class($e)),['bindings'=>$x->getBindings()]);
return NULL;
}
}
return ($o && $o->system->active) ? $o : NULL;
}
/**
* This is to find an address for a domain (like fidonet), which is technically 2D even though it uses multiple zones.
*
* This was implemented to identify seenby and path kludges
*
* @param Domain $do
* @param int $host
* @param int $node
* @param bool $trashed
* @return self|null
* @throws \Exception
*/
public static function findZone(Domain $do,int $host,int $node,int $point,bool $trashed=FALSE): ?self
{
if (! $do->flatten)
throw new \Exception(sprintf('Domain is not set with flatten: %d',$do->id));
$zones = $do->zones->pluck('zone_id');
$o = (new self)
->select('addresses.*')
->join('zones',['zones.id'=>'addresses.zone_id'])
->when($trashed,function($query) {
$query->trashed();
},function($query) {
$query->active();
})
->whereIN('zones.zone_id',$zones)
->where(function($q) use ($host) {
return $q
->where(function($q) use ($host) {
return $q->where('region_id',$host)
->where('host_id',$host);
})
->orWhere('host_id',$host);
})
->where('node_id',$node)
->where('point_id',$point)
->where('zones.domain_id',$do->id)
->single();
return $o;
}
/**
* Create an activation code for this address
*
* @param User $uo
* @return string
*/
public function set_activation(User $uo): string
{
return sprintf('%x:%s',
$this->id,
substr(md5(sprintf('%d:%x',$uo->id,timew($this->updated_at))),0,10)
);
}
/**
* Check the user's activation code for this address is correct
*
* @param User $uo
* @param string $code
* @return bool
*/
public function check_activation(User $uo,string $code): bool
{
try {
Log::info(sprintf('%s:Checking Activation code [%s] is valid for user [%d]',self::LOGKEY,$code,$uo->id));
2023-06-27 07:39:11 +00:00
return ($code === $this->set_activation($uo));
} catch (\Exception $e) {
Log::error(sprintf('%s:! Activation code [%s] invalid for user [%d]',self::LOGKEY,$code,$uo->id));
return FALSE;
}
}
2022-01-01 05:59:35 +00:00
/**
2022-11-01 11:24:36 +00:00
* Echomail waiting to be sent to this system
2022-01-01 05:59:35 +00:00
*
* @return Collection
*/
public function echomailWaiting(): Collection
{
return $this->echomails()
->whereNull('sent_at')
->whereNotNull('export_at')
2022-01-01 05:59:35 +00:00
->get();
}
2022-11-01 11:24:36 +00:00
/**
* Files waiting to be sent to this system
*
* @return Collection
*/
public function filesWaiting(): Collection
{
return $this->files()
->whereNull('sent_at')
->whereNotNull('export_at')
2022-11-01 11:24:36 +00:00
->get();
}
/**
* Get echomail for this node
*
* @param bool $update
* @param Collection|null $echomail
* @return Packet|null
*/
public function getEchomail(bool $update=TRUE,Collection $echomail=NULL): ?Packet
{
2021-09-06 13:39:32 +00:00
$pkt = NULL;
if ($echomail)
return $this->getPacket($echomail);
2021-09-06 13:39:32 +00:00
$s = Setup::findOrFail(config('app.id'));
2022-01-01 05:59:35 +00:00
if (($x=$this->echomailWaiting())
->count())
{
// Limit to max messages
Log::info(sprintf('%s:= Got [%d] echomails for [%s] for sending',self::LOGKEY,$x->count(),$this->ftn));
2023-07-05 12:42:59 +00:00
if ($x->count() > $s->msgs_pkt) {
$x = $x->take($s->msgs_pkt);
Log::alert(sprintf('%s:= Only sending [%d] echomails for [%s]',self::LOGKEY,$x->count(),$this->ftn));
}
2022-01-01 05:59:35 +00:00
$pkt = $this->getPacket($x);
2021-09-06 13:39:32 +00:00
if ($pkt && $pkt->count() && $update)
DB::table('echomail_seenby')
->whereIn('echomail_id',$x->pluck('id'))
->where('address_id',$this->id)
->whereNull('sent_at')
->whereNotNull('export_at')
->update(['sent_pkt'=>$pkt->name]);
}
2021-09-06 13:39:32 +00:00
return $pkt;
}
/**
* Get files for this node (including it's children)
*
* @param bool $update
* @return Collection
* @deprecated use filesWaiting() directly
*/
public function getFiles(bool $update=TRUE): Collection
{
return $this->filesWaiting();
}
/**
* Get netmail for this node (including it's children)
2021-07-17 05:48:07 +00:00
*
* @param bool $update
2021-07-17 05:48:07 +00:00
* @return Packet|null
*/
public function getNetmail(bool $update=FALSE): ?Packet
{
2022-01-01 05:59:35 +00:00
$pkt = NULL;
$s = Setup::findOrFail(config('app.id'));
if (($x=$this->netmailAlertWaiting())->count()) {
Log::debug(sprintf('%s:= Packaging [%d] netmail alerts to [%s]',self::LOGKEY,$x->count(),$this->ftn));
$passpos = strpos($x->last()->subject,':');
if ($passpos > 8)
Log::alert(sprintf('%s:! Password would be greater than 8 chars? [%d]',self::LOGKEY,$passpos));
$pkt = $this->getPacket($x,substr($x->last()->subject,0,$passpos));
if ($pkt && $pkt->count() && $update)
DB::table('netmails')
->whereIn('id',$x->pluck('id'))
->update(['sent_pkt'=>$pkt->name]);
return $pkt;
}
2022-01-01 05:59:35 +00:00
if (($x=$this->netmailWaiting())
->count())
{
Log::debug(sprintf('%s:= Got [%d] netmails for [%s] for sending',self::LOGKEY,$x->count(),$this->ftn));
if ($x->count() > $s->msgs_pkt) {
$x = $x->take($s->msgs_pkt);
Log::alert(sprintf('%s:= Only sending [%d] netmails for [%s]',self::LOGKEY,$x->count(),$this->ftn));
}
2022-01-01 05:59:35 +00:00
$pkt = $this->getPacket($x);
if ($pkt && $pkt->count() && $update)
DB::table('netmails')
->whereIn('id',$x->pluck('id'))
->update(['sent_pkt'=>$pkt->name]);
}
2022-01-01 05:59:35 +00:00
return $pkt;
}
2021-07-17 05:48:07 +00:00
/**
* Return a packet of mail
*
* @param Collection $msgs of message models (Echomail/Netmail)
* @param string|null $passwd Override password used in packet
* @return Packet|null
*/
public function getPacket(Collection $msgs,string $passwd=NULL): ?Packet
{
$s = Setup::findOrFail(config('app.id'));
$ao = $s->system->match($this->zone)->first();
// If we dont match on the address, we cannot pack mail for that system
if (! $ao)
return NULL;
// Get packet type
$type = collect(Packet::PACKET_TYPES)->get($this->system->pkt_type ?: config('app.default_pkt'));
$o = new $type;
$o->addressHeader($ao,$this,$passwd);
// $oo = Netmail/Echomail Model
$c = 0;
foreach ($msgs as $oo) {
// Only bundle up to max messages
2023-07-05 12:42:59 +00:00
if (++$c > $s->msgs_pkt)
break;
$o->addMail($oo->packet($this,$passwd));
}
return $o;
}
2022-01-01 05:59:35 +00:00
/**
* Netmail waiting to be sent to this system
*
* @return Collection
*/
public function netmailWaiting(): Collection
{
return Netmail::whereIn('tftn_id',(($x=$this->children) ? $x->pluck('id') : collect())->push($this->id))
->where(function($query) {
return $query->whereRaw(sprintf('(flags & %d) > 0',Message::FLAG_INTRANSIT))
->orWhereRaw(sprintf('(flags & %d) > 0',Message::FLAG_LOCAL));
})
->whereRaw(sprintf('(flags & %d) = 0',Message::FLAG_SENT))
2022-01-01 05:59:35 +00:00
->whereNull('sent_at')
->get();
}
/**
* Netmail alerts waiting to be sent to this system
*
* @return Collection
*/
public function netmailAlertWaiting(): Collection
{
return Netmail::where('tftn_id',$this->id)
->whereRaw(sprintf('(flags & %d) > 0',Message::FLAG_LOCAL))
->whereRaw(sprintf('(flags & %d) > 0',Message::FLAG_PKTPASSWD))
->whereRaw(sprintf('(flags & %d) = 0',Message::FLAG_SENT))
->whereNull('sent_at')
->get();
}
2021-06-29 10:43:29 +00:00
/**
*
2021-06-29 10:43:29 +00:00
* Parse a string and split it out as an FTN array
*
* @param string $ftn
* @return array
2023-06-27 07:39:11 +00:00
* @throws \Exception
2021-06-29 10:43:29 +00:00
*/
public static function parseFTN(string $ftn): array
{
if (! preg_match(sprintf('#^%s$#',self::ftn_regex),strtolower($ftn),$matches))
2023-06-27 07:39:11 +00:00
throw new \Exception('Invalid FTN: '.$ftn);
2021-06-29 10:43:29 +00:00
// Check our numbers are correct.
foreach ([1,2,3] as $i) {
if ((! is_numeric($matches[$i])) || ($matches[$i] > DomainController::NUMBER_MAX))
2023-06-27 07:39:11 +00:00
throw new \Exception('Invalid FTN: '.$ftn);
2021-06-29 10:43:29 +00:00
}
if (isset($matches[5]) AND ((! is_numeric($matches[$i])) || ($matches[5] > DomainController::NUMBER_MAX)))
2023-06-27 07:39:11 +00:00
throw new \Exception('Invalid FTN: '.$ftn);
2021-06-29 10:43:29 +00:00
return [
'z'=>(int)$matches[1],
'n'=>(int)$matches[2],
'f'=>(int)$matches[3],
'p'=>isset($matches[5]) && $matches[5] ? (int)$matches[5] : 0,
'd'=>$matches[7] ?? NULL
];
}
/**
* Retrieve the address session details/passwords
*
* @param string $type
* @return string|null
*/
public function session(string $type): ?string
{
return ($this->exists && ($x=$this->system->sessions->where('id',$this->zone_id)->first())) ? $x->pivot->{$type} : NULL;
}
}