public function testWriteUtf8Item()
{
$writer = new CsvWriter(';', '"', $this->getStream(), true);
$writer->prepare();
$writer->writeItem(array('Précédent', 'Suivant'));
$this->assertContentsEquals(chr(0xef) . chr(0xbb) . chr(0xbf) . "Précédent;Suivant\n", $writer);
$writer->finish();
}
public function testWriteItem()
{
$writer = new CsvWriter(';', '"', $this->getStream());
$writer->writeItem(array('first', 'last'));
$writer->writeItem(array('first' => 'James', 'last' => 'Bond'))->writeItem(array('first' => '', 'last' => 'Dr. No'));
$this->assertContentsEquals("first;last\nJames;Bond\n;\"Dr. No\"\n", $writer);
$writer->finish();
}
/**
* Test that column names prepended at first row
* and values have been written at second line
* if CsvWriter's 5-th parameter set to true
*
* @author Igor Mukhin <*****@*****.**>
*/
public function testHeaderPrependedWhenOptionSetToTrue()
{
$writer = new CsvWriter(';', '"', $this->getStream(), false, true);
$writer->prepare();
$writer->writeItem(array('col 1 name' => 'col 1 value', 'col 2 name' => 'col 2 value', 'col 3 name' => 'col 3 value'));
# Column names should be at second line
# Values should be at second line
$this->assertContentsEquals("\"col 1 name\";\"col 2 name\";\"col 3 name\"\n" . "\"col 1 value\";\"col 2 value\";\"col 3 value\"\n", $writer);
$writer->finish();
}
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$loader = LoaderFactory::make('csv');
$loader->setFile('test/names.csv');
$loader->load();
$data = $loader->getData();
$normalized = [];
foreach ($data as $key => $row) {
$normalized[$row['country']]['country'] = $row['country'];
$normalized[$row['country']]['cities'][$row['city']]['city'] = $row['city'];
$normalized[$row['country']]['cities'][$row['city']]['people'][$key] = array_only($row, ['first', 'last']);
}
$countries = [];
$cities = [];
$people = [];
$idCountry = 1;
$idCity = 1;
$idPerson = 1;
foreach ($normalized as $keyCountry => $valueCountry) {
$countries[] = ['id' => $keyCountry + 1, 'country' => $valueCountry['country']];
foreach ($valueCountry['cities'] as $keyCity => $valueCity) {
$cities[] = ['id' => $idCity, 'city' => $valueCity['city'], 'country' => $idCountry];
foreach ($valueCity['people'] as $keyPerson => $valuePerson) {
$people[] = ['id' => $idPerson, 'first' => $valuePerson['first'], 'last' => $valuePerson['last'], 'city' => $idCity];
$idPerson++;
}
$idCity++;
}
$idCountry++;
}
$writer = new CsvWriter(',');
$writer->setStream(fopen(storage_path('test/norm_countries.csv'), 'w'));
$writer->writeItem(array('id', 'country'));
foreach ($countries as $key => $value) {
$writer->writeItem($value);
}
$writer->finish();
$writer = new CsvWriter(',');
$writer->setStream(fopen(storage_path('test/norm_cities.csv'), 'w'));
$writer->writeItem(array('id', 'city', 'country'));
foreach ($cities as $key => $value) {
$writer->writeItem($value);
}
$writer->finish();
$writer = new CsvWriter(',');
$writer->setStream(fopen(storage_path('test/norm_people.csv'), 'w'));
$writer->writeItem(array('id', 'first', 'last', 'city'));
foreach ($people as $key => $value) {
$writer->writeItem($value);
}
$writer->finish();
dd($normalized);
}
/**
* Export tabular data to CSV-file
* @param array $data
* @param string $filename
*/
public static function arrayToCsv($data, $filename = 'export')
{
if (empty($data)) {
return false;
}
$filePath = api_get_path(SYS_ARCHIVE_PATH) . uniqid('') . '.csv';
$writer = new CsvWriter();
$writer->setStream(fopen($filePath, 'w'));
foreach ($data as $item) {
$writer->writeItem($item);
}
$writer->finish();
DocumentManager::file_send_for_download($filePath, true, $filename . '.csv');
exit;
}
/**
* CsvWriter constructor.
* @param Configuration $config
*/
public function __construct(Configuration $config)
{
$filename = $config->get(array('filename'));
$delimiter = $config->get(array('delimiter'), ',');
$enclosure = $config->get(array('enclosure'), '"');
$utf8 = $config->get(array('utf8'), true);
parent::__construct($delimiter, $enclosure, fopen($filename, 'w'), $utf8);
}
/**
* creates a csv
* @param array $data simple array of csv data
* @param string $outputFileLocation file location
* @param string $delimiter
* @param array $header header fields
* @return bool false if unable to write to folder
*/
function createCsv($data, $outputFileLocation, $delimiter = ',', $header = [])
{
if (!is_writable(dirname($outputFileLocation))) {
echo 'Unable to create file ' . $outputFileLocation . ' . Please check write permissions for your web server (apache/nginx/..)' . $GLOBALS["newline"];
return false;
} else {
$writer = new CsvWriter($delimiter);
$writer->setStream(fopen($outputFileLocation, 'w'));
foreach ($data as $col) {
if (empty($header)) {
$header = array_keys($col);
$writer->writeItem($header);
}
$writer->writeItem($col);
}
$writer->finish();
$filePermissions = $GLOBALS['filePermissions'];
chmod($outputFileLocation, $filePermissions);
}
}
public function write()
{
$adapter = new Adapter("/");
$filesystem = new Filesystem($adapter);
if ( ! $filesystem->has($this->path)) {
$filesystem->createDir($this->path);
}
$filename = $this->path . $this->getFileName();
$writer = new CsvWriter( "," );
$writer->setStream( fopen( $filename, 'w' ) );
$header = $this->getPrologHeader();
if ($this->includeProlog) {
$header[ 1 ][ 0 ] = 'uri';
ksort($header[1]);
$header[ 2 ][ 0 ] = 'lang';
$header[ 2 ][ 1 ] = $this->getSchema()->getLanguage(); //default language
ksort($header[2]);
$header[ 3 ][ 0 ] = 'type';
$header[ 3 ][ 1 ] = 'uri'; //default type
ksort($header[3]);
}
foreach ( $header as $line )
{
$writer->writeItem( $line );
}
if ($this->includeProlog) {
$metadata = $this->getMetadata();
foreach ($metadata as $line) {
$writer->writeItem($line);
}
$prefixRows = $this->getPrefixRows();
foreach ($prefixRows as $line) {
$writer->writeItem($line);
}
}
//get the data
if ( $this->populate )
{
$prefixes = $this->getPrefixes();
$prefixPattern = array();
$prefixReplacement = array();
foreach ( $prefixes as $prefix => $namespace )
{
if (trim($prefix)) {
if ( ! is_int($prefix)) {
$prefixPattern[] = "|" . $namespace . "|";
$prefixReplacement[] = $prefix . ":";
}
}
}
$map = $this->getHeaderMap();
$c = new \Criteria();
$c->clearSelectColumns();
if ('schema' === $this->type) {
$c->addSelectColumn(\SchemaPropertyPeer::ID);
$c->add(\SchemaPropertyPeer::SCHEMA_ID, $this->schema->getId());
if ($this->excludeDeprecated) {
$c->add(\SchemaPropertyPeer::STATUS_ID, 8, \Criteria::NOT_EQUAL);
}
$c->addAscendingOrderByColumn(\SchemaPropertyPeer::URI);
$properties = \SchemaPropertyPeer::doSelectRS($c);
} else {
$c->addSelectColumn(\ConceptPeer::ID);
$c->addSelectColumn(\ConceptPeer::URI);
$c->addSelectColumn(\ConceptPeer::STATUS_ID);
$c->add(\ConceptPeer::VOCABULARY_ID, $this->schema->getId());
if ($this->excludeDeprecated) {
$c->add(\ConceptPeer::STATUS_ID, 8, \Criteria::NOT_EQUAL);
}
$c->addAscendingOrderByColumn(\ConceptPeer::URI);
$properties = \ConceptPeer::doSelectRS($c);
}
foreach ( $properties as $property )
{
$line = array_fill( 0, $this->getHeaderCount(), '' );
$line[0] = $property[0];
$map = $this->getHeaderMap();
$ce = new \Criteria();
if ('schema' === $this->type) {
$ce->add(\BaseSchemaPropertyElementPeer::SCHEMA_PROPERTY_ID, $property[0]);
if (!$this->includeDeleted) {
$ce->add(\BaseSchemaPropertyElementPeer::DELETED_AT, null);
}
if ($this->includeDeleted) {
$ce->addAscendingOrderByColumn(\SchemaPropertyElementPeer::UPDATED_AT);
}
$elements = \SchemaPropertyElementPeer::doSelectJoinProfileProperty($ce);
} else {
$ce->add(\ConceptPropertyPeer::CONCEPT_ID, $property[0]);
if (!$this->includeDeleted) {
$ce->add(\ConceptPropertyPeer::DELETED_AT, null);
}
if ($this->includeDeleted) {
$ce->addAscendingOrderByColumn(\ConceptPropertyPeer::UPDATED_AT);
}
$elements = \ConceptPropertyPeer::doSelectJoinProfilePropertyRelatedBySkosPropertyId($ce);
$line[array_search('uri', $header[0])] = $property[1];
$line[array_search('status', $header[0])] = $property[2];
}
/** @var \SchemaPropertyElement $element */
foreach ($elements as $element )
{
if ($this->excludeGenerated and $element->getIsGenerated()) {
continue;
}
/** @var \ProfileProperty $profileProperty */
$profileProperty = $element->getProfileProperty();
$propertyId = $profileProperty->getId();
if ('schema' === $this->type and in_array( $propertyId, [ 6, 9, ] ) and $element->getIsSchemaProperty() )
{
$language = 'parent';
}
else
{
$language = $profileProperty->getHasLanguage() ? $element->getLanguage() : '';
}
$index = $propertyId . $language;
if (isset($map[ $index ])) {
foreach ($map[ $index ] as &$column) {
if (false !== $column) {
$line[ $column ] = $element->getObject();
$column = false;
break;
}
}
}
}
$writer->writeItem( preg_replace( $prefixPattern, $prefixReplacement, $line ));
unset($line, $elements);
}
}
//add an empty line at the end
$line = array_fill( 0, $this->getHeaderCount(), '' );
$writer->writeItem( $line );
$writer->finish();
}
/**
* CSV do relatório detalhado
*
* @param Request $request
* @return BinaryFileResponse
* @throws \Ddeboer\DataImport\Exception\ExceptionInterface
* @throws \Exception
*/
public function detalharCsvAction(Request $request)
{
$locale = $request->getLocale();
$em = $this->getDoctrine()->getManager();
$idRelatorio = $request->get('softwares');
$nomeRelatorio = $request->get('nomeRelatorio');
$idLocal = $request->get('locais');
$idRede = $request->get('redes');
$idSo = $request->get('so');
$filtros = array('softwares' => $idRelatorio, 'nomeRelatorio' => $nomeRelatorio, 'locais' => $idLocal, 'redes' => $idRede, 'so' => $idSo);
$saida = array();
if (is_array($idRelatorio) && !empty($idRelatorio)) {
foreach ($idRelatorio as $elm) {
$relatorio = $em->getRepository("CacicCommonBundle:SoftwareRelatorio")->find($elm);
if (!empty($relatorio)) {
array_push($saida, $relatorio);
}
}
} elseif (!empty($idRelatorio)) {
$relatorio = $em->getRepository("CacicCommonBundle:SoftwareRelatorio")->find($idRelatorio);
if (!empty($relatorio)) {
array_push($saida, $relatorio);
}
}
if (is_array($nomeRelatorio) && !empty($nomeRelatorio)) {
foreach ($nomeRelatorio as $elm) {
$relatorio = $em->getRepository("CacicCommonBundle:SoftwareRelatorio")->findOneBy(array('nomeRelatorio' => $elm));
if (!empty($relatorio)) {
array_push($saida, $relatorio);
}
}
} elseif (!empty($nomeRelatorio)) {
$relatorio = $em->getRepository("CacicCommonBundle:SoftwareRelatorio")->findOneBy(array('nomeRelatorio' => $nomeRelatorio));
if (!empty($relatorio)) {
array_push($saida, $relatorio);
}
}
$dados = $em->getRepository("CacicCommonBundle:SoftwareRelatorio")->gerarRelatorioDetalharCsv($filtros);
// Gera CSV
$reader = new ArrayReader($dados);
// Create the workflow from the reader
$workflow = new Workflow($reader);
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('dtHrUltAcesso', $converter);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Relatorio-Software-Detalhado.csv');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('Computador', 'MAC Address', 'Endereço IP', 'Sistema Operacional', 'Local', 'Ip da Rede', 'Nome da Rede', 'Data/Hora do Último Acesso'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="Relatório-Software-Detalhado.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
public function semColetaDetalharCsvAction(Request $request)
{
$em = $this->getDoctrine()->getManager();
$locale = $request->getLocale();
$idSo = $request->get('idSo');
$idRede = $request->get('idRede');
$idLocal = $request->get('idLocal');
$idClasse = $request->get('idClasse');
$computadores = $em->getRepository("CacicCommonBundle:Computador")->detalharClasseCsv($idClasse, $idRede, $idLocal, $idSo);
// Gera CSV
$reader = new ArrayReader($computadores);
// Create the workflow from the reader
$workflow = new Workflow($reader);
// As you can see, the first names are not capitalized correctly. Let's fix
// that with a value converter:
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('dtHrUltAcesso', $converter);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Computadores-Subredes');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('Computador', 'MAC Address', 'Endereço IP', 'SO', 'Local', 'Sub Rede', 'Data e Hora do último Acesso'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="WMI-sem-coleta.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
public function importCsv($daysAgo, $analyzeCache)
{
if (!$analyzeCache) {
$this->downloadReports($daysAgo);
}
$files = glob($this->download_directory . '*');
// get all file names
$shadow_server_csv_rows = array();
foreach ($files as $file) {
// iterate files
if (is_file($file)) {
$csv_file = new \SplFileObject($file);
$reader = new CsvReader($csv_file);
$reader->setHeaderRowNumber(0);
foreach ($reader as $row) {
$header = array_keys($row);
$array_reader = new ArrayReader(array($row));
$workflow = new Workflow($array_reader);
$writer = new CsvWriter();
$shadow_server_report_evidence = '/tmp/' . uniqid('shadow_server_report_evidence') . ".csv";
touch($shadow_server_report_evidence);
chmod($shadow_server_report_evidence, 0777);
$writer->setStream(fopen($shadow_server_report_evidence, 'w'));
$writer->writeItem($header);
$workflow->addWriter($writer);
$workflow->process();
$reportType = $this->shadow_server_report_type_factory->getReportTypeFromCsvRow($row, $file, $shadow_server_report_evidence);
if ($reportType) {
$shadow_server_csv_rows[] = $reportType;
}
}
}
}
return $shadow_server_csv_rows;
}
public function desativadosGeralCsvAction(Request $request)
{
$locale = $request->getLocale();
$logger = $this->get('logger');
$filtros = $request->request->all();
$dados = $this->getDoctrine()->getRepository('CacicCommonBundle:ComputadorColeta')->gerarRelatorioDesativadosCsv($filtros);
// Gera CSV
$reader = new ArrayReader($dados);
// Create the workflow from the reader
$workflow = new Workflow($reader);
// As you can see, the first names are not capitalized correctly. Let's fix
// that with a value converter:
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
//$workflow->addValueConverter('dataExclusao', $converter);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Computadores-Subredes');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('ID do Computador', 'Computador', 'MAC Address', 'Endereço IP', 'SO', 'Local', 'Subrede', 'IP da Subrede', 'Classe de Coleta', 'Propriedade', 'Valor', 'Data e Hora da Remoção'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="WMI-sem-coleta.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
public function consolidadoCsvAction(Request $request)
{
$em = $this->getDoctrine()->getManager();
$locale = $request->getLocale();
$so_lista = $em->getRepository('CacicCommonBundle:Computador')->countPorSOCsv();
// Gera CSV
$reader = new ArrayReader($so_lista);
// Create the workflow from the reader
$workflow = new Workflow($reader);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('dtHrUltAcesso', $converter);
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Computadores-lista');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('Sistema Operacional', 'Total de Estações'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="So-Consolidado.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
/**
* Generate a CSV file
*
* @Route("/csv", name="printer_csv")
*
*/
public function csvAction(Request $request)
{
ini_set('memory_limit', '1024M');
gc_enable();
$data = new \DateTime();
$em = $this->getDoctrine()->getManager();
$form = $request->query->get('form');
if ($form) {
$start = new \DateTime($form['startDate']);
$startcsv = $start->format('d/m/Y');
$start = $start->format('U');
$end = new \DateTime($form['endDate']);
$end->setTime('23', '59', '59');
$endcsv = $end->format('d/m/Y');
$end = $end->format('U');
}
$start = isset($start) ? $start : time() - 60 * 60 * 24 * 30;
$end = isset($end) ? $end : time();
$printers = $em->getRepository('CocarBundle:PrinterCounter')->relatorioCsvGeral($start, $end);
// Gera cabeçalho
$cabecalho = array();
foreach ($printers as $elm) {
array_push($cabecalho, array_keys($elm));
break;
}
// Adiciona contagem no cabeçalho
array_push($cabecalho[0], 'totalPrints');
// Gera CSV
$reader = new ArrayReader(array_merge($cabecalho, $printers));
// Gera CSV
//$reader = new ArrayReader($printers);
// Create the workflow from the reader
$workflow = new Workflow($reader);
$data = new \DateTime();
// Contador geral das impressorasa
$converter = new CallbackItemConverter(function ($item) {
if (array_key_exists('printsEnd', $item) && array_key_exists('printsStart', $item)) {
$item['totalPrints'] = $item['printsEnd'] - $item['printsStart'];
} else {
$item['totalPrints'] = null;
}
return $item;
});
$workflow->addItemConverter($converter);
// As you can see, the first names are not capitalized correctly. Let's fix
// that with a value converter:
//$converter = new CallbackValueConverter(function ($input) {
// return date('d/m/Y', $input);
//});
//$workflow->addValueConverter('endDate', $converter);
//$workflow->addValueConverter('startDate', $converter);
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'impressoras');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('', 'Relatório gerado em', $data->format('d/m/Y'), $data->format('H:i:s')));
$writer->writeItem(array('', 'Data Inicial:', $startcsv, '00:00:00'));
$writer->writeItem(array('', 'Data Final:', $endcsv, '23:59:59'));
$writer->writeItem(array(''));
#$writer->writeItem(array('Id', 'Nome','Host','Serie','Local','Contador Inicial','Contador Final','Impressões'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="impressoras.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
/**
* CSV do usuário logado por computador
*
* @param Request $request
* @param $idComputador
* @return BinaryFileResponse
* @throws \Ddeboer\DataImport\Exception\ExceptionInterface
* @throws \Exception
*/
public function logUsuarioCsvAction(Request $request, $idComputador)
{
$em = $this->getDoctrine()->getManager();
$locale = $request->getLocale();
$dataInicio = $request->get('dataInicio');
$dataFim = $request->get('dataFim');
$dados = $em->getRepository("CacicCommonBundle:LogUserLogado")->computadorData($idComputador, $dataInicio, $dataFim)->getArrayResult();
// Gera CSV
$reader = new ArrayReader($dados);
// Create the workflow from the reader
$workflow = new Workflow($reader);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('data', $converter);
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Computadores-lista');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('idLogAcesso', 'Data/Hora', 'Usuário'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="Log-Acesso-' . $idComputador . '.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
public function usuarioCsvDinamicoAction(Request $request)
{
if ($request->isMethod('POST')) {
$dataInicio = $request->get('dtAcaoInicio');
$dataFim = $request->get('dtAcaoFim');
$usuarioLogado = $request->get('usuarioLogado');
$macCompDinamico = $request->get('macCompDinamico');
$ipCompDinamico = $request->get('ipCompDinamico');
/*
* Verifica se existe filtro por data do CSV
*/
if (empty($dataInicio)) {
error_log("333333333333333333333333333333333333333");
$semData = 'S';
$dados = $this->getDoctrine()->getRepository('CacicCommonBundle:LogUserLogado')->gerarRelatorioUsuarioHistorico($usuarioLogado, $semData);
} else {
$semData = 'N';
$dados = $this->getDoctrine()->getRepository('CacicCommonBundle:LogUserLogado')->gerarRelatorioUsuarioHistorico($usuarioLogado, $dataFim, $dataInicio, $semData, $macCompDinamico, $ipCompDinamico);
}
}
// Gera CSV
$reader = new ArrayReader($dados);
// Create the workflow from the reader
$workflow = new Workflow($reader);
// As you can see, the first names are not capitalized correctly. Let's fix
// that with a value converter:
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('dtHrUltAcesso', $converter);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'usuario_estatico_');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
if ($semData == 'S') {
$writer->writeItem(array('Nome computador', 'Mac Address', 'IP computador', 'Local', 'Sub Rede', 'Usuário', 'Data', 'ID Computador'));
} else {
$writer->writeItem(array('Nome computador', 'Mac Address', 'IP computador', 'Local', 'Sub Rede', 'CPF Responsável', 'Data Pup-up', 'Usuário', 'Data', 'ID Computador'));
}
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Gera data e adiciona no nome do arquivo
$today = date("Ymd");
$nameArquivo = "usuario_dinamico_" . $today . ".csv";
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename=' . $nameArquivo . '');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
/**
* CSV da lista de computadores
*
* @param Request $request
* @param null $idRede ID da Rede
* @return BinaryFileResponse
* @throws \Ddeboer\DataImport\Exception\ExceptionInterface
* @throws \Exception
*/
public function listarDetalhadoCsvAction(Request $request, $idRede = null)
{
$dataInicio = $request->get('dataInicio');
$dataFim = $request->get('dataFim');
$locale = $request->getLocale();
$dados = $this->getDoctrine()->getRepository('CacicCommonBundle:Computador')->gerarRelatorioComputadoresCsv($filtros = array(), $idRede, $dataInicio, $dataFim);
if (!empty($idRede)) {
$rede = $dados[0]['nmRede'];
} else {
$rede = null;
}
// Gera CSV
$reader = new ArrayReader($dados);
// Create the workflow from the reader
$workflow = new Workflow($reader);
$workflow->addValueConverter("reader", new CharsetValueConverter('UTF-8', $reader));
$converter = new CallbackValueConverter(function ($input) {
return $input->format('d/m/Y H:m:s');
});
$workflow->addValueConverter('dtHrUltAcesso', $converter);
// Add the writer to the workflow
$tmpfile = tempnam(sys_get_temp_dir(), 'Computadores-lista');
$file = new \SplFileObject($tmpfile, 'w');
$writer = new CsvWriter($file);
$writer->writeItem(array('Computador', 'Mac Address', 'Endereço IP', 'Sistema Operacional', 'Local', 'Subrede', 'IP Subrede', 'Data/Hora do Ùltimo Acesso'));
$workflow->addWriter($writer);
// Process the workflow
$workflow->process();
// Retorna o arquivo
$response = new BinaryFileResponse($tmpfile);
$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="Computadores.csv"');
$response->headers->set('Content-Transfer-Encoding', 'binary');
return $response;
}
