/**
* Execute the console command.
*
* @return mixed
*/
public function fire()
{
$experiments = Experiment::active()->get();
$goals = array_unique(Goal::active()->orderBy('name')->lists('name')->toArray());
$columns = array_merge(['Experiment', 'Visitors', 'Engagement'], array_map('ucfirst', $goals));
$writer = new Writer(new SplTempFileObject());
$writer->insertOne($columns);
foreach ($experiments as $experiment) {
$engagement = $experiment->visitors ? $experiment->engagement / $experiment->visitors * 100 : 0;
$row = [$experiment->name, $experiment->visitors, number_format($engagement, 2) . " % (" . $experiment->engagement . ")"];
$results = $experiment->goals()->lists('count', 'name');
foreach ($goals as $column) {
$count = array_get($results, $column, 0);
$percentage = $experiment->visitors ? $count / $experiment->visitors * 100 : 0;
$row[] = number_format($percentage, 2) . " % ({$count})";
}
$writer->insertOne($row);
}
$output = (string) $writer;
if ($file = $this->argument('file')) {
$this->info("Creating {$file}");
File::put($file, $output);
} else {
$this->line($output);
}
}
/**
* Handle an incoming request.
*
* @param \Illuminate\Http\Request $request
* @param \Closure $next
* @return mixed
* @throws RedirectException
*/
public function handle($request, Closure $next)
{
$response = $next($request);
$source = $request->get('source', 'api_data');
$filename = $request->get('filename', 'export_' . date('Y-m-d_Hi'));
if ($request->get('download') && array_key_exists($source, $response->original->getData())) {
switch ($request->get('download')) {
case 'json':
return response()->json($response->original->getData()[$source], 200, ['Content-Disposition' => 'attachment; filename="' . $filename . '.json"']);
case 'csv':
$writer = Writer::createFromFileObject(new \SplTempFileObject());
$writer->setDelimiter(',');
$writer->setNewline("\r\n");
$writer->setEncodingFrom("utf-8");
$headers = ['Content-Type' => 'text/csv', 'Content-Disposition' => 'attachment; filename="' . $filename . '.csv"'];
$csv_headers_set = false;
foreach ($response->original->getData()[$source] as $data) {
if (!$csv_headers_set) {
$writer->insertOne(array_keys($this->getArrayRepresentation($data)));
$csv_headers_set = true;
}
$writer->insertOne($this->processData($this->getArrayRepresentation($data)));
}
return response()->make($writer, 200, $headers);
default:
throw RedirectException::make('/')->setError('Unrecognised type to download');
}
}
return $response;
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$this->writeSection($output, 'Po to Csv converter');
$this->cwd = getcwd() . DIRECTORY_SEPARATOR;
$output->writeln('<info>Using CWD</info> ' . $this->cwd);
$poFiles = $this->getInputPoFiles($input, $output);
$outputFolder = $this->getOutputFolder($input, $output);
$useDefaults = $input->getOption('use-defaults');
if ($useDefaults) {
$output->writeln('<info>Po files</info>:');
$this->writeList($output, $poFiles);
$output->writeln(['', '<info>Output folder</info>: ' . $outputFolder]);
}
$poHandles = [];
foreach ($poFiles as $poFile) {
$key = basename($poFile, '.po');
$output->writeln('<info>loading ' . $key . '</info>...');
$poHandles[$key] = Translations::fromPoFile($poFile);
}
$output->writeln('<info>merging po files</info>...');
$csvArray = [];
foreach ($poHandles as $language => $poHandle) {
foreach ($poHandle as $translation) {
$original = trim($translation->original);
$translation = trim($translation->translation);
if (!isset($csvArray[$original])) {
$csvArray[$original] = [$language => $translation];
} elseif (!isset($csvArray[$original][$language])) {
$csvArray[$original][$language] = $translation;
} elseif ($csvArray[$original][$language] != $translation) {
$csvArray[$original][$language] = $this->handleConflict($input, $output, $original, $csvArray[$original][$language], $translation);
}
}
}
$output->writeln('<info>writing csv</info>...');
$writer = Writer::createFromFileObject(new SplTempFileObject());
$writer->setDelimiter(';');
$header = ['original'];
$header = array_merge($header, array_keys($poHandles));
$writer->insertOne($header);
foreach ($csvArray as $original => $item) {
$row = [];
foreach ($header as $column) {
if ($column === 'original') {
$row[] = $original;
} else {
$row[] = isset($item[$column]) ? $item[$column] : null;
}
}
$writer->insertOne($row);
}
$outputFile = $outputFolder . DIRECTORY_SEPARATOR . 'translations.csv';
file_put_contents($outputFile, $writer->__toString());
$output->writeln('<info>done. output file is</info> ' . $outputFile);
}
/**
* @return bool
*/
public function run() : bool
{
// create temporary file:
$this->tempFile();
// necessary for CSV writer:
$fullPath = storage_path('export') . DIRECTORY_SEPARATOR . $this->fileName;
$writer = Writer::createFromPath(new SplFileObject($fullPath, 'a+'), 'w');
$rows = [];
// Count the maximum number of sources and destinations each entry has. May need to expand the number of export fields:
$maxSourceAccounts = 1;
$maxDestAccounts = 1;
/** @var Entry $entry */
foreach ($this->getEntries() as $entry) {
$sources = $entry->sourceAccounts->count();
$destinations = $entry->destinationAccounts->count();
$maxSourceAccounts = max($maxSourceAccounts, $sources);
$maxDestAccounts = max($maxDestAccounts, $destinations);
}
$rows[] = array_keys($this->getFieldsAndTypes($maxSourceAccounts, $maxDestAccounts));
/** @var Entry $entry */
foreach ($this->getEntries() as $entry) {
// order is defined in Entry::getFieldsAndTypes.
$current = [$entry->description, $entry->amount, $entry->date];
$sourceData = $this->getAccountData($maxSourceAccounts, $entry->sourceAccounts);
$current = array_merge($current, $sourceData);
$destData = $this->getAccountData($maxDestAccounts, $entry->destinationAccounts);
$current = array_merge($current, $destData);
$rest = [$entry->budget->budgetId, $entry->budget->name, $entry->category->categoryId, $entry->category->name, $entry->bill->billId, $entry->bill->name];
$current = array_merge($current, $rest);
$rows[] = $current;
}
$writer->insertAll($rows);
return true;
}
/**
* Execute the job.
*
* @return void
*/
public function handle(MergeManager $mergeManager, FileManager $fileManager)
{
$columns = ['PID', 'entity type', 'title', 'document type', 'URL', 'enabled', 'notes', 'format', 'reference', 'order'];
$items = $mergeManager->fetchAll();
$writer = Writer::createFromFileObject(new SplTempFileObject());
$writer->insertOne($columns);
$count = 0;
foreach ($items as $item) {
$row = [$item->object_number, $item->entity_type, $item->object->title, $item->url, $item->enabled, $item->format, $item->representation_order, $item->reference];
$writer->insertOne($row);
$count++;
}
$output = (string) $writer;
$timestamp = Carbon::now();
$fileName = sprintf("import_%s.csv", $timestamp->format('dmY_His'));
$fileManager->saveFile($fileName, $output);
$merger = new Merger();
$merger->filename = $fileName;
$merger->documents = $count;
$merger->save();
$context = new \ZMQContext();
$socket = $context->getSocket(\ZMQ::SOCKET_PUSH, 'my pusher');
$socket->connect("tcp://localhost:5555");
$socket->send('test');
}
/**
* Overload render for array data output
*
* @param \FrenchFrogs\Table\Table\Table $table
* @return array
*/
public function table(Table\Table $table)
{
// INitilisation du CSV
$csv = Writer::createFromFileObject(new \SplTempFileObject());
// gestion des colonne
$header = $columns = [];
foreach ($table->getColumns() as $index => $column) {
// Seule les colonnes Exportable peuvent être exporté
if ($column instanceof Exportable) {
$columns[$index] = $column;
$header[$index] = $column->getLabel();
}
}
// insertion du header
$csv->insertOne(array_values($header));
//@todo mettre en place un streaming pour économiser la memoire
// insertion des lignes
foreach ($table->getRows() as $row) {
$line = [];
foreach (array_keys($header) as $index) {
$line[] = $columns[$index]->getValue($row);
}
$csv->insertOne($line);
}
$csv->output($table->getFilename());
exit;
}
public function exportSelected()
{
$selected_students = Input::get('studentId');
if (is_array($selected_students)) {
//Setup CSV
$csv = \League\Csv\Writer::createFromFileObject(new \SplTempFileObject());
$column_flag = false;
$student = [];
foreach ($selected_students as $student_id) {
$student_data = Students::with('course')->find($student_id);
//Personal data
$student['firstname'] = $student_data['firstname'];
$student['surname'] = $student_data['surname'];
$student['email'] = $student_data['email'];
//Course data
$student['university'] = $student_data->course['university'];
$student['course_name'] = $student_data->course['course_name'];
//Check whether column headers have been set (not ideal for large datasets)
if ($column_flag === false) {
$csv->insertOne(\Schema::getColumnListing('student'));
$column_flag = true;
}
//Add student record to file
$csv->insertOne($student);
}
} else {
return "NO STUDENTS SELECTED";
}
//is_array($selected_students)
$csv->output("selected_student_records.csv");
}
public function run()
{
$commandResult = $this->runCommandPrompt();
$salaryCalendar = SalaryCalendar::get($commandResult['startDate'], $commandResult['endDate'], $commandResult['year']);
$csvWriter = Writer::createFromFileObject(new \SplTempFileObject());
$writer = new CsvFileWriter($csvWriter, $salaryCalendar->calculatePayDays());
$writer->write($commandResult['path'] . DIRECTORY_SEPARATOR . $commandResult['name']);
}
public function testInsertNormalFile()
{
$csv = Writer::createFromPath(__DIR__ . '/foo.csv', 'a+');
$csv->insertOne(['jane', 'doe', '*****@*****.**']);
$iterator = new LimitIterator($csv->getIterator(), 1, 1);
$iterator->rewind();
$this->assertSame(['jane', 'doe', '*****@*****.**'], $iterator->getInnerIterator()->current());
}
/**
* Create CSV file
*
*/
public function __construct()
{
if (empty($filepath)) {
$this->filepath = realpath(dirname(__FILE__) . '/../') . '/' . $this->filename;
}
$this->csv = \League\Csv\Writer::createFromPath(new \SplFileObject($this->filepath, 'w+'), 'w');
$this->csv->insertOne($this->columns);
}
/**
* Exports $result to $file.
*/
public function exportToFile(array $result, $file)
{
$writer = Writer::createFromFileObject(new SplTempFileObject());
foreach ($result['result'] as $row) {
unset($row['_id']);
$writer->insertOne($row);
}
file_put_contents($file, $writer->__toString());
}
public function export()
{
$data = $this->formatData();
$keys = array_keys($data[0]);
$csv = Writer::createFromFileObject(new SplTempFileObject());
$csv->insertOne($keys);
$csv->insertAll($data);
return (string) $csv;
}
public function export()
{
$data = $this->formatData();
$keys = array_keys($data[0]);
$csv = Writer::createFromFileObject(new SplTempFileObject());
$csv->insertOne($keys);
$csv->insertAll($data);
$csv->output($this->getFileName());
}
private function createCsv($inquiryList)
{
$writer = Writer::createFromString("");
$writer->setNewline("\r\n");
foreach ($inquiryList as $inquiry) {
/** @var Inquiry $inquiry */
$writer->insertOne([$inquiry->getId(), $inquiry->getName(), $inquiry->getEmail()]);
}
return (string) $writer;
}
/**
* Show the form for creating a new resource.
*
* @return Response
*/
public function create()
{
$people = bbStock::all();
$csv = \League\Csv\Writer::createFromFileObject(new \SplTempFileObject());
$csv->insertOne(\Schema::getColumnListing('bbstock'));
foreach ($people as $person) {
$csv->insertOne($person->toArray());
}
$csv->output('bbstock.csv');
}
/**
* @throws \RuntimeException
* @param string $file file to write or overwrite
* @param array $data
*/
protected function createFile($file, array $data)
{
$csv = Writer::createFromPath($file, 'w');
$csv->setDelimiter("\t");
$csv->setEnclosure('"');
// we insert the CSV header
$headers = array_keys($data[0]);
$csv->insertOne($headers);
$csv->insertAll($data);
}
public static function export($table, $dbConnection = 'default')
{
$data = DB::connection($dbConnection)->table($table)->get();
$csv = \League\Csv\Writer::createFromFileObject(new \SplTempFileObject());
$csv->insertOne(\Schema::getColumnListing($table));
foreach ($data as $row) {
$csv->insertOne((array) $row);
}
$csv->output($table . '-' . date('YmdHi') . '.csv');
}
public function encode(array $content)
{
$writer = Writer::createFromFileObject(new \SplTempFileObject());
$writer->setDelimiter($this->delimiter);
$writer->setNewline($this->newline);
$writer->setEnclosure($this->enclosure);
$writer->setEscape($this->escapeChar);
$writer->insertAll($content);
return (string) $writer;
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$size = (int) $this->argument('size');
$documents = factory('App\\Models\\Document', $size)->make()->toArray();
$headers = array_keys($documents[0]);
$csv = Writer::createFromFileObject(new SplTempFileObject());
$csv->insertOne($headers);
$csv->insertAll($documents);
Storage::put('testdata/test-' . $size . '.csv', $csv);
}
/**
* Prepare the writer.
*/
public function prepare()
{
if (!$this->csv) {
$this->csv = Writer::createFromFileObject(new SplFileObject($this->filename, 'w'));
$this->csv->setDelimiter($this->delimiter);
$this->csv->setEnclosure($this->enclosure);
}
if ($this->header !== null) {
$this->writeItem($this->header);
}
}
/**
* Converts a data collection to a CSV file.
*/
protected function processExportData($columns, $results, $options)
{
/*
* Validate
*/
if (!$results) {
throw new ApplicationException('There was no data supplied to export');
}
/*
* Parse options
*/
$defaultOptions = ['useOutput' => false, 'fileName' => 'export.csv', 'delimiter' => null, 'enclosure' => null, 'escape' => null];
$options = array_merge($defaultOptions, $options);
$columns = $this->exportExtendColumns($columns);
/*
* Prepare CSV
*/
$csv = CsvWriter::createFromFileObject(new SplTempFileObject());
if ($options['delimiter'] !== null) {
$csv->setDelimiter($options['delimiter']);
}
if ($options['enclosure'] !== null) {
$csv->setEnclosure($options['enclosure']);
}
if ($options['escape'] !== null) {
$csv->setEscape($options['escape']);
}
/*
* Add headers
*/
$headers = $this->getColumnHeaders($columns);
$csv->insertOne($headers);
/*
* Add records
*/
foreach ($results as $result) {
$data = $this->matchDataToColumns($result, $columns);
$csv->insertOne($data);
}
/*
* Output
*/
if ($options['useOutput']) {
$csv->output($options['fileName']);
}
/*
* Save for download
*/
$csvName = uniqid('oc');
$csvPath = temp_path() . '/' . $csvName;
$output = $csv->__toString();
File::put($csvPath, $output);
return $csvName;
}
public function build($keyword)
{
$inquiryList = $this->inquiryRepository->findAllByKeyword($keyword);
/** @var Writer $writer */
$writer = Writer::createFromString("");
$writer->setNewline("\r\n");
foreach ($inquiryList as $inquiry) {
$writer->insertOne([$inquiry->getId(), $inquiry->getName(), $inquiry->getEmail()]);
}
return mb_convert_encoding((string) $writer, $this->encoding, 'UTF-8');
}
/**
* Generates a CSV string from given array data
*
* @param array $data
*
* @throws \RuntimeException
*
* @return string
*/
public function generate(array $data)
{
$writer = Writer::createFromString('');
$writer->setDelimiter($this->delimiter);
$writer->setEnclosure($this->enclosure);
if (!is_array($data[0])) {
$data = [$data];
}
$writer->insertAll($data);
return $writer->__toString();
}
/**
* @param \Madewithlove\Export\Csv\Transformer $transformer
*
* @return \League\Csv\Writer
*/
private function writer(Transformer $transformer = null)
{
$writer = Writer::createFromFileObject(new SplTempFileObject());
if ($transformer instanceof WithHeaders) {
$writer->insertOne($transformer->getHeaders());
}
if ($transformer instanceof Transformer) {
$writer->addFormatter([$transformer, 'transform']);
}
return $writer;
}
function exportCSV($query, $headerArray, $filename)
{
$conn = Connection::getInstance();
$statement = $conn->db->prepare($query);
$statement->setFetchMode(PDO::FETCH_ASSOC);
$statement->execute();
$csv = Writer::createFromFileObject(new SplTempFileObject());
$csv->insertOne($headerArray);
$csv->insertAll($statement);
$csv->output($filename . '.csv');
die;
}
/**
* Create new csv if needed
* and add request data to csv
*
* @param Reservation $reservation
* @return void
*/
private function insertInCsv(Reservation $reservation)
{
$writer = Writer::createFromPath(Config::get('reservation.csv_path'), 'a');
$writer->setDelimiter(";");
$writer->setEncodingFrom("utf-8");
if (!$this->checkIfCsvExists()) {
// Only add header to first line
$headers = ["Naam", "Voornaam", "E-mail", "Bericht", "Toegevoegd op"];
$writer->insertOne($headers);
}
$writer->insertOne(array($reservation->first_name, $reservation->last_name, $reservation->email, $reservation->message, $reservation->created_at->format('d/m/Y H:i')));
}
public function post_export_subscriber_list_members()
{
$csv = \League\Csv\Writer::createFromFileObject(new \SplTempFileObject());
$columns = array("List Name", "Count Openers", "Count Clickers", "Count Active", "Count Unsubscribers", "Count Bounce", "Count Total", "Last Activity");
$csv->insertOne($columns);
$baseQuery = DB::table('subscribers_lists')->leftjoin('subscribers_lists_subscribers', 'subscribers_lists.id', '=', 'subscribers_lists_subscribers.subscribers_list_id')->leftjoin('subscribers', 'subscribers_lists_subscribers.subscriber_id', '=', 'subscribers.id')->select('subscribers_lists.name', 'subscribers_lists.id as count_openers', 'subscribers_lists.id as count_clickers', DB::raw('count(case when subscribers.status = "Active" then 1 else null end) as count_active'), DB::raw('count(case when subscribers.status = "Unsubscribed" then 1 else null end) as count_unsubsribers'), DB::raw('count(case when subscribers.status = "Bounced" then 1 else null end) as count_bounced'), DB::raw('count(subscribers_lists_subscribers.subscribers_list_id) as count_total'), 'subscribers_lists.updated_at as last_activity')->whereNull('subscribers_lists.webinar_id')->groupBy('subscribers_lists.id')->get();
foreach ($baseQuery as $value) {
$temp_data = array($value->name, $value->count_openers, $value->count_clickers, $value->count_active, $value->count_unsubsribers, $value->count_bounced, $value->count_total, $value->last_activity);
$csv->insertOne($temp_data);
}
$current_time = Carbon::now();
$csv->output('subscriber_list_members_' . $current_time->toDateTimeString() . '.csv');
}
/**
* Обработка данных и создание нового файла.
*/
public function handleData()
{
try {
$this->reader = Reader::createFromPath($this->pathToReadFile);
$this->writer = Writer::createFromPath($this->pathToWriteFile);
$this->setReadableData();
$this->setFormattedData();
$this->writer->insertAll($this->generateInsertData());
echo 'Data was handled and written to file ' . $this->pathToWriteFile, PHP_EOL;
} catch (\Exception $exception) {
echo $exception->getMessage(), PHP_EOL;
}
}
/**
* @inheritdoc
*/
public function result(AnalysisResult $result)
{
$writer = Writer::createFromString('');
$writer->insertOne(['File', 'Line', 'Tool', 'Type', 'Message']);
foreach ($result->toArray() as $fileName => $lines) {
foreach ($lines as $lineNumber => $issues) {
foreach ($issues as $issue) {
$writer->insertOne([$fileName, $lineNumber, $issue['tool'], $issue['type'], trim($issue['message'])]);
}
}
}
$csv = ltrim($writer->__toString());
$this->cli->out($csv);
}
public function download()
{
$col = new Collection(Request::input('data'));
//dd();
//we create the CSV into memory
$csv = Writer::createFromFileObject(new SplTempFileObject());
$csv->insertAll($col);
// Because you are providing the filename you don't have to
// set the HTTP headers Writer::output can
// directly set them for you
// The file is downloadable
$csv->output(Request::input('id') . '.csv');
die;
}
