public function testRun()
{
$quote = DatabaseCompatibilityUtil::getQuote();
//Create 2 export items, and set one with a date over a week ago (8 days ago) for the modifiedDateTime
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = 'test';
$exportItem->modelClassName = 'Account';
$exportItem->serializedData = serialize(array('test', 'test2'));
$this->assertTrue($exportItem->save());
$fileContent = new FileContent();
$fileContent->content = 'test';
$exportFileModel = new ExportFileModel();
$exportFileModel->fileContent = $fileContent;
$exportFileModel->name = $exportItem->exportFileName . ".csv";
$exportFileModel->type = 'application/octet-stream';
$exportFileModel->size = strlen($fileContent->content);
$this->assertTrue($exportFileModel->save());
$exportFileModel1Id = $exportFileModel->id;
$exportItem->exportFileModel = $exportFileModel;
$this->assertTrue($exportItem->save());
$modifiedDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime(time() - 60 * 60 * 24 * 8);
$sql = "Update item set modifieddatetime = '" . $modifiedDateTime . "' where id = " . $exportItem->getClassId('Item');
ZurmoRedBean::exec($sql);
// Second exportItem, that shouldn't be deleted.
$exportItem2 = new ExportItem();
$exportItem2->isCompleted = 0;
$exportItem2->exportFileType = 'csv';
$exportItem2->exportFileName = 'test';
$exportItem2->modelClassName = 'Account';
$exportItem2->serializedData = serialize(array('test', 'test2'));
$this->assertTrue($exportItem2->save());
$fileContent2 = new FileContent();
$fileContent2->content = 'test';
$exportFileModel2 = new ExportFileModel();
$exportFileModel2->fileContent = $fileContent2;
$exportFileModel2->name = $exportItem->exportFileName . ".csv";
$exportFileModel2->type = 'application/octet-stream';
$exportFileModel2->size = strlen($fileContent->content);
$this->assertTrue($exportFileModel2->save());
$exportFileModel2Id = $exportFileModel2->id;
$exportItem2->exportFileModel = $exportFileModel2;
$this->assertTrue($exportItem2->save());
$job = new ExportCleanupJob();
$this->assertTrue($job->run());
$exportItems = ExportItem::getAll();
$this->assertEquals(1, count($exportItems));
$this->assertEquals($exportItem2->id, $exportItems[0]->id);
}
/**
* Cancels export.
* @param int $id
*/
public function actionCancel($id)
{
$exportItem = ExportItem::getById(intval($id));
$exportItem->cancelExport = true;
$exportItem->save();
$this->redirect(Yii::app()->createUrl('export/default/list'));
}
/**
* Test if background export job generated csv file,
* check if content of this csv file is correct, and
* finally check if user got notification message that
* his downloads are completed.
*/
public function testRun()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$numberOfUserNotifications = Notification::getCountByTypeAndUser('ExportProcessCompleted', Yii::app()->user->userModel);
$account = new Account();
$account->owner = $super;
$account->name = 'Test Account';
$account->officePhone = '1234567890';
$this->assertTrue($account->save());
$account = new Account();
$account->owner = $super;
$account->name = 'Test Account 2';
$account->officePhone = '1234567899';
$this->assertTrue($account->save());
$account = new Account(false);
$searchForm = new AccountsSearchForm($account);
$dataProvider = ExportTestHelper::makeRedBeanDataProvider($searchForm, 'Account', 0, Yii::app()->user->userModel->id);
$totalItems = $dataProvider->getTotalItemCount();
$this->assertEquals(2, $totalItems);
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = 'test';
$exportItem->modelClassName = 'Account';
$exportItem->serializedData = serialize($dataProvider);
$this->assertTrue($exportItem->save());
$id = $exportItem->id;
$exportItem->forget();
unset($exportItem);
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItem = ExportItem::getById($id);
$fileModel = $exportItem->exportFileModel;
$this->assertEquals(1, $exportItem->isCompleted);
$this->assertEquals('csv', $exportItem->exportFileType);
$this->assertEquals('test', $exportItem->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
// Get csv string via regular csv export process(directly, not in background)
// We suppose that csv generated thisway is corrected, this function itself
// is tested in another test.
$data = array();
$rows = $dataProvider->getData();
$modelToExportAdapter = new ModelToExportAdapter($rows[0]);
$headerData = $modelToExportAdapter->getHeaderData();
foreach ($rows as $model) {
$modelToExportAdapter = new ModelToExportAdapter($model);
$data[] = $modelToExportAdapter->getData();
}
$output = ExportItemToCsvFileUtil::export($data, $headerData, 'test.csv', false);
$this->assertEquals($output, $fileModel->fileContent->content);
// Check if user got notification message, and if its type is ExportProcessCompleted
$this->assertEquals($numberOfUserNotifications + 1, Notification::getCountByTypeAndUser('ExportProcessCompleted', Yii::app()->user->userModel));
}
public function run()
{
$exportItems = ExportItem::getUncompletedItems();
if (count($exportItems) > 0) {
foreach ($exportItems as $exportItem) {
if (isset($exportItem->exportFileModel)) {
//continue;
}
$unserializedData = unserialize($exportItem->serializedData);
if ($unserializedData instanceof RedBeanModelDataProvider) {
$formattedData = $unserializedData->getData();
} else {
$formattedData = array();
foreach ($unserializedData as $idToExport) {
$model = call_user_func(array($exportItem->modelClassName, 'getById'), intval($idToExport));
$formattedData[] = $model;
}
}
if ($exportItem->exportFileType == 'csv') {
$headerData = array();
foreach ($formattedData as $model) {
if (ControllerSecurityUtil::doesCurrentUserHavePermissionOnSecurableItem($model, Permission::READ)) {
$modelToExportAdapter = new ModelToExportAdapter($model);
if (count($headerData) == 0) {
$headerData = $modelToExportAdapter->getHeaderData();
}
$data[] = $modelToExportAdapter->getData();
}
}
$output = ExportItemToCsvFileUtil::export($data, $headerData);
$fileContent = new FileContent();
$fileContent->content = $output;
$exportFileModel = new ExportFileModel();
$exportFileModel->fileContent = $fileContent;
$exportFileModel->name = $exportItem->exportFileName . ".csv";
$exportFileModel->type = 'application/octet-stream';
$exportFileModel->size = strlen($output);
$saved = $exportFileModel->save();
if ($saved) {
$exportItem->isCompleted = 1;
$exportItem->exportFileModel = $exportFileModel;
$exportItem->save();
$message = new NotificationMessage();
$message->htmlContent = Zurmo::t('ExportModule', 'Export of {fileName} requested on {dateTime} is completed. <a href="{url}">Click here</a> to download file!', array('{fileName}' => $exportItem->exportFileName, '{url}' => Yii::app()->createUrl('export/default/download', array('id' => $exportItem->id)), '{dateTime}' => DateTimeUtil::convertDbFormattedDateTimeToLocaleFormattedDisplay($exportItem->createdDateTime, 'long')));
$rules = new ExportProcessCompletedNotificationRules();
NotificationsUtil::submit($message, $rules);
}
}
}
} else {
return true;
}
return true;
}
public function actionDownload($id)
{
try {
$exportItem = ExportItem::getById((int) $id);
if ($exportItem instanceof ExportItem) {
$fileModel = $exportItem->exportFileModel;
Yii::app()->request->sendFile($fileModel->name, $fileModel->fileContent->content, $fileModel->type, false);
}
} catch (Exception $e) {
Yii::app()->user->setFlash('notification', Zurmo::t('ExportModule', 'Export file you requested is not available anymore.'));
$this->redirect(Yii::app()->createUrl('home/default/index'));
}
}
/**
* Get all exportItems where the modifiedDateTime was more than 1 week ago. Then
* delete these exports and related files(and ).
* (non-PHPdoc)
* @see BaseJob::run()
*/
public function run()
{
$oneWeekAgoTimeStamp = DateTimeUtil::convertTimestampToDbFormatDateTime(time() - 60 * 60 * 24 * 7);
$searchAttributeData = array();
$searchAttributeData['clauses'] = array(1 => array('attributeName' => 'modifiedDateTime', 'operatorType' => 'lessThan', 'value' => $oneWeekAgoTimeStamp));
$searchAttributeData['structure'] = '1';
$joinTablesAdapter = new RedBeanModelJoinTablesQueryAdapter('ExportItem');
$where = RedBeanModelDataProvider::makeWhere('ExportItem', $searchAttributeData, $joinTablesAdapter);
$oldExportItems = ExportItem::getSubset($joinTablesAdapter, null, self::$pageSize, $where, null);
foreach ($oldExportItems as $exportItem) {
$exportItem->delete();
}
return true;
}
/**
* @depends testCreateActionForRowsAndColumns
*/
public function testExportAction()
{
$notificationsBeforeCount = Notification::getCount();
$notificationMessagesBeforeCount = NotificationMessage::getCount();
$savedReports = SavedReport::getAll();
$this->assertEquals(2, count($savedReports));
$this->setGetArray(array('id' => $savedReports[0]->id));
//Test where there is no data to export
$this->runControllerWithRedirectExceptionAndGetContent('reports/default/export');
$this->assertContains('There is no data to export.', Yii::app()->user->getFlash('notification'));
$reportModelTestItem = new ReportModelTestItem();
$reportModelTestItem->string = 'string1';
$reportModelTestItem->lastName = 'xLast1';
$this->assertTrue($reportModelTestItem->save());
$reportModelTestItem = new ReportModelTestItem();
$reportModelTestItem->string = 'string2';
$reportModelTestItem->lastName = 'xLast2';
$this->assertTrue($reportModelTestItem->save());
$content = $this->runControllerWithExitExceptionAndGetContent('reports/default/export');
$this->assertEquals('Testing download.', $content);
ExportModule::$asynchronousThreshold = 1;
$this->runControllerWithRedirectExceptionAndGetUrl('reports/default/export');
// Start background job
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItems = ExportItem::getAll();
$this->assertEquals(1, count($exportItems));
$fileModel = $exportItems[0]->exportFileModel;
$this->assertEquals(1, $exportItems[0]->isCompleted);
$this->assertEquals('csv', $exportItems[0]->exportFileType);
$this->assertEquals('reports', $exportItems[0]->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
$this->assertEquals($notificationsBeforeCount + 1, Notification::getCount());
$this->assertEquals($notificationMessagesBeforeCount + 1, NotificationMessage::getCount());
}
/**
* Walkthrough test for synchronous download
*/
public function testAsynchronousDownloadDefaultControllerActions()
{
$super = $this->logoutCurrentUserLoginNewUserAndGetByUsername('super');
$notificationsBeforeCount = Notification::getCount();
$notificationMessagesBeforeCount = NotificationMessage::getCount();
$products = Product::getAll();
if (count($products)) {
foreach ($products as $product) {
$product->delete();
}
}
$products = array();
for ($i = 0; $i <= ExportModule::$asynchronousThreshold + 1; $i++) {
$products[] = ProductTestHelper::createProductByNameForOwner('superProduct' . $i, $super);
}
$this->setGetArray(array('Product_page' => '1', 'export' => '', 'ajax' => '', 'selectAll' => '1', 'selectedIds' => ''));
$this->runControllerWithRedirectExceptionAndGetUrl('products/default/export');
// Start background job
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItems = ExportItem::getAll();
$this->assertEquals(1, count($exportItems));
$fileModel = $exportItems[0]->exportFileModel;
$this->assertEquals(1, $exportItems[0]->isCompleted);
$this->assertEquals('csv', $exportItems[0]->exportFileType);
$this->assertEquals('products', $exportItems[0]->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
$this->assertEquals($notificationsBeforeCount + 1, Notification::getCount());
$this->assertEquals($notificationMessagesBeforeCount + 1, NotificationMessage::getCount());
// Check export job, when many ids are selected.
// This will probably never happen, but we need test for this case too.
$notificationsBeforeCount = Notification::getCount();
$notificationMessagesBeforeCount = NotificationMessage::getCount();
// Now test case when multiple ids are selected
$exportItems = ExportItem::getAll();
if (count($exportItems)) {
foreach ($exportItems as $exportItem) {
$exportItem->delete();
}
}
$selectedIds = "";
foreach ($products as $product) {
$selectedIds .= $product->id . ",";
// Not Coding Standard
}
$this->setGetArray(array('ProductsSearchForm' => array('anyMixedAttributesScope' => array(0 => 'All'), 'anyMixedAttributes' => '', 'quantity' => ''), 'multiselect_ProductsSearchForm_anyMixedAttributesScope' => 'All', 'Product_page' => '1', 'export' => '', 'ajax' => '', 'selectAll' => '', 'selectedIds' => "{$selectedIds}"));
$this->runControllerWithRedirectExceptionAndGetUrl('products/default/export');
// Start background job
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItems = ExportItem::getAll();
$this->assertEquals(1, count($exportItems));
$fileModel = $exportItems[0]->exportFileModel;
$this->assertEquals(1, $exportItems[0]->isCompleted);
$this->assertEquals('csv', $exportItems[0]->exportFileType);
$this->assertEquals('products', $exportItems[0]->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
$this->assertEquals($notificationsBeforeCount + 1, Notification::getCount());
$this->assertEquals($notificationMessagesBeforeCount + 1, NotificationMessage::getCount());
}
public function testExportWithSelectAllForMoreThan10Records()
{
$super = $this->logoutCurrentUserLoginNewUserAndGetByUsername('super');
$accounts = Account::getAll();
foreach ($accounts as $account) {
$account->delete();
}
$exportItems = ExportItem::getAll();
foreach ($exportItems as $exportItem) {
$exportItem->delete();
}
$numberOfRecords = rand(12, 100);
ExportModule::$asynchronusThreshold = $numberOfRecords - 1;
for ($i = 1; $i <= $numberOfRecords; $i++) {
$randomData = RandomDataUtil::getRandomDataByModuleAndModelClassNames('AccountsModule', 'Account');
AccountTestHelper::createAccountByNameForOwner($randomData['names'][$i], $super);
}
$this->setGetArray(array('Account_page' => '1', 'export' => '', 'selectAll' => '1', 'selectedIds' => '', 'ajax' => ''));
$this->runControllerWithRedirectExceptionAndGetUrl('accounts/default/export');
// Start background job
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItems = ExportItem::getAll();
$this->assertEquals(1, count($exportItems));
$fileModel = $exportItems[0]->exportFileModel;
$this->assertEquals(1, $exportItems[0]->isCompleted);
$this->assertEquals('csv', $exportItems[0]->exportFileType);
$this->assertEquals('accounts', $exportItems[0]->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
for ($i = 1; $i <= $numberOfRecords; $i++) {
$this->assertContains($randomData['names'][$i], $fileModel->fileContent->content);
}
}
/**
* @depends testExportByModelIds
*/
public function testExportReportWithMultiplePagesOfData()
{
$super = User::getByUsername('super');
Yii::app()->user->userModel = $super;
$numberOfUserNotifications = Notification::getCountByTypeAndUser('ExportProcessCompleted', Yii::app()->user->userModel);
$report = new Report();
$report->setType(Report::TYPE_ROWS_AND_COLUMNS);
$report->setModuleClassName('AccountsModule');
$report->setFiltersStructure('');
$displayAttribute = new DisplayAttributeForReportForm('AccountsModule', 'Account', Report::TYPE_ROWS_AND_COLUMNS);
$displayAttribute->setModelAliasUsingTableAliasName('model1');
$displayAttribute->attributeIndexOrDerivedType = 'name';
$report->addDisplayAttribute($displayAttribute);
$dataProvider = new RowsAndColumnsReportDataProvider($report);
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = 'rowAndColumnsTest2';
$exportItem->modelClassName = 'SavedReport';
$exportItem->serializedData = ExportUtil::getSerializedDataForExport($dataProvider);
$this->assertTrue($exportItem->save());
$id = $exportItem->id;
$exportItem->forget();
unset($exportItem);
//Delete queued jobs from test exportItems created above
Yii::app()->jobQueue->deleteAll();
ExportModule::$asynchronousPageSize = 2;
$job = new ExportJob();
$this->assertEquals(0, count(Yii::app()->jobQueue->getAll()));
$this->assertTrue($job->run());
$this->assertEquals(0, count(Yii::app()->jobQueue->getAll()));
$exportItem = ExportItem::getById($id);
$fileModel = $exportItem->exportFileModel;
$this->assertEquals(1, $exportItem->isCompleted);
$this->assertEquals(0, $exportItem->processOffset);
$this->assertEquals('csv', $exportItem->exportFileType);
$this->assertEquals('rowAndColumnsTest2', $exportItem->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
$accounts = Account::getAll();
$headerData = array('Name');
$data = array();
foreach ($accounts as $account) {
$data[] = array($account->name);
}
$output = ExportItemToCsvFileUtil::export($data, $headerData, 'rowAndColumnsTest2.csv', false);
$this->assertEquals($output, $fileModel->fileContent->content);
// Check if user got notification message, and if its type is ExportProcessCompleted
$this->assertEquals($numberOfUserNotifications + 1, Notification::getCountByTypeAndUser('ExportProcessCompleted', Yii::app()->user->userModel));
//Matrix report should not paginate
$report = new Report();
$report->setType(Report::TYPE_MATRIX);
$report->setModuleClassName('AccountsModule');
$report->setFiltersStructure('');
$displayAttribute = new DisplayAttributeForReportForm('AccountsModule', 'Account', Report::TYPE_MATRIX);
$displayAttribute->setModelAliasUsingTableAliasName('model1');
$displayAttribute->attributeIndexOrDerivedType = 'Count';
$report->addDisplayAttribute($displayAttribute);
$groupBy = new GroupByForReportForm('AccountsModule', 'Account', Report::TYPE_MATRIX);
$groupBy->attributeIndexOrDerivedType = 'name';
$groupBy->axis = 'y';
$report->addGroupBy($groupBy);
$groupBy = new GroupByForReportForm('AccountsModule', 'Account', Report::TYPE_MATRIX);
$groupBy->attributeIndexOrDerivedType = 'officePhone';
$report->addGroupBy($groupBy);
$dataProvider = new MatrixReportDataProvider($report);
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = 'matrixTest1';
$exportItem->modelClassName = 'SavedReport';
$exportItem->serializedData = ExportUtil::getSerializedDataForExport($dataProvider);
$this->assertTrue($exportItem->save());
$id = $exportItem->id;
$exportItem->forget();
unset($exportItem);
//Delete queued jobs from test exportItems created above
Yii::app()->jobQueue->deleteAll();
ExportModule::$asynchronousPageSize = 2;
$job = new ExportJob();
$this->assertTrue($job->run());
$exportItem = ExportItem::getById($id);
$fileModel = $exportItem->exportFileModel;
$this->assertEquals(1, $exportItem->isCompleted);
$this->assertEquals(0, $exportItem->processOffset);
$this->assertEquals('csv', $exportItem->exportFileType);
$this->assertEquals('matrixTest1', $exportItem->exportFileName);
$this->assertTrue($fileModel instanceof ExportFileModel);
$fileContent = $fileModel->fileContent->content;
$this->assertContains('Test Account', $fileContent);
$this->assertContains('Test Account 2', $fileContent);
$this->assertContains('Test Account 3', $fileContent);
$this->assertContains('Test Account 4', $fileContent);
// Check if user got notification message, and if its type is ExportProcessCompleted
$this->assertEquals($numberOfUserNotifications + 2, Notification::getCountByTypeAndUser('ExportProcessCompleted', Yii::app()->user->userModel));
}
public function actionExport($id, $stickySearchKey = null)
{
assert('$stickySearchKey == null || is_string($stickySearchKey)');
$savedReport = SavedReport::getById((int) $id);
ControllerSecurityUtil::resolveCanCurrentUserAccessModule($savedReport->moduleClassName);
ControllerSecurityUtil::resolveAccessCanCurrentUserReadModel($savedReport);
$report = SavedReportToReportAdapter::makeReportBySavedReport($savedReport);
$dataProvider = $this->getDataProviderForExport($report, $report->getId(), false);
$totalItems = intval($dataProvider->calculateTotalItemCount());
$data = array();
if ($totalItems > 0) {
if ($totalItems <= ExportModule::$asynchronousThreshold) {
// Output csv file directly to user browser
if ($dataProvider) {
$reportToExportAdapter = ReportToExportAdapterFactory::createReportToExportAdapter($report, $dataProvider);
$headerData = $reportToExportAdapter->getHeaderData();
$data = $reportToExportAdapter->getData();
}
// Output data
if (count($data)) {
$fileName = $this->getModule()->getName() . ".csv";
ExportItemToCsvFileUtil::export($data, $headerData, $fileName, true);
} else {
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'There is no data to export.'));
}
} else {
if ($dataProvider) {
$serializedData = ExportUtil::getSerializedDataForExport($dataProvider);
}
// Create background job
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = $this->getModule()->getName();
$exportItem->modelClassName = 'SavedReport';
$exportItem->serializedData = $serializedData;
$exportItem->save();
$exportItem->forget();
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'A large amount of data has been requested for export. You will receive ' . 'a notification with the download link when the export is complete.'));
}
} else {
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'There is no data to export.'));
}
$this->redirect(array($this->getId() . '/index'));
}
protected function export($stickySearchKey = null, $modelClassName = null, $exportFileName = null)
{
assert('$stickySearchKey == null || is_string($stickySearchKey)');
assert('$modelClassName == null || is_string($modelClassName)');
assert('$exportFileName == null || is_string($exportFileName)');
if ($modelClassName == null) {
$modelClassName = $this->getModelName();
}
$searchFormClassName = static::getSearchFormClassName();
$pageSize = null;
$model = new $modelClassName(false);
if ($searchFormClassName != null) {
$searchForm = new $searchFormClassName($model);
} else {
throw new NotSupportedException();
}
$stateMetadataAdapterClassName = $this->resolveStateMetadataAdapterClassNameForExport();
$dataProvider = $this->getDataProviderByResolvingSelectAllFromGet($searchForm, $pageSize, Yii::app()->user->userModel->id, $stateMetadataAdapterClassName, $stickySearchKey);
if (!$dataProvider) {
$idsToExport = array_filter(explode(",", trim($_GET['selectedIds'], " ,")));
// Not Coding Standard
}
$totalItems = static::getSelectedRecordCountByResolvingSelectAllFromGet($dataProvider, false);
$data = array();
if ($totalItems > 0) {
if ($totalItems <= ExportModule::$asynchronousThreshold) {
// Output csv file directly to user browser
if ($dataProvider) {
$modelsToExport = ExportUtil::getDataForExport($dataProvider);
if (count($modelsToExport) > 0) {
$modelToExportAdapter = new ModelToExportAdapter($modelsToExport[0]);
$headerData = $modelToExportAdapter->getHeaderData();
}
foreach ($modelsToExport as $model) {
if (ControllerSecurityUtil::doesCurrentUserHavePermissionOnSecurableItem($model, Permission::READ)) {
$modelToExportAdapter = new ModelToExportAdapter($model);
$data[] = $modelToExportAdapter->getData();
}
}
} else {
$headerData = array();
foreach ($idsToExport as $idToExport) {
$model = $modelClassName::getById(intval($idToExport));
if (ControllerSecurityUtil::doesCurrentUserHavePermissionOnSecurableItem($model, Permission::READ)) {
$modelToExportAdapter = new ModelToExportAdapter($model);
$data[] = $modelToExportAdapter->getData();
if (count($headerData) == 0) {
$headerData = $modelToExportAdapter->getHeaderData();
}
}
}
}
// Output data
if (count($data)) {
if ($exportFileName == null) {
$fileName = $this->getModule()->getName() . ".csv";
} else {
$fileName = $exportFileName . ".csv";
}
$output = ExportItemToCsvFileUtil::export($data, $headerData, $fileName, true);
} else {
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'There is no data to export.'));
}
} else {
if ($dataProvider) {
$serializedData = ExportUtil::getSerializedDataForExport($dataProvider);
} else {
$serializedData = serialize($idsToExport);
}
// Create background job
$exportItem = new ExportItem();
$exportItem->isCompleted = false;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = $this->getModule()->getName();
$exportItem->modelClassName = $modelClassName;
$exportItem->serializedData = $serializedData;
$exportItem->isJobRunning = false;
$exportItem->cancelExport = false;
$exportItem->save();
$exportItem->forget();
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'A large amount of data has been requested for export. You will receive ' . 'a notification with the download link when the export is complete.'));
}
} else {
Yii::app()->user->setFlash('notification', Zurmo::t('ZurmoModule', 'There is no data to export.'));
}
$this->redirect(array($this->getId() . '/index'));
}
public function testCreateExportItemWithLargeData()
{
// anything larger than 99999 will have memcache complain about objects being too big to cache
// why? because ExportItem isCacheable() is true(implicitly, inherited from RedBeanModel.php).
// so during every save its re-cached: RedBeanModel.php:2017
$idsToExport = range(0, 66500);
$exportItem = new ExportItem();
$exportItem->isCompleted = 0;
$exportItem->exportFileType = 'csv';
$exportItem->exportFileName = 'test';
$exportItem->modelClassName = 'Account';
$exportItem->serializedData = serialize($idsToExport);
$this->assertTrue($exportItem->save());
$exportItemId = $exportItem->id;
$exportItem->forget();
$exportItem = ExportItem::getById($exportItemId);
$this->assertEquals($idsToExport, unserialize($exportItem->serializedData));
}
/**
* @param ExportItem $exportItem
* @throws FailedToSaveModelException
*/
protected function processCompletedWithSecurityExceptionExportItem(ExportItem $exportItem)
{
$exportItem->isCompleted = true;
$saved = $exportItem->save();
if (!$saved) {
throw new FailedToSaveModelException();
}
$message = new NotificationMessage();
$message->htmlContent = Zurmo::t('ExportModule', 'Export requested on {dateTime} was unable to be completed due to a permissions error.', array('{dateTime}' => DateTimeUtil::convertDbFormattedDateTimeToLocaleFormattedDisplay($exportItem->createdDateTime, 'long')));
$message->textContent = $message->htmlContent;
$rules = $this->getExportProcessCompletedNotificationRulesForExportItem($exportItem);
NotificationsUtil::submit($message, $rules);
}
