loadBannerRotator

zone.cpp

struct rotatorBannerSHARED {

	shared_ptr<BannerROW> banner;
	shared_ptr<campaign_row> campaign;

	double tare;
	double gross;
	payment paymentType;

	quint64 affiliateId;
	quint32 flag;
	quint8 w_rating;

	bool fill_from_db(single_row row);
};

struct rotatorBannerWORKER {

	shared_ptr<BannerWorker> banner;
	shared_ptr<CampaignWORKER> campaign;

	double tare;
	double gross;
	payment paymentType;

	quint32 flag;
	quint8 w_rating;
};





/**
 * @brief Zone::loadRotator
 * @param ok
 * @return rotator
 */
void Zone::loadBannerRotator(bool& ok, std::vector<shared_ptr<rotatorBannerWORKER>>& final) {
	ok = true;
	std::vector<shared_ptr<rotatorBannerSHARED>> rotator_shared = RotatorShared::getInstance().loadFromZoneId(id);
	auto iter = rotator_shared->cbegin();
	auto end = rotator_shared->cend();

	//Why I like to overcomplicate things ?
	//A single big malloc is always faster than N small
	//checkAntesLoad* rdl = (checkAntesLoad*) malloc( sizeof(checkAntesLoad) * rotator_shared->size());

	/** I MUST create a "dedicated" set of stuff, or we will have shared WORKER across the thread, with bad result...
	 * The campaign ARE Shared, so we just perform certain check just once (custom rule ecc)
	 * ALSO during this scan we check if WE need to load additional data for the user (if needed) like
	 * Nugg (needed at the moment only for custom rule)
	 * Banner capping (almost never used)
	 * Campaign capping (always used now to reduce the prio if a click was done)
	 */
	info1 toLoad;
	QMap<quint64,qint8> campaignsLoaded;
	QMap<quint64,shared_ptr<CampaignWORKER>> campaignsInstance;
	quint32 i = 0;
	for(;iter != end; iter++){
		i++;
		//If a campaign is already blacklisted, do not even check...
		qint8 check = campaignsLoaded.value(iter->campaign->id,-1);
		switch (check) {
			case 0://failed
				continue;
				break;
			case -1://still not checked
				if(campaignQuickChecks(iter->campaign.get())){
					campaignsInstance.insert(iter->campaign->id,make_shared<CampaignWORKER>());
				}else{
					campaignsLoaded.insert(iter->campaign->id,0);
					continue;
				}
				break;
			case 1://ok to go
				break;
		}



		if (!bannerQuickChecks(iter->banner.get()) ) {
			continue;
		}

		if (!mixQuickChecks(&(*iter))) {
			continue;
		}

		shared_ptr<CampaignWORKER> campaign = campaignsInstance.value(iter->campaign->id);

		shared_ptr<rotatorBannerWORKER> rotator = make_shared<rotatorBannerWORKER>();
		rotator->banner = make_shared<BannerWorker>();
		rotator->banner->setRow(iter->banner,campaign);
		rotator->campaign = rotator->banner->getCampaign();

		rotator->banner->setTare(iter->tare);
		rotator->banner->setGross(iter->gross);
		rotator->banner->setPaymentType(iter->paymentType);

		rotator->flag = iter->flag;
		rotator->w_rating = iter->w_rating;

		if(toLoad.nugg == false && (rotator->campaign->getLastRefreshDeliveryRule() > 0 || rotator->campaign->getLastRefreshWeightingRule() > 0) ){
			toLoad.nugg = true;
		}
		if(toLoad.bannerCap == false && (rotator->banner->getImpCap().useMe()) ){
			toLoad.bannerCap = true;
		}
		rotator->campaign->getUserCap().setRequirements(toLoad.campaignCap);

		final.push_back(rotator);
	}
	userInfo->fetchData(toLoad);
}