/var/www/hkosl.com/imusiccircle/webadmin/libraies/illuminate/database/Illuminate/Database/Eloquent/Relations/Relation.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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
<?php namespace Illuminate\Database\Eloquent\Relations;

use 
Closure;
use 
Illuminate\Database\Eloquent\Model;
use 
Illuminate\Database\Eloquent\Builder;
use 
Illuminate\Database\Query\Expression;
use 
Illuminate\Database\Eloquent\Collection;

abstract class 
Relation {

    
/**
     * The Eloquent query builder instance.
     *
     * @var \Illuminate\Database\Eloquent\Builder
     */
    
protected $query;

    
/**
     * The parent model instance.
     *
     * @var \Illuminate\Database\Eloquent\Model
     */
    
protected $parent;

    
/**
     * The related model instance.
     *
     * @var \Illuminate\Database\Eloquent\Model
     */
    
protected $related;

    
/**
     * Indicates if the relation is adding constraints.
     *
     * @var bool
     */
    
protected static $constraints true;

    
/**
     * Create a new relation instance.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @param  \Illuminate\Database\Eloquent\Model  $parent
     * @return void
     */
    
public function __construct(Builder $queryModel $parent)
    {
        
$this->query $query;
        
$this->parent $parent;
        
$this->related $query->getModel();

        
$this->addConstraints();
    }

    
/**
     * Set the base constraints on the relation query.
     *
     * @return void
     */
    
abstract public function addConstraints();

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

    
/**
     * Initialize the relation on a set of models.
     *
     * @param  array   $models
     * @param  string  $relation
     * @return array
     */
    
abstract public function initRelation(array $models$relation);

    
/**
     * Match the eagerly loaded results to their parents.
     *
     * @param  array   $models
     * @param  \Illuminate\Database\Eloquent\Collection  $results
     * @param  string  $relation
     * @return array
     */
    
abstract public function match(array $modelsCollection $results$relation);

    
/**
     * Get the results of the relationship.
     *
     * @return mixed
     */
    
abstract public function getResults();

    
/**
     * Get the relationship for eager loading.
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    
public function getEager()
    {
        return 
$this->get();
    }

    
/**
     * Touch all of the related models for the relationship.
     *
     * @return void
     */
    
public function touch()
    {
        
$column $this->getRelated()->getUpdatedAtColumn();

        
$this->rawUpdate(array($column => $this->getRelated()->freshTimestampString()));
    }

    
/**
     * Restore all of the soft deleted related models.
     *
     * @return int
     */
    
public function restore()
    {
        return 
$this->query->withTrashed()->restore();
    }

    
/**
     * Run a raw update against the base query.
     *
     * @param  array  $attributes
     * @return int
     */
    
public function rawUpdate(array $attributes = array())
    {
        return 
$this->query->update($attributes);
    }

    
/**
     * 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->select(new Expression('count(*)'));

        
$key $this->wrap($this->getQualifiedParentKeyName());

        return 
$query->where($this->getHasCompareKey(), '=', new Expression($key));
    }

    
/**
     * Run a callback with constraints disabled on the relation.
     *
     * @param  \Closure  $callback
     * @return mixed
     */
    
public static function noConstraints(Closure $callback)
    {
        static::
$constraints false;

        
// When resetting the relation where clause, we want to shift the first element
        // off of the bindings, leaving only the constraints that the developers put
        // as "extra" on the relationships, and not original relation constraints.
        
$results call_user_func($callback);

        static::
$constraints true;

        return 
$results;
    }

    
/**
     * Get all of the primary keys for an array of models.
     *
     * @param  array   $models
     * @param  string  $key
     * @return array
     */
    
protected function getKeys(array $models$key null)
    {
        return 
array_values(array_map(function($value) use ($key)
        {
            return 
$key $value->getAttribute($key) : $value->getKey();

        }, 
$models));
    }

    
/**
     * Get the underlying query for the relation.
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    
public function getQuery()
    {
        return 
$this->query;
    }

    
/**
     * Get the base query builder driving the Eloquent builder.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    
public function getBaseQuery()
    {
        return 
$this->query->getQuery();
    }

    
/**
     * Get the parent model of the relation.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    
public function getParent()
    {
        return 
$this->parent;
    }

    
/**
     * Get the fully qualified parent key name.
     *
     * @return string
     */
    
protected function getQualifiedParentKeyName()
    {
        return 
$this->parent->getQualifiedKeyName();
    }

    
/**
     * Get the related model of the relation.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    
public function getRelated()
    {
        return 
$this->related;
    }

    
/**
     * Get the name of the "created at" column.
     *
     * @return string
     */
    
public function createdAt()
    {
        return 
$this->parent->getCreatedAtColumn();
    }

    
/**
     * Get the name of the "updated at" column.
     *
     * @return string
     */
    
public function updatedAt()
    {
        return 
$this->parent->getUpdatedAtColumn();
    }

    
/**
     * Get the name of the related model's "updated at" column.
     *
     * @return string
     */
    
public function relatedUpdatedAt()
    {
        return 
$this->related->getUpdatedAtColumn();
    }

    
/**
     * Wrap the given value with the parent query's grammar.
     *
     * @param  string  $value
     * @return string
     */
    
public function wrap($value)
    {
        return 
$this->parent->getQuery()->getGrammar()->wrap($value);
    }

    
/**
     * Handle dynamic method calls to the relationship.
     *
     * @param  string  $method
     * @param  array   $parameters
     * @return mixed
     */
    
public function __call($method$parameters)
    {
        
$result call_user_func_array(array($this->query$method), $parameters);

        if (
$result === $this->query) return $this;

        return 
$result;
    }

}