public function populateModel(&$model)
{
//todo: assert instanceof Person or mixes in Person.
parent::populateModel($model);
$personRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('ZurmoModule', 'Person');
$jobTitlesAndDepartments = RandomDataUtil::getRandomValueFromArray($personRandomData['jobTitlesAndDepartments']);
$lastName = RandomDataUtil::getRandomValueFromArray($personRandomData['lastNames']);
if ($model->firstName == null && RandomDataUtil::getRandomBooleanValue()) {
$model->firstName = RandomDataUtil::getRandomValueFromArray($personRandomData['femaleFirstNames']);
$title = RandomDataUtil::getRandomValueFromArray($personRandomData['femaleTitles']);
} elseif ($model->firstName == null) {
$model->firstName = RandomDataUtil::getRandomValueFromArray($personRandomData['maleFirstNames']);
$title = RandomDataUtil::getRandomValueFromArray($personRandomData['maleTitles']);
}
if ($model->lastName == null) {
$model->lastName = $lastName;
}
$model->title->value = $title;
$model->jobTitle = $jobTitlesAndDepartments[0];
$model->department = $jobTitlesAndDepartments[1];
$model->officePhone = RandomDataUtil::makeRandomPhoneNumber();
$model->officeFax = RandomDataUtil::makeRandomPhoneNumber();
$model->mobilePhone = RandomDataUtil::makeRandomPhoneNumber();
$model->primaryEmail = static::makeEmailAddressByPerson($model);
$model->primaryAddress = ZurmoRandomDataUtil::makeRandomAddress();
}
public static function populateAutoresponder($subject, $textContent, $htmlContent, $fromOperationDurationInterval, $operationType, $enableTracking = false, $marketingList = null)
{
assert('is_string($subject)');
assert('is_string($textContent)');
assert('is_string($htmlContent) || $htmlContent === null');
assert('is_int($fromOperationDurationInterval)');
assert('is_int($operationType)');
assert('is_bool($enableTracking) || is_int($enableTracking)');
assert('is_object($marketingList) || $marketingList === null');
if (empty($marketingList)) {
$marketingLists = MarketingList::getAll();
if (!empty($marketingLists)) {
$marketingList = RandomDataUtil::getRandomValueFromArray($marketingLists);
}
}
$autoresponder = new Autoresponder();
$autoresponder->subject = $subject;
$autoresponder->textContent = $textContent;
$autoresponder->htmlContent = $htmlContent;
$autoresponder->fromOperationDurationInterval = $fromOperationDurationInterval;
$autoresponder->fromOperationDurationType = TimeDurationUtil::DURATION_TYPE_DAY;
$autoresponder->operationType = $operationType;
$autoresponder->enableTracking = $enableTracking;
$autoresponder->marketingList = $marketingList;
return $autoresponder;
}
public static function populateAutoresponderItem($processed, $processDateTime, $autoresponder = null, $contact = null)
{
assert('is_string($processed) || is_int($processed)');
assert('is_string($processDateTime)');
assert('is_object($autoresponder) || $autoresponder === null');
assert('is_object($contact) || $contact === null');
if (empty($autoresponder)) {
$autoresponders = Autoresponder::getAll();
if (!empty($autoresponders)) {
$autoresponder = RandomDataUtil::getRandomValueFromArray($autoresponders);
}
}
if (empty($contact)) {
$contacts = Contact::getAll();
if (!empty($contacts)) {
$contact = RandomDataUtil::getRandomValueFromArray($contacts);
}
}
$autoresponderItem = new AutoresponderItem();
$autoresponderItem->processed = $processed;
$autoresponderItem->processDateTime = $processDateTime;
$autoresponderItem->autoresponder = $autoresponder;
$autoresponderItem->contact = $contact;
return $autoresponderItem;
}
public function populateModel(&$model)
{
assert('$model instanceof Contact');
parent::populateModel($model);
$accountRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('AccountsModule', 'Account');
$name = RandomDataUtil::getRandomValueFromArray($accountRandomData['names']);
$model->companyName = $name;
}
public function testDemoDataMaker()
{
$productCategory = new ProductCategory();
$productTemplateRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('ProductTemplatesModule', 'ProductCategory');
$name = RandomDataUtil::getRandomValueFromArray($productTemplateRandomData['names']);
$productCategory->name = $name;
$this->assertTrue($productCategory->save());
$productCategories[] = $productCategory->id;
}
public static function populateCampaign($name, $subject, $textContent, $htmlContent = null, $fromName = null, $fromAddress = null, $supportsRichText = null, $status = null, $sendOnDateTime = null, $enableTracking = null, $marketingList = null)
{
assert('is_string($name)');
assert('is_string($subject)');
assert('is_string($textContent) || $textContent === null');
assert('is_string($htmlContent) || $htmlContent === null');
assert('is_string($fromName) || $fromName === null');
assert('is_string($fromAddress) || $fromAddress === null');
assert('is_bool($supportsRichText) || is_int($supportsRichText) || $supportsRichText === null');
assert('is_string($status) || is_int($status) || $status === null');
assert('is_string($sendOnDateTime) || is_int($sendOnDateTime) || $sendOnDateTime === null');
assert('is_bool($enableTracking) || is_int($enableTracking) || $enableTracking === null');
assert('is_object($marketingList) || $marketingList === null');
if ($supportsRichText === null) {
$supportsRichText = 1;
if ($htmlContent === null) {
$htmlContent = 'test html content';
}
}
if ($sendOnDateTime === null) {
$sendOnDateTime = '0000-00-00 00:00:00';
}
if ($status === null) {
$status = Campaign::STATUS_ACTIVE;
}
if ($enableTracking === null) {
$enableTracking = 1;
}
if ($fromName === null) {
$fromName = 'Support Team';
}
if ($fromAddress === null) {
$fromAddress = '*****@*****.**';
}
if (empty($marketingList)) {
$marketingLists = MarketingList::getAll();
if (!empty($marketingLists)) {
$marketingList = RandomDataUtil::getRandomValueFromArray($marketingLists);
}
}
$campaign = new Campaign();
$campaign->name = $name;
$campaign->subject = $subject;
$campaign->textContent = $textContent;
$campaign->htmlContent = $htmlContent;
$campaign->status = $status;
$campaign->fromName = $fromName;
$campaign->fromAddress = $fromAddress;
$campaign->supportsRichText = $supportsRichText;
$campaign->enableTracking = $enableTracking;
$campaign->sendOnDateTime = $sendOnDateTime;
$campaign->marketingList = $marketingList;
return $campaign;
}
public function populateModel(&$model)
{
assert('$model instanceof Contact');
parent::populateModel($model);
$domainName = static::resolveDomainName($model);
$source = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('LeadSources'));
$industry = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('Industries'));
$model->website = static::makeUrlByDomainName($domainName);
$model->source->value = $source;
$model->industry->value = $industry;
}
/**
* @param RedBeanModel $model
*/
public function populateModel(&$model)
{
assert('$model instanceof Note');
parent::populateModel($model);
$taskRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('NotesModule', 'Note');
$description = RandomDataUtil::getRandomValueFromArray($taskRandomData['descriptions']);
$occurredOnTimeStamp = time() - mt_rand(1, 200) * 60 * 60 * 24;
$occurredOnDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($occurredOnTimeStamp);
$model->description = $description;
$model->occurredOnDateTime = $occurredOnDateTime;
}
/**
* Make an Address object.
*/
public static function makeRandomAddress()
{
$addressRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('ZurmoModule', 'Address');
$streetName = RandomDataUtil::getRandomValueFromArray($addressRandomData['streetNames']);
$direction = RandomDataUtil::getRandomValueFromArray($addressRandomData['directions']);
$streetSuffix = RandomDataUtil::getRandomValueFromArray($addressRandomData['streetSuffixes']);
$cityStatePostalCodeData = RandomDataUtil::getRandomValueFromArray($addressRandomData['cityStatePostalCode']);
$address = new Address();
$address->street1 = mt_rand(1000, 40000) . ' ' . $direction . ' ' . $streetName . ' ' . $streetSuffix;
$address->city = $cityStatePostalCodeData[0];
$address->state = $cityStatePostalCodeData[1];
$address->postalCode = RandomDataUtil::getRandomValueFromArray($cityStatePostalCodeData[2]);
return $address;
}
/**
* Method for testing creating a simple notification for the current user.
*/
public function actionGenerateManageSubscriptionHash()
{
if (Yii::app()->user->userModel->username != 'super') {
throw new NotSupportedException();
}
$contact = RandomDataUtil::getRandomValueFromArray(Contact::getAll());
$personId = $contact->getClassId('Person');
$marketingList = RandomDataUtil::getRandomValueFromArray(MarketingList::getAll());
$marketingListId = $marketingList->id;
$model = RandomDataUtil::getRandomValueFromArray(CampaignItem::getAll());
$modelId = $model->id;
$modelType = get_class($model);
$hash = EmailMessageActivityUtil::resolveHashForUnsubscribeAndManageSubscriptionsUrls($personId, $marketingListId, $modelId, $modelType, false);
echo 'index.php/marketingLists/external/manageSubscriptions?hash=' . $hash;
}
/**
* Method for testing creating a simple notification for the current user.
*/
public function actionGenerateManageSubscriptionHash()
{
if (!Group::isUserASuperAdministrator(Yii::app()->user->userModel)) {
throw new NotSupportedException();
}
$contact = RandomDataUtil::getRandomValueFromArray(Contact::getAll());
$personId = $contact->getClassId('Person');
$marketingList = RandomDataUtil::getRandomValueFromArray(MarketingList::getAll());
$marketingListId = $marketingList->id;
$model = RandomDataUtil::getRandomValueFromArray(CampaignItem::getAll());
$modelId = $model->id;
$modelType = get_class($model);
$hash = GlobalMarketingFooterUtil::resolveHash($personId, $marketingListId, $modelId, $modelType, false);
echo 'index.php/marketingLists/external/manageSubscriptions?hash=' . $hash;
}
/**
* @param RedBeanModel $model
*/
public function populateModel(&$model)
{
assert('$model instanceof Opportunity');
$opportunityRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('OpportunitiesModule', 'Opportunity');
parent::populateModel($model);
$name = RandomDataUtil::getRandomValueFromArray($opportunityRandomData['names']);
$model->name = $name;
$stage = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('SalesStages'));
$source = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('LeadSources'));
$model->stage->value = $stage;
$model->source->value = $source;
$futureTimeStamp = time() + mt_rand(1, 200) * 60 * 60 * 24;
$closeDate = Yii::app()->dateFormatter->format(DatabaseCompatibilityUtil::getDateFormat(), $futureTimeStamp);
$model->closeDate = $closeDate;
$model->amount->value = mt_rand(5, 350) * 1000;
}
public function populateModel(&$model)
{
assert('$model instanceof Task');
parent::populateModel($model);
$taskRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('TasksModule', 'Task');
$name = RandomDataUtil::getRandomValueFromArray($taskRandomData['names']);
if (RandomDataUtil::getRandomBooleanValue()) {
$dueTimeStamp = time() - mt_rand(1, 50) * 60 * 60 * 24;
$completedDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($dueTimeStamp + mt_rand(1, 24) * 15);
$model->completedDateTime = $completedDateTime;
$model->completed = true;
} else {
$dueTimeStamp = time() + mt_rand(1, 200) * 60 * 60 * 24;
}
$dueDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($dueTimeStamp);
$model->name = $name;
$model->dueDateTime = $dueDateTime;
}
public static function fillAutoresponder($name, $subject, $textContent, $htmlContent, $secondsFromOperation, $operationType, $marketingList = null)
{
if (empty($marketingList)) {
$marketingLists = MarketingList::getAll();
if (!empty($marketingLists)) {
$marketingList = RandomDataUtil::getRandomValueFromArray($marketingLists);
}
}
$autoresponder = new Autoresponder();
$autoresponder->name = $name;
$autoresponder->subject = $subject;
$autoresponder->textContent = $textContent;
$autoresponder->htmlContent = $htmlContent;
$autoresponder->secondsFromOperation = $secondsFromOperation;
$autoresponder->operationType = $operationType;
$autoresponder->marketingList = $marketingList;
return $autoresponder;
}
/**
* @param RedBeanModel $model
*/
public function populateModel(&$model)
{
assert('$model instanceof Account');
parent::populateModel($model);
$accountRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('AccountsModule', 'Account');
$name = RandomDataUtil::getRandomValueFromArray($accountRandomData['names']);
$domainName = static::makeDomainByName(strval($model));
$type = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('AccountTypes'));
$industry = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('Industries'));
$model->name = $name;
$model->website = static::makeUrlByDomainName($domainName);
$model->type->value = $type;
$model->industry->value = $industry;
$model->officePhone = RandomDataUtil::makeRandomPhoneNumber();
$model->officeFax = RandomDataUtil::makeRandomPhoneNumber();
$model->primaryEmail = static::makeEmailAddressByAccount($model);
$model->billingAddress = ZurmoRandomDataUtil::makeRandomAddress();
$model->employees = mt_rand(1, 95) * 10;
$model->annualRevenue = mt_rand(1, 780) * 1000000;
}
public static function populateMarketingListMember($unsubscribed = 0, $marketingList = null, $contact = null)
{
if (empty($marketingList)) {
$marketingLists = MarketingList::getAll();
if (!empty($marketingLists)) {
$marketingList = RandomDataUtil::getRandomValueFromArray($marketingLists);
}
}
if (empty($contact)) {
$contacts = Contact::getAll();
if (!empty($contacts)) {
$contact = RandomDataUtil::getRandomValueFromArray($contacts);
}
}
$marketingListMember = new MarketingListMember();
$marketingListMember->unsubscribed = $unsubscribed;
$marketingListMember->contact = $contact;
$marketingListMember->marketingList = $marketingList;
return $marketingListMember;
}
public static function fillAutoresponderItem($processed, $processDateTime, $autoresponder = null, $contact = null)
{
if (empty($autoresponder)) {
$autoresponders = Autoresponder::getAll();
if (!empty($autoresponders)) {
$autoresponder = RandomDataUtil::getRandomValueFromArray($autoresponders);
}
}
if (empty($contact)) {
$contacts = Contact::getAll();
if (!empty($contacts)) {
$contact = RandomDataUtil::getRandomValueFromArray($contacts);
}
}
$autoresponderItem = new AutoresponderItem();
$autoresponderItem->processed = $processed;
$autoresponderItem->processDateTime = $processDateTime;
$autoresponderItem->autoresponder = $autoresponder;
$autoresponderItem->contact = $contact;
return $autoresponderItem;
}
/**
* @param DemoDataHelper $demoDataHelper
*/
public function makeAll(&$demoDataHelper)
{
assert('$demoDataHelper instanceof DemoDataHelper');
assert('$demoDataHelper->isSetRange("User")');
$contactStates = ContactState::getAll();
$statesBeginningWithStartingState = ContactsDemoDataMaker::getStatesBeforeOrStartingWithStartingState($contactStates);
$contactWebForms = array();
for ($this->index = 0; $this->index < 5; $this->index++) {
$contactWebForm = new ContactWebForm();
$contactWebForm->owner = $demoDataHelper->getRandomByModelName('User');
$contactWebForm->defaultOwner = $contactWebForm->owner;
$contactWebForm->defaultState = RandomDataUtil::getRandomValueFromArray($statesBeginningWithStartingState);
$this->populateModel($contactWebForm);
$contactWebForm->addPermissions(Group::getByName(Group::EVERYONE_GROUP_NAME), Permission::READ_WRITE_CHANGE_PERMISSIONS_CHANGE_OWNER);
$saved = $contactWebForm->save();
assert('$saved');
$contactWebForm = ContactWebForm::getById($contactWebForm->id);
AllPermissionsOptimizationUtil::securableItemGivenPermissionsForGroup($contactWebForm, Group::getByName(Group::EVERYONE_GROUP_NAME));
$contactWebForm->save();
$contactWebForms[] = $contactWebForm->id;
}
$demoDataHelper->setRangeByModelName('ContactWebForm', $contactWebForms[0], $contactWebForms[count($contactWebForms) - 1]);
}
public static function populateCampaignItem($processed, $campaign = null, $contact = null)
{
assert('is_bool($processed)');
assert('is_object($campaign) || $campaign === null');
assert('is_object($contact) || $contact === null');
if (empty($campaign)) {
$campaigns = Campaign::getAll();
if (!empty($campaigns)) {
$campaign = RandomDataUtil::getRandomValueFromArray($campaigns);
}
}
if (empty($contact)) {
$contacts = Contact::getAll();
if (!empty($contacts)) {
$contact = RandomDataUtil::getRandomValueFromArray($contacts);
}
}
$campaignItem = new CampaignItem();
$campaignItem->processed = $processed;
$campaignItem->campaign = $campaign;
$campaignItem->contact = $contact;
return $campaignItem;
}
public function populateModel(&$model)
{
assert('$model instanceof Campaign');
parent::populateModel($model);
if (empty($this->seedData)) {
$this->seedData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('CampaignsModule', 'Campaign');
}
$statusKeys = array_keys(Campaign::getStatusDropDownArray());
$timestamp = time();
$model->name = $this->seedData['name'][$this->index];
$model->subject = $this->seedData['subject'][$this->index];
$model->status = RandomDataUtil::getRandomValueFromArray($statusKeys);
if (!(rand() % 2)) {
$timestamp += rand(500, 5000);
}
$model->sendOnDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($timestamp);
$model->supportsRichText = rand() % 2;
$model->htmlContent = $this->seedData['htmlContent'][$this->index];
$model->textContent = $this->seedData['textContent'][$this->index];
$model->fromName = $this->seedData['fromName'][$this->index];
$model->fromAddress = $this->seedData['fromAddress'][$this->index];
$model->enableTracking = rand() % 2;
$this->populateMarketingModelWithFiles($model);
}
/**
* @depends testGetByProcessedAndCampaignId
*/
public function testGetLabel()
{
$campaignItem = RandomDataUtil::getRandomValueFromArray(CampaignItem::getAll());
$this->assertNotNull($campaignItem);
$this->assertEquals('Campaign Item', $campaignItem::getModelLabelByTypeAndLanguage('Singular'));
$this->assertEquals('Campaign Items', $campaignItem::getModelLabelByTypeAndLanguage('Plural'));
}
/**
* Add demo tasks for the project
* @param type $project
*/
protected static function addDemoTasks($project, $taskInputCount = 1, &$demoDataHelper)
{
$randomTasks = self::getRandomTasks();
for ($i = 0; $i < count($randomTasks); $i++) {
$task = new Task();
$task->name = $randomTasks[$i]['name'];
$task->owner = $demoDataHelper->getRandomByModelName('User');
$task->requestedByUser = $demoDataHelper->getRandomByModelName('User');
$task->completedDateTime = '0000-00-00 00:00:00';
$task->project = $project;
$task->status = Task::STATUS_NEW;
$task->save();
//Notification subscriber
$notificationSubscriber = new NotificationSubscriber();
$notificationSubscriber->person = $demoDataHelper->getRandomByModelName('User');
$notificationSubscriber->hasReadLatest = false;
//Task check list items
$task->notificationSubscribers->add($notificationSubscriber);
$taskCheckListItems = $randomTasks[$i]['checkListItems'];
foreach ($taskCheckListItems as $itemKey => $name) {
$taskCheckListItem = new TaskCheckListItem();
$taskCheckListItem->name = $name;
if ($itemKey * $i * rand(5, 100) % 3 == 0) {
$taskCheckListItem->completed = true;
}
$task->checkListItems->add($taskCheckListItem);
ProjectsUtil::logTaskCheckItemEvent($task, $taskCheckListItem);
}
//Comments
$commentItems = $randomTasks[$i]['comments'];
foreach ($commentItems as $description) {
$comment = new Comment();
$comment->description = $description;
$comment->setScenario('importModel');
$comment->createdByUser = $demoDataHelper->getRandomByModelName('User');
$task->comments->add($comment);
ProjectsUtil::logAddCommentEvent($task, strval($comment));
}
//Add Super user
$comment = new Comment();
$comment->description = 'Versatile idea regarding the task';
$task->comments->add($comment);
$task->addPermissions(Group::getByName(Group::EVERYONE_GROUP_NAME), Permission::READ_WRITE_CHANGE_PERMISSIONS_CHANGE_OWNER);
$task->save();
$currentStatus = $task->status;
ProjectsUtil::logAddTaskEvent($task);
$task = Task::getById($task->id);
$task->status = RandomDataUtil::getRandomValueFromArray(self::getTaskStatusOptions());
$task->save();
AllPermissionsOptimizationUtil::securableItemGivenPermissionsForGroup($task, Group::getByName(Group::EVERYONE_GROUP_NAME));
$task->save();
ProjectsUtil::logTaskStatusChangeEvent($task, Task::getStatusDisplayName($currentStatus), Task::getStatusDisplayName(intval($task->status)));
}
}
/**
* @depends testCreateAndGetAutoresponderItemActivityById
*/
public function testGetLabel()
{
$autoresponderItemActivity = RandomDataUtil::getRandomValueFromArray(AutoresponderItemActivity::getAll());
$this->assertNotNull($autoresponderItemActivity);
$this->assertEquals('Autoresponder Item Activity', $autoresponderItemActivity::getModelLabelByTypeAndLanguage('Singular'));
$this->assertEquals('Autoresponder Item Activities', $autoresponderItemActivity::getModelLabelByTypeAndLanguage('Plural'));
}
/**
* @depends testCreateAndGetEmailMessageUrlById
*/
public function testGetLabel()
{
$emailMessageUrl = RandomDataUtil::getRandomValueFromArray(EmailMessageUrl::getAll());
$this->assertNotNull($emailMessageUrl);
$this->assertEquals('Email Message Url', $emailMessageUrl::getModelLabelByTypeAndLanguage('Singular'));
$this->assertEquals('Email Message Urls', $emailMessageUrl::getModelLabelByTypeAndLanguage('Plural'));
}
/**
* @depends testCreateAndGetMarketingListMemberById
*/
public function testAddNewMemberSkipsDuplicate()
{
$marketingList = MarketingListTestHelper::createMarketingListByName('test marketing List 03');
$this->assertNotNull($marketingList);
$contact = RandomDataUtil::getRandomValueFromArray(Contact::getAll());
$this->assertNotNull($contact);
$added = $marketingList->addNewMember($contact->id, false, $contact);
$this->assertTrue($added);
$added = $marketingList->addNewMember($contact->id, false, $contact);
$this->assertFalse($added);
$memberCount = $marketingList->memberAlreadyExists($contact->id);
$this->assertEquals(1, $memberCount);
$marketingList = MarketingListTestHelper::createMarketingListByName('test marketing List 04');
$this->assertNotNull($marketingList);
$added = $marketingList->addNewMember($contact->id, false, $contact);
$this->assertTrue($added);
}
/**
* @param RedBeanModel $model
* @param bool $setInFuture
*/
public function populateModel(&$model, $setInFuture = true)
{
assert('$model instanceof Meeting');
parent::populateModel($model);
$meetingRandomData = ZurmoRandomDataUtil::getRandomDataByModuleAndModelClassNames('MeetingsModule', 'Meeting');
$name = RandomDataUtil::getRandomValueFromArray($meetingRandomData['names']);
$category = RandomDataUtil::getRandomValueFromArray(static::getCustomFieldDataByName('MeetingCategories'));
$location = RandomDataUtil::getRandomValueFromArray($meetingRandomData['locations']);
if ($setInFuture) {
$startTimeStamp = time() + mt_rand(1, 60) * 60 * 60 * 24;
$startDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($startTimeStamp);
$endDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($startTimeStamp + mt_rand(1, 24) * 15);
} else {
$startTimeStamp = time() - mt_rand(1, 30) * 60 * 60 * 24;
$startDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($startTimeStamp);
$endDateTime = DateTimeUtil::convertTimestampToDbFormatDateTime($startTimeStamp + mt_rand(1, 24) * 15);
}
$model->name = $name;
$model->category->value = $category;
$model->location = $location;
$model->startDateTime = $startDateTime;
$model->endDateTime = $endDateTime;
}
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);
}
}
public function testSubscribeContactsForContactType()
{
$type = 'contact';
$account = AccountTestHelper::createAccountByNameForOwner('superAccount3', $this->user);
$contact = ContactTestHelper::createContactWithAccountByNameForOwner('superContact6', $this->user, $account);
$contactId = $contact->id;
$marketingList = RandomDataUtil::getRandomValueFromArray(MarketingList::getAll());
$marketingListId = $marketingList->id;
$this->setGetArray(array('marketingListId' => $marketingListId, 'id' => $contact->id, 'type' => $type));
$content = $this->runControllerWithNoExceptionsAndGetContent('marketingLists/defaultPortlet/subscribeContacts');
$contentArray = CJSON::decode($content);
$this->assertNotEmpty($contentArray);
$this->assertArrayHasKey('type', $contentArray);
$this->assertArrayHasKey('message', $contentArray);
$this->assertEquals('1 subscribed.', $contentArray['message']);
$this->assertEquals('message', $contentArray['type']);
$content = $this->runControllerWithNoExceptionsAndGetContent('marketingLists/defaultPortlet/subscribeContacts');
$contentArray = CJSON::decode($content);
$this->assertNotEmpty($contentArray);
$this->assertArrayHasKey('type', $contentArray);
$this->assertArrayHasKey('message', $contentArray);
$this->assertEquals('0 subscribed. 1 skipped, already in the list.', $contentArray['message']);
$this->assertEquals('message', $contentArray['type']);
}
