/** * Merge client info subentity * @param \Illuminate\Support\Collection $clients */ protected function mergeInfo($clients) { $infos = $this->manager->clientInfo->where('clientID', 'in', $clients->pluck('id'))->get(); foreach ($infos as $clientID => $info) { $clients[$clientID]->info = $info; } }
/** * @param $object * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return string */ protected function commonBalanceInPeriod($object, Carbon $start, Carbon $end, Collection $accounts) { $ids = $accounts->pluck('id')->toArray(); $entry = $object->transactionjournals()->transactionTypes([TransactionType::WITHDRAWAL, TransactionType::DEPOSIT, TransactionType::OPENING_BALANCE])->before($end)->leftJoin('transactions', 'transactions.transaction_journal_id', '=', 'transaction_journals.id')->leftJoin('accounts', 'accounts.id', '=', 'transactions.account_id')->whereIn('accounts.id', $ids)->after($start)->first([DB::raw('SUM(`transactions`.`amount`) as `journalAmount`')]); $amount = $entry->journalAmount; return $amount; }
/** * This method generates a full report for the given period on all * given accounts. * * a special consideration for accounts that did exist on this exact day. * we also grab the balance from today just in case, to see if that changes things. * it's a fall back for users who (rightly so) start keeping score at the first of * the month and find the first report lacking / broken. * * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return AccountCollection */ public function getAccountReport(Carbon $start, Carbon $end, Collection $accounts) : AccountCollection { $startAmount = '0'; $endAmount = '0'; $diff = '0'; $ids = $accounts->pluck('id')->toArray(); $yesterday = clone $start; $yesterday->subDay(); $startSet = $this->getSet($ids, $yesterday); // get balances for start. $backupSet = $this->getSet($ids, $start); $endSet = $this->getSet($ids, $end); $accounts->each(function (Account $account) use($startSet, $endSet, $backupSet) { return self::reportFilter($account, $startSet, $endSet, $backupSet); }); // summarize: foreach ($accounts as $account) { $startAmount = bcadd($startAmount, $account->startBalance); $endAmount = bcadd($endAmount, $account->endBalance); $diff = bcadd($diff, bcsub($account->endBalance, $account->startBalance)); } $object = new AccountCollection(); $object->setStart($startAmount); $object->setEnd($endAmount); $object->setDifference($diff); $object->setAccounts($accounts); return $object; }
/** * @author WN * @param Collection $partialRefunds * @return Collection */ private function processFilter(Collection $partialRefunds) { $statuses = $partialRefunds->pluck('status')->unique()->flip(); foreach ($statuses as $key => $value) { $statuses[$key] = ucfirst($key); } return $statuses; }
public static function getDefaultsUrl() { $defaults = []; foreach (self::$defaults as $default) { $defaults[] = self::buildImageUrl($default); } $defaults = new Collection($defaults); return $defaults->pluck('path'); }
/** * @param Collection $accounts * * @return Collection */ public function getBillsForAccounts(Collection $accounts) { $ids = $accounts->pluck('id')->toArray(); $set = Auth::user()->bills()->leftJoin('transaction_journals', function (JoinClause $join) { $join->on('transaction_journals.bill_id', '=', 'bills.id')->whereNull('transaction_journals.deleted_at'); })->leftJoin('transactions', function (JoinClause $join) { $join->on('transaction_journals.id', '=', 'transactions.transaction_journal_id')->where('transactions.amount', '<', 0); })->whereIn('transactions.account_id', $ids)->whereNull('transaction_journals.deleted_at')->groupBy('bills.id')->get(['bills.*']); $set = $set->sortBy(function (Bill $bill) { $int = $bill->active == 1 ? 0 : 1; return $int . strtolower($bill->name); }); return $set; }
/** * This method generates a full report for the given period on all * given accounts * * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return AccountCollection */ public function getAccountReport(Carbon $start, Carbon $end, Collection $accounts) { $startAmount = '0'; $endAmount = '0'; $diff = '0'; $ids = $accounts->pluck('id')->toArray(); $yesterday = clone $start; $yesterday->subDay(); bcscale(2); // get balances for start. $startSet = Account::leftJoin('transactions', 'transactions.account_id', '=', 'accounts.id')->leftJoin('transaction_journals', 'transaction_journals.id', '=', 'transactions.transaction_journal_id')->whereIn('accounts.id', $ids)->whereNull('transaction_journals.deleted_at')->whereNull('transactions.deleted_at')->where('transaction_journals.date', '<=', $yesterday->format('Y-m-d'))->groupBy('accounts.id')->get(['accounts.id', DB::Raw('SUM(`transactions`.`amount`) as `balance`')]); // and end: $endSet = Account::leftJoin('transactions', 'transactions.account_id', '=', 'accounts.id')->leftJoin('transaction_journals', 'transaction_journals.id', '=', 'transactions.transaction_journal_id')->whereIn('accounts.id', $ids)->whereNull('transaction_journals.deleted_at')->whereNull('transactions.deleted_at')->where('transaction_journals.date', '<=', $end->format('Y-m-d'))->groupBy('accounts.id')->get(['accounts.id', DB::Raw('SUM(`transactions`.`amount`) as `balance`')]); $accounts->each(function (Account $account) use($startSet, $endSet) { /** * The balance for today always incorporates transactions * made on today. So to get todays "start" balance, we sub one * day. */ // $currentStart = $startSet->filter(function (Account $entry) use($account) { return $account->id == $entry->id; }); if ($currentStart->first()) { $account->startBalance = $currentStart->first()->balance; } $currentEnd = $endSet->filter(function (Account $entry) use($account) { return $account->id == $entry->id; }); if ($currentEnd->first()) { $account->endBalance = $currentEnd->first()->balance; } }); // summarize: foreach ($accounts as $account) { $startAmount = bcadd($startAmount, $account->startBalance); $endAmount = bcadd($endAmount, $account->endBalance); $diff = bcadd($diff, bcsub($account->endBalance, $account->startBalance)); } $object = new AccountCollection(); $object->setStart($startAmount); $object->setEnd($endAmount); $object->setDifference($diff); $object->setAccounts($accounts); return $object; }
public static function average(\Illuminate\Support\Collection $posts) { $count = $posts->count(); $comments = $posts->pluck('comments')->avg(); $pictures = $posts->pluck('pictures')->avg(); $wordCount = $posts->pluck('wordCount')->avg(); $totalWords = $posts->pluck('wordCount')->sum(); $emotionalScore = $posts->pluck('emotionalScore')->avg(); $emotionalScoreX = $posts->pluck('emotionalScoreX')->avg(); $emotionalScoreY = $posts->pluck('emotionalScoreY')->avg(); $ego = $posts->pluck('ego')->map(function ($item, $key) { return count($item); })->avg(); $comments = round($comments, 2); $pictures = round($pictures, 2); $wordCount = round($wordCount, 2); $ego = round($ego, 2); $wordCounts = $posts->pluck('lemmas'); $words = []; foreach ($wordCounts as $k => $subArray) { foreach ($subArray as $key => $value) { if (!isset($words[$key])) { $words[$key] = 0; } $words[$key] += $value; } } arsort($words); $words = array_slice($words, 0, 5000); $words = array_filter($words, function ($value) { return $value > 2; }); // collect($words)->filter(function ($key, $value) { // return $value > 2; // })->toArray(); return compact('count', 'comments', 'pictures', 'wordCount', 'ego', 'words', 'totalWords', 'emotionalScore', 'emotionalScoreX', 'emotionalScoreY'); }
/** * @SuppressWarnings(PHPMD.ExcessiveMethodLength) // at 43, its ok. * @SuppressWarnings(PHPMD.CyclomaticComplexity) // it's exactly 5. * * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return Collection */ public function budgetYearOverview(Carbon $start, Carbon $end, Collection $accounts) : Collection { // chart properties for cache: $cache = new CacheProperties(); $cache->addProperty($start); $cache->addProperty($end); $cache->addProperty('budget-year'); $cache->addProperty($accounts->pluck('id')->toArray()); if ($cache->has()) { return $cache->get(); } $current = clone $start; $return = new Collection(); $set = $this->repository->getBudgets(); $budgets = []; $spent = []; $headers = $this->createYearHeaders($current, $end); /** @var Budget $budget */ foreach ($set as $budget) { $id = $budget->id; $budgets[$id] = $budget->name; $current = clone $start; $budgetData = $this->getBudgetSpentData($current, $end, $budget, $accounts); $sum = $budgetData['sum']; $spent[$id] = $budgetData['spent']; if (bccomp('0', $sum) === 0) { // not spent anything. unset($spent[$id]); unset($budgets[$id]); } } $return->put('headers', $headers); $return->put('budgets', $budgets); $return->put('spent', $spent); $cache->store($return); return $return; }
/** * Merge groups subentity with client * @param \Illuminate\Support\Collection $clients */ protected function mergeGroups($clients) { $groups = $this->manager->group->byClients($clients->pluck('id')); foreach ($groups as $clientID => $group) { $clients[$clientID]->groups = collect($group); } }
/** * Returns an array of tags and their comparitive size with amounts bla bla. * * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return array */ public function tagReport(Carbon $start, Carbon $end, Collection $accounts) : array { $ids = $accounts->pluck('id')->toArray(); $set = Tag::leftJoin('tag_transaction_journal', 'tags.id', '=', 'tag_transaction_journal.tag_id')->leftJoin('transaction_journals', 'tag_transaction_journal.transaction_journal_id', '=', 'transaction_journals.id')->leftJoin('transactions AS source', function (JoinClause $join) { $join->on('source.transaction_journal_id', '=', 'transaction_journals.id')->where('source.amount', '<', '0'); })->leftJoin('transactions AS destination', function (JoinClause $join) { $join->on('destination.transaction_journal_id', '=', 'transaction_journals.id')->where('destination.amount', '>', '0'); })->where('transaction_journals.date', '>=', $start->format('Y-m-d'))->where('transaction_journals.date', '<=', $end->format('Y-m-d'))->where(function (Builder $q) use($ids) { $q->whereIn('source.account_id', $ids)->whereIn('destination.account_id', $ids, 'xor'); })->get(['tags.id', 'tags.tag', 'transaction_journals.id as journal_id', 'destination.amount']); $collection = []; if ($set->count() === 0) { return $collection; } /** @var Tag $entry */ foreach ($set as $entry) { // less than zero? multiply to be above zero. $amount = $entry->amount; $id = intval($entry->id); $previousAmount = $collection[$id]['amount'] ?? '0'; $collection[$id] = ['id' => $id, 'tag' => $entry->tag, 'amount' => bcadd($previousAmount, $amount)]; } // cleanup collection (match "fonts") $max = strval(max(array_column($collection, 'amount'))); foreach ($collection as $id => $entry) { $size = bcdiv($entry['amount'], $max, 4); if (bccomp($size, '0.25') === -1) { $size = '0.5'; } $collection[$id]['fontsize'] = $size; } return $collection; }
/** * This method returns all the "out" transaction journals for the given account and given period. The amount * is stored in "journalAmount". * * @param Collection $accounts * @param Carbon $start * @param Carbon $end * * @return Collection */ public function expense(Collection $accounts, Carbon $start, Carbon $end) { $ids = $accounts->pluck('id')->toArray(); $set = Auth::user()->transactionjournals()->leftJoin('transactions as t_from', function (JoinClause $join) { $join->on('t_from.transaction_journal_id', '=', 'transaction_journals.id')->where('t_from.amount', '<', 0); })->leftJoin('transactions as t_to', function (JoinClause $join) { $join->on('t_to.transaction_journal_id', '=', 'transaction_journals.id')->where('t_to.amount', '>', 0); })->leftJoin('accounts', 't_to.account_id', '=', 'accounts.id')->transactionTypes([TransactionType::WITHDRAWAL, TransactionType::TRANSFER, TransactionType::OPENING_BALANCE])->before($end)->after($start)->whereIn('t_from.account_id', $ids)->whereNotIn('t_to.account_id', $ids)->get(['transaction_journals.*', 't_from.amount as journalAmount', 'accounts.id as account_id', 'accounts.name as account_name']); return $set; }
/** * Returns a list of expenses (in the field "spent", grouped per budget per account. * * @param Collection $budgets * @param Collection $accounts * @param Carbon $start * @param Carbon $end * * @return Collection */ public function spentPerBudgetPerAccount(Collection $budgets, Collection $accounts, Carbon $start, Carbon $end) { $accountIds = $accounts->pluck('id')->toArray(); $budgetIds = $budgets->pluck('id')->toArray(); $set = Auth::user()->transactionjournals()->leftJoin('transactions AS t_from', function (JoinClause $join) { $join->on('transaction_journals.id', '=', 't_from.transaction_journal_id')->where('t_from.amount', '<', 0); })->leftJoin('transactions AS t_to', function (JoinClause $join) { $join->on('transaction_journals.id', '=', 't_to.transaction_journal_id')->where('t_to.amount', '>', 0); })->leftJoin('budget_transaction_journal', 'transaction_journals.id', '=', 'budget_transaction_journal.transaction_journal_id')->whereIn('t_from.account_id', $accountIds)->whereNotIn('t_to.account_id', $accountIds)->where(function (Builder $q) use($budgetIds) { $q->whereIn('budget_transaction_journal.budget_id', $budgetIds); $q->orWhereNull('budget_transaction_journal.budget_id'); })->after($start)->before($end)->groupBy('t_from.account_id')->groupBy('budget_transaction_journal.budget_id')->transactionTypes([TransactionType::WITHDRAWAL, TransactionType::TRANSFER, TransactionType::OPENING_BALANCE])->get(['t_from.account_id', 'budget_transaction_journal.budget_id', DB::Raw('SUM(`t_from`.`amount`) AS `spent`')]); return $set; }
/** * @param Collection $accounts * @param Carbon $start * @param Carbon $end * * @return string */ public function spentInPeriodWithoutBudget(Collection $accounts, Carbon $start, Carbon $end) : string { $types = [TransactionType::WITHDRAWAL]; $query = $this->user->transactionJournals()->distinct()->transactionTypes($types)->leftJoin('budget_transaction_journal', 'budget_transaction_journal.transaction_journal_id', '=', 'transaction_journals.id')->leftJoin('transactions as source', function (JoinClause $join) { $join->on('source.transaction_journal_id', '=', 'transaction_journals.id')->where('source.amount', '<', 0); })->leftJoin('transactions as destination', function (JoinClause $join) { $join->on('destination.transaction_journal_id', '=', 'transaction_journals.id')->where('destination.amount', '>', 0); })->leftJoin('budget_transaction', 'source.id', '=', 'budget_transaction.transaction_id')->whereNull('budget_transaction_journal.id')->whereNull('budget_transaction.id')->before($end)->after($start)->whereNull('source.deleted_at')->whereNull('destination.deleted_at')->where('transaction_journals.completed', 1); if ($accounts->count() > 0) { $accountIds = $accounts->pluck('id')->toArray(); $set = join(', ', $accountIds); $query->whereRaw('(source.account_id in (' . $set . ') XOR destination.account_id in (' . $set . '))'); } $ids = $query->get(['transaction_journals.id'])->pluck('id')->toArray(); $sum = '0'; if (count($ids) > 0) { $sum = strval($this->user->transactions()->whereIn('transaction_journal_id', $ids)->where('amount', '<', '0')->whereNull('transactions.deleted_at')->sum('amount')); } return $sum; }
/** * Returns a collection of ALL journals, given a specific account and a date range. * * @param Collection $accounts * @param Carbon $start * @param Carbon $end * * @return Collection */ public function getJournalsInRange(Collection $accounts, Carbon $start, Carbon $end) : Collection { $query = $this->user->transactionJournals()->expanded()->sortCorrectly(); $query->where('transaction_journals.completed', 1); $query->before($end); $query->after($start); if ($accounts->count() > 0) { $ids = $accounts->pluck('id')->toArray(); // join source and destination: $query->leftJoin('transactions as source', function (JoinClause $join) { $join->on('source.transaction_journal_id', '=', 'transaction_journals.id')->where('source.amount', '<', 0); }); $query->leftJoin('transactions as destination', function (JoinClause $join) { $join->on('destination.transaction_journal_id', '=', 'transaction_journals.id')->where('destination.amount', '>', 0); }); $query->where(function (Builder $q) use($ids) { $q->whereIn('destination.account_id', $ids); $q->orWhereIn('source.account_id', $ids); }); } $set = $query->get(TransactionJournal::queryFields()); return $set; }
/** * @param Collection $accounts * @param array $types * @param Carbon $start * @param Carbon $end * * @return string */ private function sumInPeriodWithoutCategory(Collection $accounts, array $types, Carbon $start, Carbon $end) : string { $query = $this->user->transactionJournals()->distinct()->transactionTypes($types)->leftJoin('category_transaction_journal', 'category_transaction_journal.transaction_journal_id', '=', 'transaction_journals.id')->leftJoin('transactions as t', function (JoinClause $join) { $join->on('t.transaction_journal_id', '=', 'transaction_journals.id')->where('amount', '<', 0); })->leftJoin('category_transaction', 't.id', '=', 'category_transaction.transaction_id')->whereNull('category_transaction_journal.id')->whereNull('category_transaction.id')->before($end)->after($start); if ($accounts->count() > 0) { $accountIds = $accounts->pluck('id')->toArray(); $query->whereIn('t.account_id', $accountIds); } $sum = strval($query->sum('t.amount')); return $sum; }
/** * Get the accounts of a user that have piggy banks connected to them. * * @return Collection */ public function getPiggyBankAccounts() { $start = clone Session::get('start', new Carbon()); $end = clone Session::get('end', new Carbon()); $collection = new Collection(DB::table('piggy_banks')->distinct()->get(['piggy_banks.account_id'])); $ids = $collection->pluck('account_id')->toArray(); $accounts = new Collection(); $ids = array_unique($ids); if (count($ids) > 0) { $accounts = Auth::user()->accounts()->whereIn('id', $ids)->where('accounts.active', 1)->get(); } bcscale(2); $accounts->each(function (Account $account) use($start, $end) { $account->startBalance = Steam::balance($account, $start, true); $account->endBalance = Steam::balance($account, $end, true); $account->piggyBalance = 0; /** @var PiggyBank $piggyBank */ foreach ($account->piggyBanks as $piggyBank) { $account->piggyBalance += $piggyBank->currentRelevantRep()->currentamount; } // sum of piggy bank amounts on this account: // diff between endBalance and piggyBalance. // then, percentage. $difference = bcsub($account->endBalance, $account->piggyBalance); $account->difference = $difference; $account->percentage = $difference != 0 && $account->endBalance != 0 ? round($difference / $account->endBalance * 100) : 100; }); return $accounts; }
/** * @param Bill $bill * * @return Collection */ public function getPossiblyRelatedJournals(Bill $bill) { $set = new Collection(DB::table('transactions')->where('amount', '>', 0)->where('amount', '>=', $bill->amount_min)->where('amount', '<=', $bill->amount_max)->get(['transaction_journal_id'])); $ids = $set->pluck('transaction_journal_id')->toArray(); $journals = new Collection(); if (count($ids) > 0) { $journals = Auth::user()->transactionjournals()->transactionTypes([TransactionType::WITHDRAWAL])->whereIn('transaction_journals.id', $ids)->get(['transaction_journals.*']); } return $journals; }
/** * Merge entity attributes (not store attributes) subentity with client * @param \Illuminate\Support\Collection $entities */ protected function mergeAttributes($entities) { $primary = $this->map($this->attributes('primary'), true); $entity = $this->attributes('entity'); // Attributes not available/enabled for this entity if store relationship not defined if (is_null($this->properties('attributes'))) { return; } $attributes = $this->manager()->attribute->where('entity', $entity)->where('entityKey', 'in', $entities->pluck($primary)->all())->get(); if (isset($attributes)) { foreach ($attributes as $attribute) { $entities[$attribute->entityKey]->attributes = json_decode($attribute->value, true); } } }
/** * @param Carbon $start * @param Carbon $end * @param Collection $accounts * * @return View */ private function auditReport(Carbon $start, Carbon $end, Collection $accounts) { /** @var ARI $repos */ $repos = app(ARI::class); $auditData = []; $dayBefore = clone $start; $dayBefore->subDay(); /** @var Account $account */ foreach ($accounts as $account) { // balance the day before: $id = $account->id; $first = $repos->oldestJournalDate($account); $last = $repos->newestJournalDate($account); $exists = false; $journals = new Collection(); $dayBeforeBalance = Steam::balance($account, $dayBefore); /* * Is there even activity on this account between the requested dates? */ if ($start->between($first, $last) || $end->between($first, $last)) { $exists = true; $journals = $repos->journalsInPeriod(new Collection([$account]), [], $start, $end); } /* * Reverse set, get balances. */ $journals = $journals->reverse(); $startBalance = $dayBeforeBalance; /** @var TransactionJournal $journal */ foreach ($journals as $journal) { $journal->before = $startBalance; $transactionAmount = $journal->source_amount; // get currently relevant transaction: $destinations = TransactionJournal::destinationAccountList($journal)->pluck('id')->toArray(); if (in_array($account->id, $destinations)) { $transactionAmount = TransactionJournal::amountPositive($journal); } $newBalance = bcadd($startBalance, $transactionAmount); $journal->after = $newBalance; $startBalance = $newBalance; } /* * Reverse set again. */ $auditData[$id]['journals'] = $journals->reverse(); $auditData[$id]['exists'] = $exists; $auditData[$id]['end'] = $end->formatLocalized(strval(trans('config.month_and_day'))); $auditData[$id]['endBalance'] = Steam::balance($account, $end); $auditData[$id]['dayBefore'] = $dayBefore->formatLocalized(strval(trans('config.month_and_day'))); $auditData[$id]['dayBeforeBalance'] = $dayBeforeBalance; } $reportType = 'audit'; $accountIds = join(',', $accounts->pluck('id')->toArray()); $hideable = ['buttons', 'icon', 'description', 'balance_before', 'amount', 'balance_after', 'date', 'interest_date', 'book_date', 'process_date', 'due_date', 'payment_date', 'invoice_date', 'from', 'to', 'budget', 'category', 'bill', 'internal_reference', 'notes', 'create_date', 'update_date']; $defaultShow = ['icon', 'description', 'balance_before', 'amount', 'balance_after', 'date', 'to']; return view('reports.audit.report', compact('start', 'end', 'reportType', 'accountIds', 'accounts', 'auditData', 'hideable', 'defaultShow')); }
/** * Array of scripts registered to this project. * * @return array */ public function availableScripts() { return $this->scripts->pluck('name')->toArray(); }
/** * Perform a simple check to see if all defined salts are using a placeholder. * @return bool */ protected function salts_are_placeholders() { return $this->env->dictionary()->only($this->salts->pluck(0)->all())->values()->unique()->count() === 1; // 1 unique means they are all the same }
/** * @param Player[] $players */ public function handle(Collection $players) { $playerIds = implode(',', $players->pluck('id')->toArray()); $now = Carbon::now(); DB::update('UPDATE player_season SET paid = ? WHERE group_id = ? AND player_id IN(' . $playerIds . ')', [$now->toDateTimeString(), Session::group()->id]); }
/** * Append Reportback data to the supplied collection of users. * * @param \Illuminate\Support\Collection $collection * @param array $parameters * @return \Illuminate\Support\Collection */ protected function appendReportbackToCollection($collection, $parameters) { $activity = $this->getActivityForAllUsers($collection->pluck('id')->all(), $parameters); $activity = $activity->keyBy(function ($item) { return $item->user->id; }); foreach ($collection as $user) { if (isset($activity[$user->id])) { $user->reportback = $activity[$user->id]->reportback; } else { $user->reportback = null; } } return $collection; }
public function testGetPluckValueWithAccessors() { $model = new TestAccessorEloquentTestStub(['some' => 'foo']); $modelTwo = new TestAccessorEloquentTestStub(['some' => 'bar']); $data = new Collection([$model, $modelTwo]); $this->assertEquals(['foo', 'bar'], $data->pluck('some')->all()); }
public function postStore($id = null) { // ---------------------------------------- HANDLE REQUEST ---------------------------------------- // handle id if (!is_null($id)) { $data = $this->model->findorfail($id); } else { $data = $this->model->newInstance(); } // ---------------------------------------- CHECK TAG ---------------------------------------- $tags_in_db = \App\Tag::whereIn('tag', Input::get('tags'))->get(); if (!$tags_in_db) { $tags_in_db = new Collection(); } foreach (Input::get('tags') as $x) { if (!$tags_in_db->where('tag', $x)->first()->id) { $new_tag = new \App\Tag(['tag' => $x]); if (!$new_tag->save()) { dd($new_tag->getErrors()); } $tags_in_db->push($new_tag); } } // ---------------------------------------- HANDLE SAVE ---------------------------------------- $input = Input::all(); // tour travel agent $input['travel_agent_id'] = $input['travel_agent']; // tour destinations $input['destination_ids'] = $input['destinations']; // tour places $input['place_ids'] = $input['places']; // tags $input['tag_ids'] = $tags_in_db->pluck('id')->toArray(); // tour options foreach ($input['tour_options'] as $x) { $input['option_ids'][$x] = ['description' => $input['tour_options_description_' . $x]]; } // published_at if ($input['published_at']) { $input['published_at'] = \Carbon\Carbon::createFromFormat('d/m/Y H:i', $input['published_at'])->format('Y-m-d H:i:s'); } else { $input['published_at'] = null; } $data->fill($input); if ($data->save()) { if (!$this->save_required_images($data, $input)) { return redirect()->back()->withInput()->withErrors($data->getErrors()); } return redirect()->route('admin.' . $this->view_name . '.show', ['id' => $data->id])->with('alert_success', '"' . $data->{$data->getNameField()} . '" has been saved successfully'); } else { return redirect()->back()->withInput()->withErrors($data->getErrors()); } }
/** * @param Collection $accounts * @param Carbon $start * @param Carbon $end * * @return string */ public function spentInPeriod(Collection $accounts, Carbon $start, Carbon $end) : string { /** @var HasMany $query */ $query = $this->user->transactionJournals()->expanded()->transactionTypes([TransactionType::WITHDRAWAL, TransactionType::TRANSFER]); if ($end >= $start) { $query->before($end)->after($start); } if ($accounts->count() > 0) { $accountIds = $accounts->pluck('id')->toArray(); $query->leftJoin('transactions as source', function (JoinClause $join) { $join->on('source.transaction_journal_id', '=', 'transaction_journals.id')->where('source.amount', '<', 0); }); $query->leftJoin('transactions as destination', function (JoinClause $join) { $join->on('destination.transaction_journal_id', '=', 'transaction_journals.id')->where('destination.amount', '>', 0); }); $query->whereIn('source.account_id', $accountIds); $query->whereNotIn('destination.account_id', $accountIds); $query->whereNull('source.deleted_at'); $query->whereNull('destination.deleted_at'); $query->distinct(); } // remove group by $query->getQuery()->getQuery()->groups = null; $ids = $query->get(['transaction_journals.id'])->pluck('id')->toArray(); $sum = $this->user->transactions()->whereIn('transaction_journal_id', $ids)->where('amount', '<', '0')->whereNull('transactions.deleted_at')->sum('amount'); return strval($sum); }
/** * Get a route list (object list) from a Collection * * @param string $routeName * @param Collection $collection * @param string $key * @return array **/ protected function collectionRouteList($routeName, Collection $collection, $key = 'id') { $keys = $collection->pluck($key); return array_map(function ($key) use($routeName) { return route($routeName, $key); }, $keys->all()); }
/** * Get an array with the values of a given column. * * @param string $column * @param string $key * @return array */ public function lists($column, $key = null) { $columns = $this->getListSelect($column, $key); $results = new Collection($this->get($columns)); return $results->pluck($columns[0], Arr::get($columns, 1))->all(); }
/** * Sync entire collection of material to this job costing * * @param \Illuminate\Support\Collection $materials */ public function syncMaterialCollection(\Illuminate\Support\Collection $materials) { $width = $this->target_width; $materialIds = $materials->pluck('material_id'); $intermediateValues = $materialIds->map(function ($item, $key) use($width) { return ['jc_material_width' => $width, 'jc_material_layer' => $key + 1]; })->toArray(); $this->material()->sync($materialIds->combine($intermediateValues)->toArray()); }