/**
* 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());
}
