/var/www/hkosl.com/imusiccircle/webadmin/libraies/illuminate/database/Illuminate/Database/Eloquent/Relations/MorphOneOrMany.php


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
<?php namespace Illuminate\Database\Eloquent\Relations;

use 
Illuminate\Database\Eloquent\Model;
use 
Illuminate\Database\Eloquent\Builder;

abstract class 
MorphOneOrMany extends HasOneOrMany {

    
/**
     * The foreign key type for the relationship.
     *
     * @var string
     */
    
protected $morphType;

    
/**
     * The class name of the parent model.
     *
     * @var string
     */
    
protected $morphClass;

    
/**
     * Create a new has many relationship instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @param  string  $type
     * @param  string  $id
     * @param  string  $localKey
     * @param  string  $morphClass
     * @return void
     */
    
public function __construct(Builder $queryModel $parent$type$id$localKey)
    {
        
$this->morphType $type;

        
$this->morphClass $parent->getMorphClass();

        
parent::__construct($query$parent$id$localKey);
    }

    
/**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    
public function addConstraints()
    {
        if (static::
$constraints)
        {
            
parent::addConstraints();

            
$this->query->where($this->morphType$this->morphClass);
        }
    }

    
/**
     * Add the constraints for a relationship count query.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Builder  $parent
     * @return \Illuminate\Database\Eloquent\Builder
     */
    
public function getRelationCountQuery(Builder $queryBuilder $parent)
    {
        
$query parent::getRelationCountQuery($query$parent);

        return 
$query->where($this->morphType$this->morphClass);
    }

    
/**
     * Set the constraints for an eager load of the relation.
     *
     * @param  array  $models
     * @return void
     */
    
public function addEagerConstraints(array $models)
    {
        
parent::addEagerConstraints($models);

        
$this->query->where($this->morphType$this->morphClass);
    }

    
/**
     * Attach a model instance to the parent model.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $model
     * @return \Illuminate\Database\Eloquent\Model
     */
    
public function save(Model $model)
    {
        
$model->setAttribute($this->getPlainMorphType(), $this->morphClass);

        return 
parent::save($model);
    }

    
/**
     * Create a new instance of the related model.
     *
     * @param  array  $attributes
     * @return \Illuminate\Database\Eloquent\Model
     */
    
public function create(array $attributes)
    {
        
$foreign $this->getForeignAttributesForCreate();

        
// When saving a polymorphic relationship, we need to set not only the foreign
        // key, but also the foreign key type, which is typically the class name of
        // the parent model. This makes the polymorphic item unique in the table.
        
$attributes array_merge($attributes$foreign);

        
$instance $this->related->newInstance($attributes);

        
$instance->save();

        return 
$instance;
    }

    
/**
     * Get the foreign ID and type for creating a related model.
     *
     * @return array
     */
    
protected function getForeignAttributesForCreate()
    {
        
$foreign = array($this->getPlainForeignKey() => $this->getParentKey());

        
$foreign[last(explode('.'$this->morphType))] = $this->morphClass;

        return 
$foreign;
    }

    
/**
     * Get the foreign key "type" name.
     *
     * @return string
     */
    
public function getMorphType()
    {
        return 
$this->morphType;
    }

    
/**
     * Get the plain morph type name without the table.
     *
     * @return string
     */
    
public function getPlainMorphType()
    {
        return 
last(explode('.'$this->morphType));
    }

    
/**
     * Get the class name of the parent model.
     *
     * @return string
     */
    
public function getMorphClass()
    {
        return 
$this->morphClass;
    }

}