[李景山php]每天laravel
// 2016-09-23/**
* Format the sync list so that it is keyed by ID.
*
* @paramarray$records
* @return array
*/
protected function formatSyncList(array $records)
{//format the sync list so that it is keyed b ID.
$results = [];// set return values
foreach ($records as $id => $attributes) {// loop this records
if (! is_array($attributes)) {// get ID and attributes
list($id, $attributes) = [$attributes, []];
}// set list
$results[$id] = $attributes;
}// //set the result by id throw the attributes
return $results;
}// return results
/**
* Attach all of the IDs that aren't in the current array.
*
* @paramarray$records
* @paramarray$current
* @parambool $touch
* @return array
*/
protected function attachNew(array $records, array $current, $touch = true)
{// Attach all of the IDs that aren't in the current array.
$changes = ['attached' => [], 'updated' => []];//set the changes
foreach ($records as $id => $attributes) {// loop the records
// If the ID is not in the list of existing pivot IDs, we will insert a new pivot
// record, otherwise, we will just update this existing record on this joining
// table, so that the developers will easily update these records pain free.
if (! in_array($id, $current)) {// if this id not in the pivot group,just insert it.
$this->attach($id, $attributes, $touch);
$changes['attached'][] = is_numeric($id) ? (int) $id : (string) $id;
}
// Now we'll try to update an existing pivot record with the attributes that were
// given to the method. If the model is actually updated we will add it to the
// list of updated pivot records so we return them back out to the consumer.
elseif (count($attributes) > 0 &&
$this->updateExistingPivot($id, $attributes, $touch)) {
$changes['updated'][] = is_numeric($id) ? (int) $id : (string) $id;
}//we return them back out to the consumer.
}
return $changes;
}
/**
* Update an existing pivot record on the table.
*
* @parammixed$id
* @paramarray$attributes
* @parambool $touch
* @return int
*/
public function updateExistingPivot($id, array $attributes, $touch = true)
{// Update an existing pivot record on the table
if (in_array($this->updatedAt(), $this->pivotColumns)) {
$attributes = $this->setTimestampsOnAttach($attributes, true);
}// in_array($this->updateAt)
// set the attribute
$updated = $this->newPivotStatementForId($id)->update($attributes);
// get this updated
if ($touch) {
$this->touchIfTouching();
}// if need touch
return $updated;
}//return this result
/**
* Attach a model to the parent.
*
* @parammixed$id
* @paramarray$attributes
* @parambool $touch
* @return void
*/
public function attach($id, array $attributes = [], $touch = true)
{
if ($id instanceof Model) {
$id = $id->getKey();
}// case 1
if ($id instanceof Collection) {
$id = $id->modelKeys();
}// case 2
$query = $this->newPivotStatement();
// get the query
$query->insert($this->createAttachRecords((array) $id, $attributes));
// insert the data
if ($touch) {
$this->touchIfTouching();
}// touch something
}// first to attach
/**
* Create an array of records to insert into the pivot table.
*
* @paramarray$ids
* @paramarray$attributes
* @return array
*/
protected function createAttachRecords($ids, array $attributes)
{//Create an array of records to insert into the pivot table.
$records = [];// records
$timed = ($this->hasPivotColumn($this->createdAt()) ||
$this->hasPivotColumn($this->updatedAt()));
// set timed
// To create the attachment records, we will simply spin through the IDs given
// and create a new record to insert for each ID. Each ID may actually be a
// key in the array, with extra attributes to be placed in other columns.
foreach ($ids as $key => $value) {
$records[] = $this->attacher($key, $value, $attributes, $timed);
}// get records by id and other relation columns
return $records;
}// return this records
/**
* Create a full attachment record payload.
*
* @paramint $key
* @parammixed$value
* @paramarray$attributes
* @parambool $timed
* @return array
*/
protected function attacher($key, $value, $attributes, $timed)
{//Create a full attachment record payload
list($id, $extra) = $this->getAttachId($key, $value, $attributes);// list many return
// To create the attachment records, we will simply spin through the IDs given
// and create a new record to insert for each ID. Each ID may actually be a
// key in the array, with extra attributes to be placed in other columns.
$record = $this->createAttachRecord($id, $timed);// id is a key about every thing
return array_merge($record, $extra);
}//return this array_merge.
/**
* Get the attach record ID and extra attributes.
*
* @parammixed$key
* @parammixed$value
* @paramarray$attributes
* @return array
*/
protected function getAttachId($key, $value, array $attributes)
{//Get the attach record ID and extra attributes.
if (is_array($value)) {
return [$key, array_merge($value, $attributes)];
}// a strange thing
return [$value, $attributes];
}// return this default
/**
* Create a new pivot attachment record.
*
* @paramint $id
* @parambool$timed
* @return array
*/
protected function createAttachRecord($id, $timed)
{//Create a new pivot attachment record
$record[$this->foreignKey] = $this->parent->getKey();// record the key
$record[$this->otherKey] = $id;//record the other key
// If the record needs to have creation and update timestamps, we will make
// them by calling the parent model's "freshTimestamp" method which will
// provide us with a fresh timestamp in this model's preferred format.
if ($timed) {
$record = $this->setTimestampsOnAttach($record);
}// if you need to update this timestamps,just use parents method
return $record;
}//return record
/**
* Set the creation and update timestamps on an attach record.
*
* @paramarray$record
* @parambool $exists
* @return array
*/
protected function setTimestampsOnAttach(array $record, $exists = false)
{// this function just try to use father method to set about timestamps
$fresh = $this->parent->freshTimestamp();// get this function return
if (! $exists && $this->hasPivotColumn($this->createdAt())) {
$record[$this->createdAt()] = $fresh;
}// check some condition
if ($this->hasPivotColumn($this->updatedAt())) {
$record[$this->updatedAt()] = $fresh;
}// ok
return $record;
}//return this record
/**
* Detach models from the relationship.
*
* @paramint|array$ids
* @parambool$touch
* @return int
*/
public function detach($ids = [], $touch = true)
{// detach models from the relationship
if ($ids instanceof Model) {
$ids = (array) $ids->getKey();// ids = (array) -> ids-> getKey
}// ids instanceof Model
$query = $this->newPivotQuery();//get a new query
// If associated IDs were passed to the method we will only delete those
// associations, otherwise all of the association ties will be broken.
// We'll return the numbers of affected rows when we do the deletes.
$ids = (array) $ids;// first to set the ids
if (count($ids) > 0) {
$query->whereIn($this->otherKey, (array) $ids);
}// count the query
// Once we have all of the conditions set on the statement, we are ready
// to run the delete on the pivot table. Then, if the touch parameter
// is true, we will go ahead and touch all related models to sync.
$results = $query->delete();//Once we have all of the conditions on the statement
//are ready to run the delete on the pivot table.
if ($touch) {
$this->touchIfTouching();
}
return $results;
}//just return this results
/**
* If we're touching the parent model, touch.
*
* @return void
*/
public function touchIfTouching()
{
if ($this->touchingParent()) {
$this->getParent()->touch();
}
if ($this->getParent()->touches($this->relationName)) {
$this->touch();
}
}//If we're touching the parent model,touch.
/**
* Determine if we should touch the parent on sync.
*
* @return bool
*/
protected function touchingParent()
{
return $this->getRelated()->touches($this->guessInverseRelation());
}//Determine if we should touch the parent on sync.
/**
* Attempt to guess the name of the inverse of the relation.
*
* @return string
*/
protected function guessInverseRelation()
{
return Str::camel(Str::plural(class_basename($this->getParent())));
}//Attempt to guess the name of the inverse of the relation
/**
* Create a new query builder for the pivot table.
*
* @return \Illuminate\Database\Query\Builder
*/
protected function newPivotQuery()
{//Create a new query builder for the pivot table
$query = $this->newPivotStatement();
foreach ($this->pivotWheres as $whereArgs) {
call_user_func_array([$query, 'where'], $whereArgs);
}
return $query->where($this->foreignKey, $this->parent->getKey());
}// just a wrap function
/**
* Get a new plain query builder for the pivot table.
*
* @return \Illuminate\Database\Query\Builder
*/
public function newPivotStatement()
{
return $this->query->getQuery()->newQuery()->from($this->table);
}// Get a new plain query builder for the pivot table
/**
* Get a new pivot statement for a given "other" ID.
*
* @parammixed$id
* @return \Illuminate\Database\Query\Builder
*/
public function newPivotStatementForId($id)
{
return $this->newPivotQuery()->where($this->otherKey, $id);
}//Get a new pivot statement for a given "other" ID.
/**
* Create a new pivot model instance.
*
* @paramarray$attributes
* @parambool $exists
* @return \Illuminate\Database\Eloquent\Relations\Pivot
*/
public function newPivot(array $attributes = [], $exists = false)
{
$pivot = $this->related->newPivot($this->parent, $attributes, $this->table, $exists);
return $pivot->setPivotKeys($this->foreignKey, $this->otherKey);
}//Create a new pivot model instance.
// return set Pivot Keys
/**
* Create a new existing pivot model instance.
*
* @paramarray$attributes
* @return \Illuminate\Database\Eloquent\Relations\Pivot
*/
public function newExistingPivot(array $attributes = [])
{
return $this->newPivot($attributes, true);
}//Create a new existing pivot model instance.
/**
* Set the columns on the pivot table to retrieve.
*
* @paramarray|mixed$columns
* @return $this
*/
public function withPivot($columns)
{
$columns = is_array($columns) ? $columns : func_get_args();// set this columns.
$this->pivotColumns = array_merge($this->pivotColumns, $columns);// pivot array_merge
return $this;
}// Set the columns on the pivot table to retrieve.
/**
* Specify that the pivot table has creation and update timestamps.
*
* @parammixed$createdAt
* @parammixed$updatedAt
* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
*/
public function withTimestamps($createdAt = null, $updatedAt = null)
{
$this->pivotCreatedAt = $createdAt;// set user
$this->pivotUpdatedAt = $updatedAt;// set user
return $this->withPivot($this->createdAt(), $this->updatedAt());
}// Specify that the pivot table has creation and update timestamps
/**
* Get the name of the "created at" column.
*
* @return string
*/
public function createdAt()
{
return $this->pivotCreatedAt ?: $this->parent->getCreatedAtColumn();
}// Get the name of the "created at" column
/**
* Get the name of the "updated at" column.
*
* @return string
*/
public function updatedAt()
{
return $this->pivotUpdatedAt ?: $this->parent->getUpdatedAtColumn();
}// pivot
/**
* Get the related model's updated at column name.
*
* @return string
*/
public function getRelatedFreshUpdate()
{
return [$this->related->getUpdatedAtColumn() => $this->related->freshTimestamp()];
}// just return
/**
* Get the key for comparing against the parent key in "has" query.
*
* @return string
*/
public function getHasCompareKey()
{
return $this->getForeignKey();
}//return
/**
* Get the fully qualified foreign key for the relation.
*
* @return string
*/
public function getForeignKey()
{
return $this->table.'.'.$this->foreignKey;
}//return
/**
* Get the fully qualified "other key" for the relation.
*
* @return string
*/
public function getOtherKey()
{
return $this->table.'.'.$this->otherKey;
}//return
/**
* Get the intermediate table for the relationship.
*
* @return string
*/
public function getTable()
{
return $this->table;
}//return
/**
* Get the relationship name for the relationship.
*
* @return string
*/
public function getRelationName()
{
return $this->relationName;
}//return
}
页:
[1]