3285 lines
125 KiB
JavaScript
3285 lines
125 KiB
JavaScript
// QR Rapido Speed Generator
|
||
class QRRapidoGenerator {
|
||
constructor() {
|
||
this.startTime = 0;
|
||
this.currentQR = null;
|
||
this.timerInterval = null;
|
||
this.languageStrings = {
|
||
'pt-BR': {
|
||
tagline: 'Gere QR codes em segundos!',
|
||
generating: 'Gerando...',
|
||
generated: 'Gerado em',
|
||
seconds: 's',
|
||
ultraFast: 'Geração ultra rápida!',
|
||
fast: 'Geração rápida!',
|
||
normal: 'Geração normal',
|
||
error: 'Erro na geração. Tente novamente.',
|
||
success: 'QR Code salvo no histórico!'
|
||
},
|
||
'es': {
|
||
tagline: '¡Genera códigos QR en segundos!',
|
||
generating: 'Generando...',
|
||
generated: 'Generado en',
|
||
seconds: 's',
|
||
ultraFast: '¡Generación ultra rápida!',
|
||
fast: '¡Generación rápida!',
|
||
normal: 'Generación normal',
|
||
error: 'Error en la generación. Inténtalo de nuevo.',
|
||
success: '¡Código QR guardado en el historial!'
|
||
},
|
||
'en': {
|
||
tagline: 'Generate QR codes in seconds!',
|
||
generating: 'Generating...',
|
||
generated: 'Generated in',
|
||
seconds: 's',
|
||
ultraFast: 'Ultra fast generation!',
|
||
fast: 'Fast generation!',
|
||
normal: 'Normal generation',
|
||
error: 'Generation error. Please try again.',
|
||
success: 'QR Code saved to history!'
|
||
}
|
||
};
|
||
this.currentLang = localStorage.getItem('qrrapido-lang') || 'pt-BR';
|
||
|
||
this.selectedType = null;
|
||
this.selectedStyle = 'classic'; // Estilo padrão
|
||
this.contentValid = false;
|
||
|
||
this.initializeEvents();
|
||
this.checkAdFreeStatus();
|
||
this.updateLanguage();
|
||
this.updateStatsCounters();
|
||
this.initializeUserCounter();
|
||
this.initializeProgressiveFlow();
|
||
this.initializeRateLimiting();
|
||
|
||
// Validar segurança dos dados após carregamento
|
||
setTimeout(() => {
|
||
this.validateDataSecurity();
|
||
this.testUTF8Encoding();
|
||
}, 1000);
|
||
}
|
||
|
||
initializeEvents() {
|
||
// Form submission with timer
|
||
const form = document.getElementById('qr-speed-form');
|
||
if (form) {
|
||
form.addEventListener('submit', this.generateQRWithTimer.bind(this));
|
||
}
|
||
|
||
// Quick style selection
|
||
document.querySelectorAll('input[name="quick-style"]').forEach(radio => {
|
||
radio.addEventListener('change', this.applyQuickStyle.bind(this));
|
||
});
|
||
|
||
// Logo upload feedback
|
||
const logoUpload = document.getElementById('logo-upload');
|
||
if (logoUpload) {
|
||
logoUpload.addEventListener('change', this.handleLogoSelection.bind(this));
|
||
}
|
||
|
||
// Logo size slider preview em tempo real
|
||
const logoSizeSlider = document.getElementById('logo-size-slider');
|
||
if (logoSizeSlider && typeof this.updateLogoReadabilityPreview === 'function') {
|
||
logoSizeSlider.addEventListener('input', this.updateLogoReadabilityPreview.bind(this));
|
||
}
|
||
|
||
// Logo colorize toggle preview em tempo real
|
||
const logoColorizeToggle = document.getElementById('logo-colorize-toggle');
|
||
if (logoColorizeToggle && typeof this.updateLogoReadabilityPreview === 'function') {
|
||
logoColorizeToggle.addEventListener('change', this.updateLogoReadabilityPreview.bind(this));
|
||
}
|
||
|
||
// Corner style validation for non-premium users
|
||
const cornerStyle = document.getElementById('corner-style');
|
||
if (cornerStyle) {
|
||
cornerStyle.addEventListener('change', this.handleCornerStyleChange.bind(this));
|
||
}
|
||
|
||
// QR type change with hints and flow
|
||
const qrType = document.getElementById('qr-type');
|
||
if (qrType) {
|
||
qrType.addEventListener('change', (e) => {
|
||
this.handleTypeSelection(e.target.value);
|
||
this.updateContentHints();
|
||
});
|
||
}
|
||
|
||
// Content validation
|
||
const qrContent = document.getElementById('qr-content');
|
||
if (qrContent) {
|
||
let timer;
|
||
qrContent.addEventListener('input', (e) => {
|
||
clearTimeout(timer);
|
||
timer = setTimeout(() => {
|
||
this.handleContentChange(e.target.value);
|
||
this.updateGenerateButton();
|
||
}, 300);
|
||
});
|
||
}
|
||
|
||
// Style selection
|
||
document.querySelectorAll('input[name="quick-style"]').forEach(radio => {
|
||
radio.addEventListener('change', (e) => {
|
||
this.handleStyleSelection(e.target.value);
|
||
});
|
||
});
|
||
|
||
// Add listeners to all relevant fields to update button state
|
||
const fieldsToWatch = [
|
||
'qr-content', 'vcard-name', 'vcard-mobile', 'vcard-email',
|
||
'wifi-ssid', 'wifi-password', 'sms-number', 'sms-message',
|
||
'email-to', 'email-subject', 'email-body'
|
||
];
|
||
fieldsToWatch.forEach(id => {
|
||
const el = document.getElementById(id);
|
||
if (el) {
|
||
el.addEventListener('input', () => this.updateGenerateButton());
|
||
}
|
||
});
|
||
document.querySelectorAll('input[name="wifi-security"]').forEach(radio => {
|
||
radio.addEventListener('change', () => this.updateGenerateButton());
|
||
});
|
||
|
||
// Language selector
|
||
document.querySelectorAll('[data-lang]').forEach(link => {
|
||
link.addEventListener('click', this.changeLanguage.bind(this));
|
||
});
|
||
|
||
// Real-time preview for premium users
|
||
if (this.isPremiumUser()) {
|
||
this.setupRealTimePreview();
|
||
}
|
||
|
||
// Download buttons
|
||
this.setupDownloadButtons();
|
||
|
||
// Share functionality
|
||
this.setupShareButtons();
|
||
|
||
// Save to history
|
||
const saveBtn = document.getElementById('save-to-history');
|
||
if (saveBtn) {
|
||
saveBtn.addEventListener('click', this.saveToHistory.bind(this));
|
||
}
|
||
}
|
||
|
||
setupDownloadButtons() {
|
||
const pngBtn = document.getElementById('download-png');
|
||
const svgBtn = document.getElementById('download-svg');
|
||
const pdfBtn = document.getElementById('download-pdf');
|
||
|
||
if (pngBtn) pngBtn.addEventListener('click', () => this.downloadQR('png'));
|
||
if (svgBtn) svgBtn.addEventListener('click', () => this.downloadQR('svg'));
|
||
if (pdfBtn) pdfBtn.addEventListener('click', () => this.downloadQR('pdf'));
|
||
}
|
||
|
||
setupShareButtons() {
|
||
// Check if Web Share API is supported and show/hide native share option
|
||
if (navigator.share && this.isMobileDevice()) {
|
||
const nativeShareOption = document.getElementById('native-share-option');
|
||
if (nativeShareOption) {
|
||
nativeShareOption.classList.remove('d-none');
|
||
}
|
||
}
|
||
|
||
// Show save to gallery option on mobile
|
||
if (this.isMobileDevice()) {
|
||
const saveGalleryOption = document.getElementById('save-gallery-option');
|
||
if (saveGalleryOption) {
|
||
saveGalleryOption.classList.remove('d-none');
|
||
}
|
||
}
|
||
|
||
// Add event listeners to share buttons
|
||
const shareButtons = {
|
||
'native-share': () => this.shareNative(),
|
||
'share-whatsapp': () => this.shareWhatsApp(),
|
||
'share-telegram': () => this.shareTelegram(),
|
||
'share-email': () => this.shareEmail(),
|
||
'copy-qr-link': () => this.copyToClipboard(),
|
||
'save-to-gallery': () => this.saveToGallery()
|
||
};
|
||
|
||
Object.entries(shareButtons).forEach(([id, handler]) => {
|
||
const button = document.getElementById(id);
|
||
if (button) {
|
||
button.addEventListener('click', (e) => {
|
||
e.preventDefault();
|
||
handler();
|
||
});
|
||
}
|
||
});
|
||
}
|
||
|
||
isMobileDevice() {
|
||
return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ||
|
||
(navigator.maxTouchPoints && navigator.maxTouchPoints > 2 && /MacIntel/.test(navigator.platform));
|
||
}
|
||
|
||
async shareNative() {
|
||
if (!this.currentQR || !navigator.share) return;
|
||
|
||
try {
|
||
// Create a blob from the base64 image
|
||
const base64Response = await fetch(`data:image/png;base64,${this.currentQR.base64}`);
|
||
const blob = await base64Response.blob();
|
||
const file = new File([blob], 'qrcode.png', { type: 'image/png' });
|
||
|
||
const shareData = {
|
||
title: 'QR Code - QR Rapido',
|
||
text: 'QR Code gerado com QR Rapido - o gerador mais rápido do Brasil!',
|
||
url: window.location.origin,
|
||
files: [file]
|
||
};
|
||
|
||
// Check if files can be shared
|
||
if (navigator.canShare && navigator.canShare(shareData)) {
|
||
await navigator.share(shareData);
|
||
} else {
|
||
// Fallback without files
|
||
await navigator.share({
|
||
title: shareData.title,
|
||
text: shareData.text,
|
||
url: shareData.url
|
||
});
|
||
}
|
||
|
||
this.trackShareEvent('native');
|
||
} catch (error) {
|
||
console.error('Error sharing:', error);
|
||
if (error.name !== 'AbortError') {
|
||
this.showError(window.QRRapidoTranslations?.shareError || 'Error sharing. Try another method.');
|
||
}
|
||
}
|
||
}
|
||
|
||
shareWhatsApp() {
|
||
if (!this.currentQR) return;
|
||
|
||
const text = encodeURIComponent((window.QRRapidoTranslations?.fastestGeneratorBrazil || 'QR Code generated with QR Rapido!') + ' ' + window.location.origin);
|
||
const url = `https://wa.me/?text=${text}`;
|
||
|
||
if (this.isMobileDevice()) {
|
||
window.open(url, '_blank');
|
||
} else {
|
||
window.open(`https://web.whatsapp.com/send?text=${text}`, '_blank');
|
||
}
|
||
|
||
this.trackShareEvent('whatsapp');
|
||
}
|
||
|
||
shareTelegram() {
|
||
if (!this.currentQR) return;
|
||
|
||
const text = encodeURIComponent(window.QRRapidoTranslations?.fastestGeneratorBrazil || 'QR Code generated with QR Rapido!');
|
||
const url = encodeURIComponent(window.location.origin);
|
||
const telegramUrl = `https://t.me/share/url?url=${url}&text=${text}`;
|
||
|
||
window.open(telegramUrl, '_blank');
|
||
this.trackShareEvent('telegram');
|
||
}
|
||
|
||
shareEmail() {
|
||
if (!this.currentQR) return;
|
||
|
||
const subject = encodeURIComponent('QR Code - QR Rapido');
|
||
const body = encodeURIComponent(`Olá!\n\nCompartilho com você este QR Code gerado no QR Rapido, o gerador mais rápido do Brasil!\n\nAcesse: ${window.location.origin}\n\nAbraços!`);
|
||
const mailtoUrl = `mailto:?subject=${subject}&body=${body}`;
|
||
|
||
window.location.href = mailtoUrl;
|
||
this.trackShareEvent('email');
|
||
}
|
||
|
||
async copyToClipboard() {
|
||
if (!this.currentQR) return;
|
||
|
||
try {
|
||
const shareText = `QR Code gerado com QR Rapido - ${window.location.origin}`;
|
||
|
||
if (navigator.clipboard && window.isSecureContext) {
|
||
await navigator.clipboard.writeText(shareText);
|
||
} else {
|
||
// Fallback for older browsers
|
||
const textArea = document.createElement('textarea');
|
||
textArea.value = shareText;
|
||
textArea.style.position = 'fixed';
|
||
textArea.style.left = '-999999px';
|
||
textArea.style.top = '-999999px';
|
||
document.body.appendChild(textArea);
|
||
textArea.focus();
|
||
textArea.select();
|
||
document.execCommand('copy');
|
||
textArea.remove();
|
||
}
|
||
|
||
this.showSuccess(window.QRRapidoTranslations?.linkCopied || 'Link copied to clipboard!');
|
||
this.trackShareEvent('copy');
|
||
} catch (error) {
|
||
console.error('Error copying to clipboard:', error);
|
||
this.showError('Erro ao copiar link. Tente novamente.');
|
||
}
|
||
}
|
||
|
||
async saveToGallery() {
|
||
if (!this.currentQR) return;
|
||
|
||
try {
|
||
// Create a blob from the base64 image
|
||
const base64Response = await fetch(`data:image/png;base64,${this.currentQR.base64}`);
|
||
const blob = await base64Response.blob();
|
||
|
||
// Create download link
|
||
const url = window.URL.createObjectURL(blob);
|
||
const a = document.createElement('a');
|
||
a.href = url;
|
||
a.download = `qrrapido-${new Date().toISOString().slice(0,10)}-${Date.now()}.png`;
|
||
document.body.appendChild(a);
|
||
a.click();
|
||
document.body.removeChild(a);
|
||
window.URL.revokeObjectURL(url);
|
||
|
||
this.showSuccess('QR Code baixado! Verifique sua galeria/downloads.');
|
||
this.trackShareEvent('gallery');
|
||
} catch (error) {
|
||
console.error('Error saving to gallery:', error);
|
||
this.showError('Erro ao salvar na galeria. Tente novamente.');
|
||
}
|
||
}
|
||
|
||
trackShareEvent(method) {
|
||
// Google Analytics
|
||
if (typeof gtag !== 'undefined') {
|
||
gtag('event', 'qr_shared', {
|
||
'share_method': method,
|
||
'user_type': this.isPremiumUser() ? 'premium' : 'free',
|
||
'language': this.currentLang
|
||
});
|
||
}
|
||
|
||
// Internal tracking
|
||
// QR Code shared via ${method}
|
||
}
|
||
|
||
async generateQRWithTimer(e) {
|
||
e.preventDefault();
|
||
|
||
// Check rate limit for anonymous users
|
||
if (!this.checkRateLimit()) return;
|
||
|
||
// Validation
|
||
if (!this.validateForm()) return;
|
||
|
||
// Start timer
|
||
this.startTime = performance.now();
|
||
this.showGenerationStarted();
|
||
|
||
const requestData = this.collectFormData();
|
||
|
||
try {
|
||
// Build fetch options based on request type
|
||
const fetchOptions = {
|
||
method: 'POST',
|
||
body: requestData.isMultipart ? requestData.data : JSON.stringify(requestData.data)
|
||
};
|
||
|
||
// Add Content-Type header only for JSON requests (FormData sets its own)
|
||
if (!requestData.isMultipart) {
|
||
fetchOptions.headers = {
|
||
'Content-Type': 'application/json'
|
||
};
|
||
}
|
||
|
||
// Sending request to backend
|
||
|
||
const response = await fetch(requestData.endpoint, fetchOptions);
|
||
|
||
if (!response.ok) {
|
||
const errorData = await response.json().catch(() => ({}));
|
||
|
||
if (response.status === 429) {
|
||
this.showUpgradeModal(window.QRRapidoTranslations?.rateLimitReached || 'QR codes limit reached!');
|
||
return;
|
||
}
|
||
|
||
if (response.status === 400 && errorData.requiresPremium) {
|
||
this.showUpgradeModal(errorData.error || window.QRRapidoTranslations?.premiumLogoRequired || 'Premium logo required.');
|
||
return;
|
||
}
|
||
|
||
throw new Error(errorData.error || 'Erro na geração');
|
||
}
|
||
|
||
const result = await response.json();
|
||
|
||
if (!result.success) {
|
||
if (result.requiresPremium) {
|
||
this.showUpgradeModal(result.error || 'Logo personalizado é exclusivo do plano Premium.');
|
||
return;
|
||
}
|
||
throw new Error(result.error || 'Erro desconhecido');
|
||
}
|
||
|
||
const generationTime = ((performance.now() - this.startTime) / 1000).toFixed(1);
|
||
|
||
console.log('✅ QR code recebido do backend:', {
|
||
success: result.success,
|
||
hasBase64: !!result.qrCodeBase64,
|
||
base64Length: result.qrCodeBase64?.length || 0,
|
||
generationTime: generationTime + 's'
|
||
});
|
||
|
||
this.displayQRResult(result, generationTime);
|
||
this.updateSpeedStats(generationTime);
|
||
this.trackGenerationEvent(requestData.data.type || requestData.data.get('type'), generationTime);
|
||
|
||
} catch (error) {
|
||
console.error('❌ Erro ao gerar QR:', error);
|
||
this.showError(this.languageStrings[this.currentLang].error);
|
||
} finally {
|
||
this.hideGenerationLoading();
|
||
}
|
||
}
|
||
|
||
validateForm() {
|
||
const qrType = document.getElementById('qr-type').value;
|
||
|
||
if (!qrType) {
|
||
this.showError('Selecione o tipo de QR code');
|
||
return false;
|
||
}
|
||
|
||
// Special validation for VCard
|
||
if (qrType === 'vcard') {
|
||
try {
|
||
if (window.vcardGenerator) {
|
||
const errors = window.vcardGenerator.validateVCardData();
|
||
if (errors.length > 0) {
|
||
this.showError(errors.join('<br>'));
|
||
return false;
|
||
}
|
||
return true;
|
||
} else {
|
||
this.showError(window.QRRapidoTranslations?.featureNotAvailable || 'Feature not available');
|
||
return false;
|
||
}
|
||
} catch (error) {
|
||
this.showError((window.QRRapidoTranslations?.vCardValidationError || 'VCard validation error: ') + error.message);
|
||
return false;
|
||
}
|
||
} else if (qrType === 'wifi') {
|
||
const errors = window.wifiGenerator.validateWiFiData();
|
||
if (errors.length > 0) {
|
||
this.showError(errors.join('<br>'));
|
||
return false;
|
||
}
|
||
return true;
|
||
} else if (qrType === 'sms') {
|
||
const errors = window.smsGenerator.validateSMSData();
|
||
if (errors.length > 0) {
|
||
this.showError(errors.join('<br>'));
|
||
return false;
|
||
}
|
||
return true;
|
||
} else if (qrType === 'email') {
|
||
const errors = window.emailGenerator.validateEmailData();
|
||
if (errors.length > 0) {
|
||
this.showError(errors.join('<br>'));
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Normal validation for other types
|
||
const qrContent = document.getElementById('qr-content').value.trim();
|
||
|
||
if (!qrContent) {
|
||
this.showError(window.QRRapidoTranslations?.enterQRContent || 'Enter QR code content');
|
||
return false;
|
||
}
|
||
|
||
if (qrContent.length > 4000) {
|
||
this.showError(window.QRRapidoTranslations?.contentTooLong || 'Content too long. Maximum 4000 characters.');
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
collectFormData() {
|
||
const type = document.getElementById('qr-type').value;
|
||
const quickStyle = document.querySelector('input[name="quick-style"]:checked')?.value || 'classic';
|
||
const styleSettings = this.getStyleSettings(quickStyle);
|
||
|
||
// Check if logo is selected FIRST - this determines the endpoint
|
||
const logoUpload = document.getElementById('logo-upload');
|
||
const hasLogo = logoUpload && logoUpload.files && logoUpload.files[0];
|
||
|
||
// Get content based on type
|
||
let content, actualType;
|
||
|
||
if (type === 'url') {
|
||
let dynamicData;
|
||
if (typeof this.getDynamicQRData === 'function') {
|
||
dynamicData = this.getDynamicQRData();
|
||
} else {
|
||
// Fallback se a função não existir
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
const isDynamic = dynamicToggle && dynamicToggle.checked && this.isPremium;
|
||
dynamicData = {
|
||
isDynamic: isDynamic,
|
||
originalUrl: document.getElementById('qr-content').value,
|
||
requiresPremium: !this.isPremium && isDynamic
|
||
};
|
||
}
|
||
|
||
if (dynamicData.requiresPremium) {
|
||
throw new Error('QR Dinâmico é exclusivo para usuários Premium. Faça upgrade para usar analytics.');
|
||
}
|
||
content = dynamicData.originalUrl;
|
||
actualType = 'url';
|
||
} else if (type === 'wifi') {
|
||
content = window.wifiGenerator.generateWiFiString();
|
||
actualType = 'text'; // WiFi is treated as text in the backend
|
||
} else if (type === 'sms') {
|
||
content = window.smsGenerator.generateSMSString();
|
||
actualType = 'text';
|
||
} else if (type === 'email') {
|
||
content = window.emailGenerator.generateEmailString();
|
||
actualType = 'text';
|
||
} else if (type === 'vcard') {
|
||
if (!window.vcardGenerator) {
|
||
throw new Error('VCard generator não está disponível');
|
||
}
|
||
content = window.vcardGenerator.getVCardContent();
|
||
actualType = 'vcard'; // Keep as vcard type for tracking
|
||
} else {
|
||
// Default case - get content from input
|
||
content = document.getElementById('qr-content').value;
|
||
actualType = type;
|
||
}
|
||
|
||
// Prepare final content
|
||
const encodedContent = this.prepareContentForQR(content, actualType);
|
||
|
||
// Get colors
|
||
const userPrimaryColor = document.getElementById('primary-color').value;
|
||
const userBackgroundColor = document.getElementById('bg-color').value;
|
||
const finalPrimaryColor = userPrimaryColor || (styleSettings.primaryColor || '#000000');
|
||
const finalBackgroundColor = userBackgroundColor || (styleSettings.backgroundColor || '#FFFFFF');
|
||
|
||
// Common data for both endpoints
|
||
const commonData = {
|
||
type: actualType,
|
||
content: encodedContent,
|
||
quickStyle: quickStyle,
|
||
primaryColor: finalPrimaryColor,
|
||
backgroundColor: finalBackgroundColor,
|
||
size: parseInt(document.getElementById('qr-size').value),
|
||
margin: parseInt(document.getElementById('qr-margin').value),
|
||
cornerStyle: document.getElementById('corner-style')?.value || 'square',
|
||
optimizeForSpeed: true,
|
||
language: this.currentLang
|
||
};
|
||
|
||
// Add dynamic QR data if it's a URL type
|
||
if (type === 'url') {
|
||
let dynamicData;
|
||
if (typeof this.getDynamicQRData === 'function') {
|
||
dynamicData = this.getDynamicQRData();
|
||
} else {
|
||
// Fallback se a função não existir
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
const isDynamic = dynamicToggle && dynamicToggle.checked && this.isPremium;
|
||
dynamicData = {
|
||
isDynamic: isDynamic,
|
||
originalUrl: document.getElementById('qr-content').value,
|
||
requiresPremium: !this.isPremium && isDynamic
|
||
};
|
||
}
|
||
commonData.isDynamic = dynamicData.isDynamic;
|
||
}
|
||
|
||
if (hasLogo) {
|
||
// Use FormData for requests with logo
|
||
const formData = new FormData();
|
||
|
||
// Add all common data to FormData
|
||
Object.keys(commonData).forEach(key => {
|
||
formData.append(key, commonData[key]);
|
||
});
|
||
|
||
// NOVOS PARÂMETROS DE LOGO APRIMORADO
|
||
const logoSettings = this.getLogoSettings();
|
||
formData.append('LogoSizePercent', logoSettings.logoSizePercent.toString());
|
||
formData.append('ApplyLogoColorization', logoSettings.applyColorization.toString());
|
||
|
||
// Add logo file
|
||
formData.append('logo', logoUpload.files[0]);
|
||
|
||
// CORREÇÃO: Log detalhado antes de enviar
|
||
const logoSizeSlider = document.getElementById('logo-size-slider');
|
||
const logoColorizeToggle = document.getElementById('logo-colorize-toggle');
|
||
|
||
console.log('🎨 Preparando FormData com logo:', {
|
||
logoFile: logoUpload.files[0].name,
|
||
logoSize: logoUpload.files[0].size + ' bytes',
|
||
LogoSizePercent: logoSettings.logoSizePercent,
|
||
ApplyLogoColorization: logoSettings.applyColorization,
|
||
checkboxChecked: logoColorizeToggle?.checked,
|
||
endpoint: '/api/QR/GenerateRapidWithLogo'
|
||
});
|
||
|
||
return {
|
||
data: formData,
|
||
isMultipart: true,
|
||
endpoint: '/api/QR/GenerateRapidWithLogo'
|
||
};
|
||
} else {
|
||
// Usar JSON para QR sem logo (método original)
|
||
console.log('📝 Preparando JSON sem logo - endpoint: /api/QR/GenerateRapid');
|
||
|
||
return {
|
||
data: commonData,
|
||
isMultipart: false,
|
||
endpoint: '/api/QR/GenerateRapid'
|
||
};
|
||
}
|
||
}
|
||
|
||
// Nova função para coletar configurações de logo
|
||
getLogoSettings() {
|
||
const logoSizeSlider = document.getElementById('logo-size-slider');
|
||
const logoColorizeToggle = document.getElementById('logo-colorize-toggle');
|
||
|
||
return {
|
||
logoSizePercent: parseInt(logoSizeSlider?.value || '20'),
|
||
applyColorization: logoColorizeToggle?.checked || false
|
||
};
|
||
}
|
||
|
||
// Função auxiliar para obter conteúdo baseado no tipo
|
||
getContentForType(type) {
|
||
if (type === 'url') {
|
||
let dynamicData;
|
||
if (typeof this.getDynamicQRData === 'function') {
|
||
dynamicData = this.getDynamicQRData();
|
||
} else {
|
||
// Fallback se a função não existir
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
const isDynamic = dynamicToggle && dynamicToggle.checked && this.isPremium;
|
||
dynamicData = {
|
||
isDynamic: isDynamic,
|
||
originalUrl: document.getElementById('qr-content').value,
|
||
requiresPremium: !this.isPremium && isDynamic
|
||
};
|
||
}
|
||
return dynamicData?.originalUrl || document.getElementById('qr-content').value;
|
||
} else if (type === 'wifi') {
|
||
return window.wifiGenerator?.generateWiFiString() || '';
|
||
} else if (type === 'vcard') {
|
||
return window.vcardGenerator?.getVCardContent() || '';
|
||
} else if (type === 'sms') {
|
||
return window.smsGenerator?.generateSMSString() || '';
|
||
} else if (type === 'email') {
|
||
return window.emailGenerator?.generateEmailString() || '';
|
||
} else {
|
||
return document.getElementById('qr-content').value || '';
|
||
}
|
||
}
|
||
|
||
getStyleSettings(style) {
|
||
const styles = {
|
||
classic: { primaryColor: '#000000', backgroundColor: '#FFFFFF' },
|
||
modern: { primaryColor: '#007BFF', backgroundColor: '#F8F9FA' },
|
||
colorful: { primaryColor: '#FF6B35', backgroundColor: '#FFF3E0' }
|
||
};
|
||
return styles[style] || styles.classic;
|
||
}
|
||
|
||
displayQRResult(result, generationTime) {
|
||
const previewDiv = document.getElementById('qr-preview');
|
||
if (!previewDiv) return;
|
||
|
||
// CORREÇÃO SIMPLES: Remover cache buster que quebrava a imagem e adicionar debug
|
||
const imageUrl = `data:image/png;base64,${result.qrCodeBase64}`;
|
||
|
||
previewDiv.innerHTML = `
|
||
<img src="${imageUrl}"
|
||
class="img-fluid border rounded shadow-sm"
|
||
alt="QR Code gerado em ${generationTime}s"
|
||
style="image-rendering: crisp-edges;">
|
||
`;
|
||
|
||
// Exibir análise de legibilidade do logo se disponível
|
||
if (result.readabilityInfo && typeof this.displayReadabilityAnalysis === 'function') {
|
||
this.displayReadabilityAnalysis(result.readabilityInfo);
|
||
}
|
||
|
||
// CORREÇÃO: Log para debug - verificar se QR code tem logo
|
||
const logoUpload = document.getElementById('logo-upload');
|
||
const hasLogo = logoUpload && logoUpload.files && logoUpload.files.length > 0;
|
||
console.log('✅ QR Code exibido:', {
|
||
hasLogo: hasLogo,
|
||
logoFile: hasLogo ? logoUpload.files[0].name : 'nenhum',
|
||
generationTime: generationTime + 's',
|
||
imageSize: result.qrCodeBase64.length + ' chars',
|
||
readabilityScore: result.readabilityInfo?.readabilityScore
|
||
});
|
||
|
||
// Show generation statistics
|
||
this.showGenerationStats(generationTime);
|
||
|
||
// Show download buttons
|
||
const downloadSection = document.getElementById('download-section');
|
||
if (downloadSection) {
|
||
downloadSection.style.display = 'block';
|
||
}
|
||
|
||
// Save current data
|
||
this.currentQR = {
|
||
base64: result.qrCodeBase64,
|
||
qrCodeBase64: result.qrCodeBase64, // Both properties for compatibility
|
||
id: result.qrId,
|
||
generationTime: generationTime,
|
||
readabilityInfo: result.readabilityInfo
|
||
};
|
||
|
||
// Increment rate limit counter after successful generation
|
||
this.incrementRateLimit();
|
||
|
||
// Update counter for logged users
|
||
if (result.remainingQRs !== undefined) {
|
||
if (result.remainingQRs === -1 || result.remainingQRs === 2147483647 || result.remainingQRs >= 1000000) {
|
||
// Logged user - show unlimited
|
||
this.showUnlimitedCounter();
|
||
} else {
|
||
this.updateRemainingCounter(result.remainingQRs);
|
||
}
|
||
}
|
||
}
|
||
|
||
showGenerationStarted() {
|
||
const button = document.getElementById('generate-btn');
|
||
const spinner = button?.querySelector('.spinner-border');
|
||
const timer = document.querySelector('.generation-timer');
|
||
|
||
if (button) button.disabled = true;
|
||
if (spinner) spinner.classList.remove('d-none');
|
||
if (timer) timer.classList.remove('d-none');
|
||
|
||
// Update timer in real time
|
||
this.timerInterval = setInterval(() => {
|
||
const elapsed = ((performance.now() - this.startTime) / 1000).toFixed(1);
|
||
const timerSpan = timer?.querySelector('span');
|
||
if (timerSpan) {
|
||
timerSpan.textContent = `${elapsed}s`;
|
||
}
|
||
}, 100);
|
||
|
||
// Preview loading
|
||
const preview = document.getElementById('qr-preview');
|
||
if (preview) {
|
||
preview.innerHTML = `
|
||
<div class="text-center p-4">
|
||
<div class="spinner-border text-primary mb-3" role="status"></div>
|
||
<p class="text-muted">${this.languageStrings[this.currentLang].generating}</p>
|
||
<div class="progress">
|
||
<div class="progress-bar progress-bar-striped progress-bar-animated"
|
||
style="width: 100%"></div>
|
||
</div>
|
||
</div>
|
||
`;
|
||
}
|
||
}
|
||
|
||
showGenerationStats(generationTime) {
|
||
const statsDiv = document.querySelector('.generation-stats');
|
||
const speedBadge = document.querySelector('.speed-badge');
|
||
|
||
if (statsDiv) {
|
||
statsDiv.classList.remove('d-none');
|
||
const timeSpan = statsDiv.querySelector('.generation-time');
|
||
if (timeSpan) {
|
||
timeSpan.textContent = `${generationTime}s`;
|
||
}
|
||
}
|
||
|
||
// Show speed badge
|
||
if (speedBadge) {
|
||
const strings = this.languageStrings[this.currentLang];
|
||
let badgeText = strings.normal;
|
||
let badgeClass = 'bg-secondary';
|
||
|
||
if (generationTime < 1.0) {
|
||
badgeText = strings.ultraFast;
|
||
badgeClass = 'bg-success';
|
||
} else if (generationTime < 2.0) {
|
||
badgeText = strings.fast;
|
||
badgeClass = 'bg-primary';
|
||
}
|
||
|
||
speedBadge.innerHTML = `
|
||
<span class="badge ${badgeClass}">
|
||
<i class="fas fa-bolt"></i> ${badgeText}
|
||
</span>
|
||
`;
|
||
speedBadge.classList.remove('d-none');
|
||
}
|
||
}
|
||
|
||
hideGenerationLoading() {
|
||
const button = document.getElementById('generate-btn');
|
||
const spinner = button?.querySelector('.spinner-border');
|
||
|
||
if (button) button.disabled = false;
|
||
if (spinner) spinner.classList.add('d-none');
|
||
|
||
if (this.timerInterval) {
|
||
clearInterval(this.timerInterval);
|
||
this.timerInterval = null;
|
||
}
|
||
}
|
||
|
||
updateContentHints() {
|
||
const type = document.getElementById('qr-type')?.value;
|
||
const hintsElement = document.getElementById('content-hints');
|
||
const vcardInterface = document.getElementById('vcard-interface');
|
||
const contentTextarea = document.getElementById('qr-content');
|
||
|
||
if (!hintsElement || !type) return;
|
||
|
||
// Show/hide VCard interface based on type
|
||
if (type === 'vcard') {
|
||
if (vcardInterface) vcardInterface.style.display = 'block';
|
||
if (contentTextarea) {
|
||
contentTextarea.style.display = 'none';
|
||
contentTextarea.removeAttribute('required');
|
||
}
|
||
hintsElement.textContent = 'Preencha os campos acima para criar seu cartão de visita digital';
|
||
return; // Skip normal hints for VCard
|
||
} else {
|
||
if (vcardInterface) vcardInterface.style.display = 'none';
|
||
if (contentTextarea) {
|
||
contentTextarea.style.display = 'block';
|
||
contentTextarea.setAttribute('required', 'required');
|
||
}
|
||
}
|
||
|
||
const hints = {
|
||
'pt-BR': {
|
||
'url': 'Ex: https://www.exemplo.com.br',
|
||
'text': 'Digite qualquer texto que desejar',
|
||
'wifi': 'Nome da rede;Senha;Tipo de segurança (WPA/WEP)',
|
||
'vcard': 'Nome;Telefone;Email;Empresa',
|
||
'sms': 'Número;Mensagem',
|
||
'email': 'email@exemplo.com;Assunto;Mensagem'
|
||
},
|
||
'es': {
|
||
'url': 'Ej: https://www.ejemplo.com',
|
||
'text': 'Escribe cualquier texto que desees',
|
||
'wifi': 'Nombre de red;Contraseña;Tipo de seguridad (WPA/WEP)',
|
||
'vcard': 'Nombre;Teléfono;Email;Empresa',
|
||
'sms': 'Número;Mensaje',
|
||
'email': 'email@ejemplo.com;Asunto;Mensagem'
|
||
}
|
||
};
|
||
|
||
const langHints = hints[this.currentLang] || hints['pt-BR'];
|
||
hintsElement.textContent = langHints[type] || 'Digite o conteúdo apropriado para o tipo selecionado';
|
||
}
|
||
|
||
changeLanguage(e) {
|
||
e.preventDefault();
|
||
this.currentLang = e.target.dataset.lang;
|
||
this.updateLanguage();
|
||
this.updateContentHints();
|
||
|
||
// Save preference
|
||
localStorage.setItem('qrrapido-lang', this.currentLang);
|
||
|
||
// Track language change
|
||
window.trackLanguageChange && window.trackLanguageChange('pt-BR', this.currentLang);
|
||
}
|
||
|
||
updateLanguage() {
|
||
const strings = this.languageStrings[this.currentLang];
|
||
|
||
// Update tagline
|
||
const tagline = document.getElementById('tagline');
|
||
if (tagline) {
|
||
tagline.textContent = strings.tagline;
|
||
}
|
||
|
||
// Update language selector
|
||
const langMap = { 'pt-BR': 'PT', 'es': 'ES', 'en': 'EN' };
|
||
const currentLang = document.getElementById('current-lang');
|
||
if (currentLang) {
|
||
currentLang.textContent = langMap[this.currentLang];
|
||
}
|
||
|
||
// Update hints if type already selected
|
||
const qrType = document.getElementById('qr-type');
|
||
if (qrType?.value) {
|
||
this.updateContentHints();
|
||
}
|
||
}
|
||
|
||
handleLogoSelection(e) {
|
||
const file = e.target.files[0];
|
||
const logoPreview = document.getElementById('logo-preview');
|
||
const logoFilename = document.getElementById('logo-filename');
|
||
const logoPreviewImage = document.getElementById('logo-preview-image');
|
||
|
||
if (file) {
|
||
// Validate file size (2MB max)
|
||
if (file.size > 2 * 1024 * 1024) {
|
||
this.showError(window.QRRapidoTranslations?.logoTooLarge || 'Logo too large. Maximum 2MB.');
|
||
e.target.value = ''; // Clear the input
|
||
logoPreview?.classList.add('d-none');
|
||
return;
|
||
}
|
||
|
||
// Validate file type
|
||
const allowedTypes = ['image/png', 'image/jpeg', 'image/jpg'];
|
||
if (!allowedTypes.includes(file.type)) {
|
||
this.showError(window.QRRapidoTranslations?.invalidLogoFormat || 'Invalid format. Use PNG or JPG.');
|
||
e.target.value = ''; // Clear the input
|
||
logoPreview?.classList.add('d-none');
|
||
return;
|
||
}
|
||
|
||
// Create FileReader to show image preview
|
||
const reader = new FileReader();
|
||
reader.onload = (e) => {
|
||
if (logoPreviewImage) {
|
||
logoPreviewImage.src = e.target.result;
|
||
const logoVisualPreview = document.getElementById('logo-visual-preview');
|
||
if (logoVisualPreview) logoVisualPreview.style.display = 'block';
|
||
}
|
||
|
||
// Show file information
|
||
if (logoFilename) {
|
||
const fileSizeKB = Math.round(file.size / 1024);
|
||
logoFilename.textContent = `${file.name} (${fileSizeKB}KB)`;
|
||
}
|
||
|
||
logoPreview?.classList.remove('d-none');
|
||
|
||
// CORREÇÃO: Log detalhado do logo selecionado
|
||
console.log('📁 Logo selecionado:', {
|
||
name: file.name,
|
||
size: Math.round(file.size / 1024) + 'KB',
|
||
type: file.type,
|
||
timestamp: new Date().toLocaleTimeString()
|
||
});
|
||
|
||
// Atualizar preview de legibilidade
|
||
if (typeof this.updateLogoReadabilityPreview === 'function') {
|
||
this.updateLogoReadabilityPreview();
|
||
}
|
||
};
|
||
reader.readAsDataURL(file);
|
||
} else {
|
||
// Limpar preview quando arquivo removido
|
||
logoPreview?.classList.add('d-none');
|
||
const logoVisualPreview = document.getElementById('logo-visual-preview');
|
||
if (logoVisualPreview) logoVisualPreview.style.display = 'none';
|
||
if (logoPreviewImage) logoPreviewImage.src = '';
|
||
|
||
// Limpar preview de legibilidade
|
||
if (typeof this.clearReadabilityPreview === 'function') {
|
||
this.clearReadabilityPreview();
|
||
}
|
||
|
||
console.log('🗑️ Logo removido');
|
||
}
|
||
}
|
||
|
||
handleCornerStyleChange(e) {
|
||
const selectedStyle = e.target.value;
|
||
const premiumStyles = ['rounded', 'circle', 'leaf'];
|
||
|
||
if (premiumStyles.includes(selectedStyle)) {
|
||
// Check if user is premium (we can detect this by checking if the option is disabled)
|
||
const option = e.target.options[e.target.selectedIndex];
|
||
if (option.disabled) {
|
||
// Reset to square
|
||
e.target.value = 'square';
|
||
this.showUpgradeModal(window.QRRapidoTranslations?.premiumCornerStyleRequired || 'Custom corner styles are exclusive to Premium plan.');
|
||
return;
|
||
}
|
||
}
|
||
|
||
console.log('Corner style selected:', selectedStyle);
|
||
}
|
||
|
||
applyQuickStyle(e) {
|
||
const style = e.target.value;
|
||
const settings = this.getStyleSettings(style);
|
||
|
||
const primaryColor = document.getElementById('primary-color');
|
||
const bgColor = document.getElementById('bg-color');
|
||
|
||
if (primaryColor) primaryColor.value = settings.primaryColor;
|
||
if (bgColor) bgColor.value = settings.backgroundColor;
|
||
}
|
||
|
||
updateStatsCounters() {
|
||
// Simulate real-time counters
|
||
setInterval(() => {
|
||
const totalElement = document.getElementById('total-qrs');
|
||
if (totalElement) {
|
||
const current = parseFloat(totalElement.textContent.replace('K', '')) || 10.5;
|
||
const newValue = (current + Math.random() * 0.1).toFixed(1);
|
||
totalElement.textContent = `${newValue}K`;
|
||
}
|
||
|
||
// Update average time based on real performance
|
||
const avgElement = document.getElementById('avg-generation-time');
|
||
if (avgElement && window.qrRapidoStats) {
|
||
const avg = window.qrRapidoStats.getAverageTime();
|
||
avgElement.textContent = `${avg}s`;
|
||
}
|
||
}, 30000); // Update every 30 seconds
|
||
}
|
||
|
||
async initializeUserCounter() {
|
||
try {
|
||
const response = await fetch('/api/QR/GetUserStats');
|
||
if (response.ok) {
|
||
const stats = await response.json();
|
||
console.log('User stats loaded:', stats);
|
||
console.log('remainingCount:', stats.remainingCount, 'type:', typeof stats.remainingCount);
|
||
console.log('isUnlimited:', stats.isUnlimited);
|
||
|
||
// For logged users, always show unlimited (they all have unlimited QR codes)
|
||
console.log('Calling showUnlimitedCounter directly for logged user');
|
||
this.showUnlimitedCounter();
|
||
} else {
|
||
console.log('GetUserStats response not ok:', response.status);
|
||
}
|
||
} catch (error) {
|
||
// If not authenticated or error, keep the default "Carregando..." text
|
||
console.debug('User not authenticated or error loading stats:', error);
|
||
}
|
||
}
|
||
|
||
trackGenerationEvent(type, time) {
|
||
// Google Analytics
|
||
if (typeof gtag !== 'undefined') {
|
||
gtag('event', 'qr_generated', {
|
||
'qr_type': type,
|
||
'generation_time': parseFloat(time),
|
||
'user_type': this.isPremiumUser() ? 'premium' : 'free',
|
||
'language': this.currentLang
|
||
});
|
||
}
|
||
|
||
// Internal statistics
|
||
if (!window.qrRapidoStats) {
|
||
window.qrRapidoStats = {
|
||
times: [],
|
||
getAverageTime: function() {
|
||
if (this.times.length === 0) return '1.2';
|
||
const avg = this.times.reduce((a, b) => a + b) / this.times.length;
|
||
return avg.toFixed(1);
|
||
}
|
||
};
|
||
}
|
||
window.qrRapidoStats.times.push(parseFloat(time));
|
||
}
|
||
|
||
updateSpeedStats(generationTime) {
|
||
// Update the live statistics display
|
||
const timeFloat = parseFloat(generationTime);
|
||
|
||
// Update average time display in the stats cards
|
||
// Find h5 elements in card bodies and look for one containing time info
|
||
const cardElements = document.querySelectorAll('.card-body h5');
|
||
cardElements.forEach(element => {
|
||
// Look for elements containing time format (e.g., "1.2s", "0.8s", etc.)
|
||
if (element.textContent.includes('s') && element.textContent.match(/\d+\.\d+s/)) {
|
||
const avgTime = window.qrRapidoStats ? window.qrRapidoStats.getAverageTime() : generationTime;
|
||
element.innerHTML = `<i class="fas fa-stopwatch"></i> ${avgTime}s`;
|
||
}
|
||
});
|
||
|
||
// Update the generation timer in the header
|
||
const timerElement = document.querySelector('.generation-timer span');
|
||
if (timerElement) {
|
||
timerElement.textContent = `${generationTime}s`;
|
||
}
|
||
|
||
// Update performance statistics
|
||
if (!window.qrRapidoPerformance) {
|
||
window.qrRapidoPerformance = {
|
||
totalGenerations: 0,
|
||
totalTime: 0,
|
||
bestTime: Infinity,
|
||
worstTime: 0
|
||
};
|
||
}
|
||
|
||
const perf = window.qrRapidoPerformance;
|
||
perf.totalGenerations++;
|
||
perf.totalTime += timeFloat;
|
||
perf.bestTime = Math.min(perf.bestTime, timeFloat);
|
||
perf.worstTime = Math.max(perf.worstTime, timeFloat);
|
||
|
||
// Log performance statistics for debugging
|
||
console.log('📊 Performance Update:', {
|
||
currentTime: `${generationTime}s`,
|
||
averageTime: `${(perf.totalTime / perf.totalGenerations).toFixed(1)}s`,
|
||
bestTime: `${perf.bestTime.toFixed(1)}s`,
|
||
totalGenerations: perf.totalGenerations
|
||
});
|
||
}
|
||
|
||
isPremiumUser() {
|
||
return document.querySelector('.text-success')?.textContent.includes('Premium Ativo') || false;
|
||
}
|
||
|
||
async downloadQR(format) {
|
||
if (!this.currentQR || !this.currentQR.qrCodeBase64) {
|
||
this.showError('Nenhum QR Code gerado para download.');
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const timestamp = new Date().toISOString().slice(0,10);
|
||
const base64Data = this.currentQR.qrCodeBase64;
|
||
|
||
if (format === 'png') {
|
||
// Download PNG directly from base64
|
||
const link = document.createElement('a');
|
||
link.href = `data:image/png;base64,${base64Data}`;
|
||
link.download = `qrrapido-${timestamp}.png`;
|
||
document.body.appendChild(link);
|
||
link.click();
|
||
document.body.removeChild(link);
|
||
|
||
} else if (format === 'svg') {
|
||
// Convert PNG to SVG
|
||
const svgData = await this.convertPngToSvg(base64Data);
|
||
const link = document.createElement('a');
|
||
link.href = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgData)}`;
|
||
link.download = `qrrapido-${timestamp}.svg`;
|
||
document.body.appendChild(link);
|
||
link.click();
|
||
document.body.removeChild(link);
|
||
|
||
} else if (format === 'pdf') {
|
||
// Convert PNG to PDF
|
||
const pdfBlob = await this.convertPngToPdf(base64Data);
|
||
const url = window.URL.createObjectURL(pdfBlob);
|
||
const link = document.createElement('a');
|
||
link.href = url;
|
||
link.download = `qrrapido-${timestamp}.pdf`;
|
||
document.body.appendChild(link);
|
||
link.click();
|
||
document.body.removeChild(link);
|
||
window.URL.revokeObjectURL(url);
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error('Download error:', error);
|
||
this.showError(`Erro ao fazer download ${format.toUpperCase()}. Tente novamente.`);
|
||
}
|
||
}
|
||
|
||
async convertPngToSvg(base64Data) {
|
||
return new Promise((resolve) => {
|
||
const img = new Image();
|
||
img.onload = () => {
|
||
const canvas = document.createElement('canvas');
|
||
const ctx = canvas.getContext('2d');
|
||
canvas.width = img.width;
|
||
canvas.height = img.height;
|
||
ctx.drawImage(img, 0, 0);
|
||
|
||
// Create SVG with embedded base64 image
|
||
const svgData = `<?xml version="1.0" encoding="UTF-8"?>
|
||
<svg width="${img.width}" height="${img.height}" xmlns="http://www.w3.org/2000/svg">
|
||
<image width="${img.width}" height="${img.height}" href="data:image/png;base64,${base64Data}"/>
|
||
</svg>`;
|
||
resolve(svgData);
|
||
};
|
||
img.src = `data:image/png;base64,${base64Data}`;
|
||
});
|
||
}
|
||
|
||
async convertPngToPdf(base64Data) {
|
||
return new Promise((resolve, reject) => {
|
||
try {
|
||
// Try to use jsPDF if available, otherwise use a simpler approach
|
||
if (typeof window.jsPDF !== 'undefined') {
|
||
const pdf = new window.jsPDF();
|
||
const img = new Image();
|
||
img.onload = () => {
|
||
// Calculate dimensions to fit on page
|
||
const pdfWidth = pdf.internal.pageSize.getWidth();
|
||
const pdfHeight = pdf.internal.pageSize.getHeight();
|
||
const imgRatio = img.width / img.height;
|
||
|
||
let width = Math.min(pdfWidth - 20, 150);
|
||
let height = width / imgRatio;
|
||
|
||
if (height > pdfHeight - 20) {
|
||
height = pdfHeight - 20;
|
||
width = height * imgRatio;
|
||
}
|
||
|
||
// Center on page
|
||
const x = (pdfWidth - width) / 2;
|
||
const y = (pdfHeight - height) / 2;
|
||
|
||
pdf.addImage(`data:image/png;base64,${base64Data}`, 'PNG', x, y, width, height);
|
||
const pdfBlob = pdf.output('blob');
|
||
resolve(pdfBlob);
|
||
};
|
||
img.onerror = () => reject(new Error('Failed to load image'));
|
||
img.src = `data:image/png;base64,${base64Data}`;
|
||
} else {
|
||
// Fallback: create a very simple PDF
|
||
this.createBasicPdf(base64Data).then(resolve).catch(reject);
|
||
}
|
||
} catch (error) {
|
||
reject(error);
|
||
}
|
||
});
|
||
}
|
||
|
||
async createBasicPdf(base64Data) {
|
||
// Load jsPDF dynamically if not available
|
||
if (typeof window.jsPDF === 'undefined') {
|
||
await this.loadJsPDF();
|
||
}
|
||
|
||
return new Promise((resolve) => {
|
||
const pdf = new window.jsPDF();
|
||
const img = new Image();
|
||
img.onload = () => {
|
||
// Add QR code to PDF
|
||
const pdfWidth = pdf.internal.pageSize.getWidth();
|
||
const size = Math.min(pdfWidth - 40, 100);
|
||
const x = (pdfWidth - size) / 2;
|
||
const y = 50;
|
||
|
||
pdf.addImage(`data:image/png;base64,${base64Data}`, 'PNG', x, y, size, size);
|
||
pdf.text('QR Code - QR Rapido', pdfWidth / 2, 30, { align: 'center' });
|
||
|
||
const pdfBlob = pdf.output('blob');
|
||
resolve(pdfBlob);
|
||
};
|
||
img.src = `data:image/png;base64,${base64Data}`;
|
||
});
|
||
}
|
||
|
||
async loadJsPDF() {
|
||
return new Promise((resolve, reject) => {
|
||
if (typeof window.jsPDF !== 'undefined') {
|
||
resolve();
|
||
return;
|
||
}
|
||
|
||
const script = document.createElement('script');
|
||
script.src = 'https://cdnjs.cloudflare.com/ajax/libs/jspdf/2.5.1/jspdf.umd.min.js';
|
||
script.onload = () => {
|
||
window.jsPDF = window.jspdf.jsPDF;
|
||
resolve();
|
||
};
|
||
script.onerror = () => reject(new Error('Failed to load jsPDF'));
|
||
document.head.appendChild(script);
|
||
});
|
||
}
|
||
|
||
async saveToHistory() {
|
||
if (!this.currentQR) return;
|
||
|
||
try {
|
||
const response = await fetch('/api/QR/SaveToHistory', {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
},
|
||
body: JSON.stringify({
|
||
qrId: this.currentQR.id
|
||
})
|
||
});
|
||
|
||
if (response.ok) {
|
||
this.showSuccess(this.languageStrings[this.currentLang].success);
|
||
} else {
|
||
throw new Error('Failed to save');
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error('Save error:', error);
|
||
this.showError(window.QRRapidoTranslations?.errorSavingHistory || 'Error saving to history.');
|
||
}
|
||
}
|
||
|
||
async checkAdFreeStatus() {
|
||
try {
|
||
const response = await fetch('/Account/AdFreeStatus');
|
||
const status = await response.json();
|
||
|
||
if (status.isAdFree) {
|
||
this.hideAllAds();
|
||
this.showAdFreeMessage(status.timeRemaining);
|
||
}
|
||
|
||
} catch (error) {
|
||
console.error('Error checking ad-free status:', error);
|
||
}
|
||
}
|
||
|
||
hideAllAds() {
|
||
document.querySelectorAll('.ad-container').forEach(ad => {
|
||
ad.style.display = 'none';
|
||
});
|
||
}
|
||
|
||
showAdFreeMessage(timeRemaining) {
|
||
if (timeRemaining <= 0) return;
|
||
|
||
const existing = document.querySelector('.ad-free-notice');
|
||
if (existing) return; // Already shown
|
||
|
||
const message = document.createElement('div');
|
||
message.className = 'alert alert-success text-center mb-3 ad-free-notice';
|
||
message.innerHTML = `
|
||
<i class="fas fa-crown text-warning"></i>
|
||
<strong>Sessão sem anúncios ativa!</strong>
|
||
Tempo restante: <span class="ad-free-countdown">${this.formatTime(timeRemaining)}</span>
|
||
<a href="/Premium/Upgrade" class="btn btn-sm btn-warning ms-2">Tornar Permanente</a>
|
||
`;
|
||
|
||
const container = document.querySelector('.container');
|
||
const row = container?.querySelector('.row');
|
||
if (container && row) {
|
||
container.insertBefore(message, row);
|
||
}
|
||
}
|
||
|
||
formatTime(minutes) {
|
||
if (minutes === 0) return '0m';
|
||
|
||
const days = Math.floor(minutes / 1440);
|
||
const hours = Math.floor((minutes % 1440) / 60);
|
||
const mins = minutes % 60;
|
||
|
||
if (days > 0) return `${days}d ${hours}h ${mins}m`;
|
||
if (hours > 0) return `${hours}h ${mins}m`;
|
||
return `${mins}m`;
|
||
}
|
||
|
||
showUpgradeModal(message) {
|
||
const modal = document.createElement('div');
|
||
modal.className = 'modal fade';
|
||
modal.innerHTML = `
|
||
<div class="modal-dialog">
|
||
<div class="modal-content">
|
||
<div class="modal-header bg-warning">
|
||
<h5 class="modal-title">
|
||
<i class="fas fa-crown"></i> Upgrade para Premium
|
||
</h5>
|
||
<button type="button" class="btn-close" data-bs-dismiss="modal"></button>
|
||
</div>
|
||
<div class="modal-body">
|
||
<p>${message}</p>
|
||
<div class="row">
|
||
<div class="col-md-6">
|
||
<h6>Plano Atual (Free)</h6>
|
||
<ul class="list-unstyled">
|
||
<li>❌ Limite de 10 QR/dia</li>
|
||
<li>❌ Anúncios</li>
|
||
<li>✅ QR básicos</li>
|
||
</ul>
|
||
</div>
|
||
<div class="col-md-6">
|
||
<h6>Premium (R$ 19,90/mês)</h6>
|
||
<ul class="list-unstyled">
|
||
<li>✅ QR ilimitados</li>
|
||
<li>✅ Sem anúncios</li>
|
||
<li>✅ QR dinâmicos</li>
|
||
<li>✅ Analytics</li>
|
||
<li>✅ Suporte prioritário</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="modal-footer">
|
||
<button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Cancelar</button>
|
||
<a href="/Premium/Upgrade" class="btn btn-warning">
|
||
<i class="fas fa-crown"></i> Fazer Upgrade
|
||
</a>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
`;
|
||
|
||
document.body.appendChild(modal);
|
||
const bsModal = new bootstrap.Modal(modal);
|
||
bsModal.show();
|
||
|
||
// Remove modal when closed
|
||
modal.addEventListener('hidden.bs.modal', () => {
|
||
document.body.removeChild(modal);
|
||
});
|
||
}
|
||
|
||
updateRemainingCounter(remaining) {
|
||
const counterElement = document.querySelector('.qr-counter');
|
||
if (counterElement && remaining !== null && remaining !== undefined) {
|
||
// If it's unlimited (any special value indicating unlimited)
|
||
if (remaining === -1 || remaining >= 2147483647 || remaining > 1000000) {
|
||
this.showUnlimitedCounter();
|
||
return;
|
||
}
|
||
|
||
const remainingText = this.getLocalizedString('QRCodesRemainingToday');
|
||
counterElement.textContent = `${remaining} ${remainingText}`;
|
||
|
||
if (remaining <= 3) {
|
||
counterElement.className = 'badge bg-warning qr-counter';
|
||
}
|
||
if (remaining === 0) {
|
||
counterElement.className = 'badge bg-danger qr-counter';
|
||
}
|
||
}
|
||
}
|
||
|
||
showUnlimitedCounter() {
|
||
console.log('showUnlimitedCounter called');
|
||
const counterElement = document.querySelector('.qr-counter');
|
||
if (counterElement) {
|
||
counterElement.textContent = 'QR Codes ilimitados';
|
||
counterElement.className = 'badge bg-success qr-counter';
|
||
console.log('Set counter to: QR Codes ilimitados');
|
||
} else {
|
||
console.log('Counter element not found');
|
||
}
|
||
}
|
||
|
||
showError(message) {
|
||
this.showAlert(message, 'danger');
|
||
}
|
||
|
||
showSuccess(message) {
|
||
this.showAlert(message, 'success');
|
||
}
|
||
|
||
showAlert(message, type) {
|
||
// Create toast container if doesn't exist
|
||
let toastContainer = document.getElementById('toast-container');
|
||
if (!toastContainer) {
|
||
toastContainer = document.createElement('div');
|
||
toastContainer.id = 'toast-container';
|
||
toastContainer.className = 'toast-container position-fixed top-0 end-0 p-3';
|
||
toastContainer.style.zIndex = '1060';
|
||
document.body.appendChild(toastContainer);
|
||
}
|
||
|
||
// Create toast element
|
||
const toast = document.createElement('div');
|
||
toast.className = `toast align-items-center text-bg-${type} border-0`;
|
||
toast.setAttribute('role', 'alert');
|
||
toast.innerHTML = `
|
||
<div class="d-flex">
|
||
<div class="toast-body">
|
||
<i class="fas fa-${type === 'danger' ? 'exclamation-triangle' : 'check-circle'}"></i>
|
||
${message}
|
||
</div>
|
||
<button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast"></button>
|
||
</div>
|
||
`;
|
||
|
||
toastContainer.appendChild(toast);
|
||
|
||
// Show toast
|
||
const bsToast = new bootstrap.Toast(toast, {
|
||
delay: type === 'success' ? 3000 : 5000,
|
||
autohide: true
|
||
});
|
||
bsToast.show();
|
||
|
||
// Remove from DOM after hidden
|
||
toast.addEventListener('hidden.bs.toast', () => {
|
||
if (toast.parentNode) {
|
||
toast.parentNode.removeChild(toast);
|
||
}
|
||
});
|
||
}
|
||
|
||
setupRealTimePreview() {
|
||
const contentField = document.getElementById('qr-content');
|
||
const typeField = document.getElementById('qr-type');
|
||
|
||
if (contentField && typeField) {
|
||
let previewTimeout;
|
||
const updatePreview = () => {
|
||
clearTimeout(previewTimeout);
|
||
previewTimeout = setTimeout(() => {
|
||
if (contentField.value.trim() && typeField.value) {
|
||
// Could implement real-time preview for premium users
|
||
console.log('Real-time preview update');
|
||
}
|
||
}, 500);
|
||
};
|
||
|
||
contentField.addEventListener('input', updatePreview);
|
||
typeField.addEventListener('change', updatePreview);
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// SISTEMA DE FLUXO ASCENDENTE PROGRESSIVO
|
||
// ============================================
|
||
|
||
initializeProgressiveFlow() {
|
||
// Estado inicial: apenas tipo habilitado, botão gerar desabilitado
|
||
const qrContent = document.getElementById('qr-content');
|
||
const vcardInterface = document.getElementById('vcard-interface');
|
||
|
||
// FIXED: Don't disable content field initially - let enableContentFields handle it
|
||
// The field should be available for typing once a type is selected
|
||
|
||
// Ocultar interface vCard
|
||
if (vcardInterface) {
|
||
vcardInterface.style.display = 'none';
|
||
}
|
||
|
||
this.updateGenerateButton();
|
||
|
||
// Setup URL validation event listeners
|
||
this.setupURLValidationListeners();
|
||
|
||
// Setup hint auto-hide timer
|
||
this.setupHintAutoHide();
|
||
}
|
||
|
||
setupHintAutoHide() {
|
||
const hint = document.getElementById('type-selection-hint');
|
||
if (hint) {
|
||
// Auto-hide after 30 seconds
|
||
setTimeout(() => {
|
||
if (hint && !hint.classList.contains('fade-out')) {
|
||
hint.classList.add('fade-out');
|
||
// Remove from DOM after animation
|
||
setTimeout(() => {
|
||
if (hint.parentNode) {
|
||
hint.style.display = 'none';
|
||
}
|
||
}, 1000); // 1s for fade-out animation
|
||
}
|
||
}, 30000); // 30 seconds
|
||
}
|
||
}
|
||
|
||
setupURLValidationListeners() {
|
||
const contentField = document.getElementById('qr-content');
|
||
if (!contentField) return;
|
||
|
||
// Auto-fix URL on blur (when user leaves the field)
|
||
contentField.addEventListener('blur', () => {
|
||
const type = document.getElementById('qr-type')?.value;
|
||
|
||
if (type === 'url' && contentField.value.trim()) {
|
||
const originalValue = contentField.value.trim();
|
||
const fixedValue = this.autoFixURL(originalValue);
|
||
|
||
if (originalValue !== fixedValue) {
|
||
contentField.value = fixedValue;
|
||
console.log('🔧 URL auto-corrigida:', originalValue, '→', fixedValue);
|
||
|
||
// Revalidar após correção
|
||
this.updateGenerateButton();
|
||
}
|
||
}
|
||
});
|
||
|
||
// Real-time validation with debounce
|
||
contentField.addEventListener('input', () => {
|
||
const type = document.getElementById('qr-type')?.value;
|
||
|
||
if (type === 'url') {
|
||
// Debounce para não validar a cada caractere
|
||
clearTimeout(contentField.validationTimeout);
|
||
contentField.validationTimeout = setTimeout(() => {
|
||
this.updateGenerateButton();
|
||
}, 500);
|
||
}
|
||
});
|
||
}
|
||
|
||
handleTypeSelection(type) {
|
||
this.selectedType = type;
|
||
|
||
if (type) {
|
||
this.removeInitialHighlight();
|
||
// Sempre habilitar campos de conteúdo após selecionar tipo
|
||
this.enableContentFields(type);
|
||
// Show guidance toast for the selected type
|
||
this.showTypeGuidanceToast(type);
|
||
} else {
|
||
this.disableAllFields();
|
||
}
|
||
|
||
this.updateGenerateButton();
|
||
}
|
||
|
||
handleStyleSelection(style) {
|
||
this.selectedStyle = style;
|
||
this.updateGenerateButton();
|
||
}
|
||
|
||
handleContentChange(content) {
|
||
const contentField = document.getElementById('qr-content');
|
||
this.contentValid = this.validateContent(content);
|
||
|
||
// Feedback visual para campo de conteúdo
|
||
if (contentField) {
|
||
this.validateField(contentField, this.contentValid, window.QRRapidoTranslations?.validationContentMinLength || 'Content must have at least 3 characters');
|
||
}
|
||
|
||
this.updateGenerateButton();
|
||
}
|
||
|
||
enableContentFields(type) {
|
||
const contentGroup = document.getElementById('content-group');
|
||
const vcardInterface = document.getElementById('vcard-interface');
|
||
const wifiInterface = document.getElementById('wifi-interface');
|
||
const smsInterface = document.getElementById('sms-interface');
|
||
const emailInterface = document.getElementById('email-interface');
|
||
const dynamicQRSection = document.getElementById('dynamic-qr-section');
|
||
const urlPreview = document.getElementById('url-preview');
|
||
|
||
// Hide all interfaces by default
|
||
if (vcardInterface) vcardInterface.style.display = 'none';
|
||
if (wifiInterface) wifiInterface.style.display = 'none';
|
||
if (smsInterface) smsInterface.style.display = 'none';
|
||
if (emailInterface) emailInterface.style.display = 'none';
|
||
if (dynamicQRSection) dynamicQRSection.style.display = 'none';
|
||
if (urlPreview) urlPreview.style.display = 'none';
|
||
if (contentGroup) contentGroup.style.display = 'block';
|
||
|
||
if (type === 'vcard') {
|
||
// Para vCard, ocultar textarea e mostrar interface específica
|
||
if (contentGroup) contentGroup.style.display = 'none';
|
||
if (vcardInterface) {
|
||
vcardInterface.style.display = 'block';
|
||
this.enableVCardFields();
|
||
}
|
||
} else if (type === 'wifi') {
|
||
// Para WiFi, ocultar textarea e mostrar interface específica
|
||
if (contentGroup) contentGroup.style.display = 'none';
|
||
if (wifiInterface) {
|
||
wifiInterface.style.display = 'block';
|
||
}
|
||
} else if (type === 'sms') {
|
||
// Para SMS, ocultar textarea e mostrar interface específica
|
||
if (contentGroup) contentGroup.style.display = 'none';
|
||
if (smsInterface) {
|
||
smsInterface.style.display = 'block';
|
||
}
|
||
} else if (type === 'email') {
|
||
// Para Email, ocultar textarea e mostrar interface específica
|
||
if (contentGroup) contentGroup.style.display = 'none';
|
||
if (emailInterface) {
|
||
emailInterface.style.display = 'block';
|
||
}
|
||
} else if (type === 'url') {
|
||
if (dynamicQRSection) dynamicQRSection.style.display = 'block';
|
||
if (urlPreview) urlPreview.style.display = 'block';
|
||
// CRITICAL FIX: Enable content field for URL type
|
||
const qrContent = document.getElementById('qr-content');
|
||
if(qrContent) {
|
||
qrContent.disabled = false;
|
||
}
|
||
} else {
|
||
// Para outros tipos, mostrar textarea
|
||
if (contentGroup) contentGroup.style.display = 'block';
|
||
const qrContent = document.getElementById('qr-content');
|
||
if(qrContent) {
|
||
qrContent.disabled = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
enableVCardFields() {
|
||
const requiredFields = ['vcard-name', 'vcard-mobile', 'vcard-email'];
|
||
requiredFields.forEach(fieldId => {
|
||
const field = document.getElementById(fieldId);
|
||
if (field) {
|
||
field.disabled = false;
|
||
field.setAttribute('required', 'required');
|
||
}
|
||
});
|
||
}
|
||
|
||
disableAllFields() {
|
||
// Resetar estado
|
||
const qrContent = document.getElementById('qr-content');
|
||
const vcardInterface = document.getElementById('vcard-interface');
|
||
|
||
if (qrContent) {
|
||
// FIXED: Don't disable content field, just clear it
|
||
qrContent.value = '';
|
||
}
|
||
|
||
if (vcardInterface) {
|
||
vcardInterface.style.display = 'none';
|
||
// Limpar campos vCard
|
||
const vcardFields = document.querySelectorAll('#vcard-interface input');
|
||
vcardFields.forEach(field => {
|
||
field.value = '';
|
||
field.disabled = true;
|
||
});
|
||
}
|
||
|
||
this.contentValid = false;
|
||
}
|
||
|
||
validateContent(content) {
|
||
if (!content) return false;
|
||
return content.trim().length >= 3;
|
||
}
|
||
|
||
validateVCardFields() {
|
||
const nameField = document.getElementById('vcard-name');
|
||
const mobileField = document.getElementById('vcard-mobile');
|
||
const emailField = document.getElementById('vcard-email');
|
||
|
||
const name = nameField?.value.trim() || '';
|
||
const mobile = mobileField?.value.trim() || '';
|
||
const email = emailField?.value.trim() || '';
|
||
|
||
// Validação individual dos campos com feedback visual
|
||
this.validateField(nameField, name !== '', 'Nome é obrigatório');
|
||
this.validateField(mobileField, mobile !== '' && mobile.length >= 10, 'Telefone deve ter pelo menos 10 dígitos');
|
||
this.validateField(emailField, email !== '' && email.includes('@'), 'Email válido é obrigatório');
|
||
|
||
const isValid = name !== '' && mobile !== '' && email !== '' && email.includes('@') && mobile.length >= 10;
|
||
this.contentValid = isValid;
|
||
|
||
return isValid;
|
||
}
|
||
|
||
validateField(field, isValid, errorMessage) {
|
||
if (!field) return;
|
||
|
||
const feedbackElement = field.parentNode.querySelector('.invalid-feedback');
|
||
|
||
if (isValid) {
|
||
field.classList.remove('is-invalid');
|
||
field.classList.add('is-valid');
|
||
if (feedbackElement) {
|
||
feedbackElement.style.display = 'none';
|
||
}
|
||
} else if (field.value.trim() !== '') {
|
||
// Só mostrar erro se o campo tem conteúdo
|
||
field.classList.remove('is-valid');
|
||
field.classList.add('is-invalid');
|
||
if (feedbackElement) {
|
||
feedbackElement.textContent = errorMessage;
|
||
feedbackElement.style.display = 'block';
|
||
}
|
||
} else {
|
||
// Campo vazio, remover validações visuais
|
||
field.classList.remove('is-valid', 'is-invalid');
|
||
if (feedbackElement) {
|
||
feedbackElement.style.display = 'none';
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================================
|
||
// URL VALIDATION FUNCTIONS
|
||
// ============================================
|
||
|
||
isValidURL(url) {
|
||
if (!url || typeof url !== 'string') return false;
|
||
|
||
const trimmedUrl = url.trim();
|
||
|
||
// Verificar se começa com http:// ou https://
|
||
const hasProtocol = trimmedUrl.startsWith('http://') || trimmedUrl.startsWith('https://');
|
||
|
||
// Verificar se tem pelo menos um ponto
|
||
const hasDot = trimmedUrl.includes('.');
|
||
|
||
// Verificar se não é só o protocolo
|
||
const hasContent = trimmedUrl.length > 8; // mais que "https://"
|
||
|
||
// Regex mais robusta
|
||
const urlRegex = /^https?:\/\/.+\..+/i;
|
||
|
||
return hasProtocol && hasDot && hasContent && urlRegex.test(trimmedUrl);
|
||
}
|
||
|
||
autoFixURL(url) {
|
||
if (!url || typeof url !== 'string') return '';
|
||
|
||
let fixedUrl = url.trim();
|
||
|
||
// Se não tem protocolo, adicionar https://
|
||
if (!fixedUrl.startsWith('http://') && !fixedUrl.startsWith('https://')) {
|
||
fixedUrl = 'https://' + fixedUrl;
|
||
}
|
||
|
||
return fixedUrl;
|
||
}
|
||
|
||
showValidationError(message) {
|
||
let errorDiv = document.getElementById('url-validation-error');
|
||
|
||
if (!errorDiv) {
|
||
// Criar div de erro se não existir
|
||
errorDiv = document.createElement('div');
|
||
errorDiv.id = 'url-validation-error';
|
||
errorDiv.className = 'alert alert-danger mt-2';
|
||
errorDiv.style.display = 'none';
|
||
|
||
// Inserir após o campo de conteúdo
|
||
const contentGroup = document.getElementById('content-group');
|
||
if (contentGroup) {
|
||
contentGroup.appendChild(errorDiv);
|
||
}
|
||
}
|
||
|
||
errorDiv.innerHTML = `<small><i class="fas fa-exclamation-triangle"></i> ${message}</small>`;
|
||
errorDiv.style.display = 'block';
|
||
}
|
||
|
||
clearValidationError() {
|
||
const errorDiv = document.getElementById('url-validation-error');
|
||
if (errorDiv) {
|
||
errorDiv.style.display = 'none';
|
||
}
|
||
}
|
||
|
||
updateGenerateButton() {
|
||
const generateBtn = document.getElementById('generate-btn');
|
||
if (!generateBtn) return;
|
||
|
||
let isValid = false;
|
||
const type = this.selectedType;
|
||
|
||
if (type === 'url') {
|
||
const contentField = document.getElementById('qr-content');
|
||
const content = contentField?.value || '';
|
||
const trimmedContent = content.trim();
|
||
|
||
if (!trimmedContent) {
|
||
this.showValidationError('URL é obrigatória');
|
||
if (contentField) {
|
||
contentField.classList.remove('is-valid');
|
||
contentField.classList.add('is-invalid');
|
||
}
|
||
isValid = false;
|
||
} else if (!this.isValidURL(trimmedContent)) {
|
||
this.showValidationError('URL deve começar com http:// ou https:// e conter pelo menos um ponto (ex: https://google.com)');
|
||
if (contentField) {
|
||
contentField.classList.remove('is-valid');
|
||
contentField.classList.add('is-invalid');
|
||
}
|
||
isValid = false;
|
||
} else {
|
||
this.clearValidationError();
|
||
if (contentField) {
|
||
contentField.classList.remove('is-invalid');
|
||
contentField.classList.add('is-valid');
|
||
}
|
||
isValid = true;
|
||
}
|
||
} else if (type === 'text') {
|
||
const contentField = document.getElementById('qr-content');
|
||
const content = contentField?.value || '';
|
||
isValid = content.trim().length >= 3;
|
||
this.clearValidationError(); // Clear any URL validation errors
|
||
if (contentField) {
|
||
contentField.classList.remove('is-valid', 'is-invalid');
|
||
}
|
||
} else if (type === 'vcard') {
|
||
isValid = this.validateVCardFields();
|
||
} else if (type === 'wifi') {
|
||
const data = window.wifiGenerator.collectWiFiData();
|
||
isValid = data.ssid.trim() !== '';
|
||
if (data.security !== 'nopass' && !data.password.trim()) {
|
||
isValid = false;
|
||
}
|
||
} else if (type === 'sms') {
|
||
const data = window.smsGenerator.collectSMSData();
|
||
isValid = data.number.trim() !== '' && data.message.trim() !== '';
|
||
} else if (type === 'email') {
|
||
const data = window.emailGenerator.collectEmailData();
|
||
isValid = data.to.trim() !== '' && data.subject.trim() !== '';
|
||
}
|
||
|
||
generateBtn.disabled = !isValid;
|
||
|
||
if (isValid) {
|
||
generateBtn.classList.remove('btn-secondary', 'disabled');
|
||
generateBtn.classList.add('btn-primary');
|
||
} else {
|
||
generateBtn.classList.remove('btn-primary');
|
||
generateBtn.classList.add('btn-secondary', 'disabled');
|
||
}
|
||
}
|
||
|
||
// Remove destaque inicial quando tipo for selecionado
|
||
removeInitialHighlight() {
|
||
const typeField = document.getElementById('qr-type');
|
||
const hint = document.getElementById('type-selection-hint');
|
||
|
||
if (typeField && typeField.classList.contains('qr-type-highlight')) {
|
||
typeField.classList.remove('qr-type-highlight');
|
||
}
|
||
|
||
if (hint && !hint.classList.contains('fade-out')) {
|
||
hint.classList.add('fade-out');
|
||
// Hide after animation
|
||
setTimeout(() => {
|
||
if (hint.parentNode) {
|
||
hint.style.display = 'none';
|
||
}
|
||
}, 1000);
|
||
}
|
||
}
|
||
|
||
showTypeGuidanceToast(type) {
|
||
// Get localized message based on QR type
|
||
const messages = this.getTypeGuidanceMessages();
|
||
const message = messages[type];
|
||
|
||
if (message) {
|
||
// Create info toast with 30 second duration
|
||
const toast = this.createGuidanceToast(message);
|
||
this.showGuidanceToast(toast, 30000); // 30 seconds
|
||
}
|
||
}
|
||
|
||
getTypeGuidanceMessages() {
|
||
// These should match the resource file keys
|
||
// In a real implementation, these would come from server-side localization
|
||
// For now, we'll use the JavaScript language strings or fallback to Portuguese
|
||
return {
|
||
'url': document.querySelector('[data-type-guide-url]')?.textContent || '🌐 Para gerar QR de URL, digite o endereço completo (ex: https://google.com)',
|
||
'vcard': document.querySelector('[data-type-guide-vcard]')?.textContent || '👤 Para cartão de visita, preencha nome, telefone e email nos campos abaixo',
|
||
'wifi': document.querySelector('[data-type-guide-wifi]')?.textContent || '📶 Para WiFi, informe nome da rede, senha e tipo de segurança',
|
||
'sms': document.querySelector('[data-type-guide-sms]')?.textContent || '💬 Para SMS, digite o número do destinatário e a mensagem',
|
||
'email': document.querySelector('[data-type-guide-email]')?.textContent || '📧 Para email, preencha destinatário, assunto e mensagem (opcional)',
|
||
'text': document.querySelector('[data-type-guide-text]')?.textContent || '📝 Para texto livre, digite qualquer conteúdo que desejar'
|
||
};
|
||
}
|
||
|
||
createGuidanceToast(message) {
|
||
const toast = document.createElement('div');
|
||
toast.className = 'toast align-items-center text-bg-info border-0';
|
||
toast.setAttribute('role', 'alert');
|
||
toast.style.minWidth = '400px';
|
||
toast.innerHTML = `
|
||
<div class="d-flex">
|
||
<div class="toast-body fw-medium">
|
||
${message}
|
||
</div>
|
||
<button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast"></button>
|
||
</div>
|
||
`;
|
||
return toast;
|
||
}
|
||
|
||
showGuidanceToast(toast, duration = 30000) {
|
||
// Create toast container if doesn't exist (positioned below header stats)
|
||
let toastContainer = document.getElementById('guidance-toast-container');
|
||
if (!toastContainer) {
|
||
toastContainer = document.createElement('div');
|
||
toastContainer.id = 'guidance-toast-container';
|
||
toastContainer.className = 'toast-container position-relative w-100 d-flex justify-content-center mb-3';
|
||
toastContainer.style.zIndex = '1060';
|
||
|
||
// Try to find existing toast container first (if manually positioned)
|
||
const existingContainer = document.getElementById('guidance-toast-container');
|
||
if (existingContainer) {
|
||
// Use existing container that was manually positioned
|
||
toastContainer = existingContainer;
|
||
} else {
|
||
// Find the main content area and insert after hero section
|
||
const mainElement = document.querySelector('main[role="main"]');
|
||
if (mainElement) {
|
||
// Insert at the beginning of main content
|
||
mainElement.insertBefore(toastContainer, mainElement.firstChild);
|
||
} else {
|
||
// Fallback: find container and insert at top
|
||
const container = document.querySelector('.container');
|
||
if (container) {
|
||
container.insertBefore(toastContainer, container.firstChild);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
toastContainer.appendChild(toast);
|
||
|
||
// Show toast with custom duration
|
||
const bsToast = new bootstrap.Toast(toast, {
|
||
delay: duration,
|
||
autohide: true
|
||
});
|
||
bsToast.show();
|
||
|
||
// Remove from DOM after hidden
|
||
toast.addEventListener('hidden.bs.toast', () => {
|
||
if (toast.parentNode) {
|
||
toast.parentNode.removeChild(toast);
|
||
}
|
||
});
|
||
}
|
||
|
||
// ============================================
|
||
// FUNÇÕES DE CODIFICAÇÃO UTF-8
|
||
// ============================================
|
||
|
||
// Garantir codificação UTF-8 para todos os tipos de QR Code
|
||
prepareContentForQR(content, type) {
|
||
if (!content) return '';
|
||
|
||
// Garantir que o conteúdo seja tratado como UTF-8
|
||
try {
|
||
// Verificar se há caracteres especiais
|
||
const hasSpecialChars = /[^ -]/.test(content);
|
||
|
||
if (hasSpecialChars) {
|
||
console.log('Caracteres especiais detectados, aplicando codificação UTF-8');
|
||
// Forçar codificação UTF-8
|
||
const encoder = new TextEncoder();
|
||
const decoder = new TextDecoder();
|
||
const encoded = encoder.encode(content);
|
||
return decoder.decode(encoded);
|
||
}
|
||
|
||
return content;
|
||
} catch (error) {
|
||
console.warn('Erro na codificação UTF-8:', error);
|
||
return content;
|
||
}
|
||
}
|
||
|
||
// Validação de segurança para dados pessoais
|
||
validateDataSecurity() {
|
||
const placeholders = document.querySelectorAll('[placeholder]');
|
||
placeholders.forEach(el => {
|
||
const placeholder = el.placeholder;
|
||
|
||
// Verificar dados pessoais em placeholders
|
||
if (placeholder.includes('@') && placeholder.includes('gmail')) {
|
||
console.warn('Dado pessoal detectado em placeholder:', placeholder);
|
||
el.placeholder = 'seu.email@exemplo.com';
|
||
}
|
||
|
||
// Verificar números de telefone reais
|
||
if (placeholder.match(/\d{11}/) && !placeholder.includes('99999')) {
|
||
console.warn('Possível telefone real em placeholder:', placeholder);
|
||
el.placeholder = el.placeholder.replace(/\d{11}/, '11999998888');
|
||
}
|
||
});
|
||
}
|
||
|
||
// Teste da codificação UTF-8
|
||
testUTF8Encoding() {
|
||
const testStrings = [
|
||
'Ação rápida çáéíóú',
|
||
'João Gonçalves',
|
||
'Coração brasileiro',
|
||
'Situação especial'
|
||
];
|
||
|
||
console.group('🧪 Teste de Codificação UTF-8');
|
||
testStrings.forEach(str => {
|
||
const encoded = this.prepareContentForQR(str, 'text');
|
||
console.log(`Original: "${str}"`);
|
||
console.log(`Codificado: "${encoded}"`);
|
||
console.log('---');
|
||
});
|
||
|
||
// Teste específico para vCard
|
||
if (window.vcardGenerator) {
|
||
const testName = 'João Gonçalves';
|
||
const encoded = window.vcardGenerator.encodeQuotedPrintable(testName);
|
||
console.log(`vCard Quoted-Printable test:`);
|
||
console.log(`Original: "${testName}"`);
|
||
console.log(`Encoded: "${encoded}"`);
|
||
}
|
||
|
||
console.groupEnd();
|
||
}
|
||
|
||
// Rate Limiting Methods
|
||
initializeRateLimiting() {
|
||
// Wait a bit for DOM to be fully ready
|
||
setTimeout(() => {
|
||
this.updateRateDisplayCounter();
|
||
}, 100);
|
||
}
|
||
|
||
checkRateLimit() {
|
||
// Check if user is logged in (unlimited access)
|
||
const userStatus = document.getElementById('user-premium-status');
|
||
console.log('🔍 Rate limit check - User status:', userStatus ? userStatus.value : 'not found');
|
||
|
||
if (userStatus && (userStatus.value === 'logged-in' || userStatus.value === 'premium')) {
|
||
console.log('✅ User is logged in - unlimited access');
|
||
return true; // Unlimited for logged users
|
||
}
|
||
|
||
// For anonymous users, check daily limit
|
||
const today = new Date().toDateString();
|
||
const cookieName = 'qr_daily_count';
|
||
const rateLimitData = this.getCookie(cookieName);
|
||
|
||
console.log('📅 Today:', today);
|
||
console.log('🍪 Cookie data:', rateLimitData);
|
||
|
||
let currentData = { date: today, count: 0 };
|
||
|
||
if (rateLimitData) {
|
||
try {
|
||
currentData = JSON.parse(rateLimitData);
|
||
console.log('📊 Parsed data:', currentData);
|
||
|
||
// Reset count if it's a new day
|
||
if (currentData.date !== today) {
|
||
console.log('🔄 New day detected, resetting count');
|
||
currentData = { date: today, count: 0 };
|
||
}
|
||
} catch (e) {
|
||
console.log('❌ Error parsing cookie:', e);
|
||
currentData = { date: today, count: 0 };
|
||
}
|
||
} else {
|
||
console.log('🆕 No cookie found, starting fresh');
|
||
}
|
||
|
||
console.log('📈 Current count:', currentData.count);
|
||
|
||
// Check if limit exceeded (don't increment here)
|
||
if (currentData.count >= 3) {
|
||
console.log('🚫 Rate limit exceeded');
|
||
this.showRateLimitError();
|
||
return false;
|
||
}
|
||
|
||
console.log('✅ Rate limit check passed');
|
||
return true;
|
||
}
|
||
|
||
incrementRateLimit() {
|
||
// Only increment after successful QR generation
|
||
const userStatus = document.getElementById('user-premium-status');
|
||
if (userStatus && userStatus.value === 'logged-in') {
|
||
return; // No limits for logged users
|
||
}
|
||
|
||
const today = new Date().toDateString();
|
||
const cookieName = 'qr_daily_count';
|
||
const rateLimitData = this.getCookie(cookieName);
|
||
|
||
let currentData = { date: today, count: 0 };
|
||
|
||
if (rateLimitData) {
|
||
try {
|
||
currentData = JSON.parse(rateLimitData);
|
||
if (currentData.date !== today) {
|
||
currentData = { date: today, count: 0 };
|
||
}
|
||
} catch (e) {
|
||
currentData = { date: today, count: 0 };
|
||
}
|
||
}
|
||
|
||
// Increment count and save
|
||
currentData.count++;
|
||
this.setCookie(cookieName, JSON.stringify(currentData), 1);
|
||
|
||
// Update display counter
|
||
this.updateRateDisplayCounter();
|
||
}
|
||
|
||
showRateLimitError() {
|
||
const message = this.getLocalizedString('RateLimitExceeded') || 'Daily limit reached! Login for unlimited access.';
|
||
this.showError(message);
|
||
}
|
||
|
||
updateRateDisplayCounter() {
|
||
const counterElement = document.querySelector('.qr-counter');
|
||
if (!counterElement) return;
|
||
|
||
// Check user status
|
||
const userStatus = document.getElementById('user-premium-status');
|
||
|
||
if (userStatus && userStatus.value === 'premium') {
|
||
// Premium users have unlimited QRs
|
||
const unlimitedText = this.getLocalizedString('UnlimitedToday');
|
||
counterElement.textContent = unlimitedText;
|
||
counterElement.className = 'badge bg-success qr-counter';
|
||
return;
|
||
} else if (userStatus && userStatus.value === 'logged-in') {
|
||
// Free logged users - we need to get their actual remaining count
|
||
this.updateLoggedUserCounter();
|
||
return;
|
||
}
|
||
|
||
// For anonymous users, show remaining count
|
||
const today = new Date().toDateString();
|
||
const cookieName = 'qr_daily_count';
|
||
const rateLimitData = this.getCookie(cookieName);
|
||
|
||
let remaining = 3;
|
||
|
||
if (rateLimitData) {
|
||
try {
|
||
const currentData = JSON.parse(rateLimitData);
|
||
if (currentData.date === today) {
|
||
remaining = Math.max(0, 3 - currentData.count);
|
||
}
|
||
} catch (e) {
|
||
remaining = 3;
|
||
}
|
||
}
|
||
|
||
const remainingText = this.getLocalizedString('QRCodesRemainingToday');
|
||
counterElement.textContent = `${remaining} ${remainingText}`;
|
||
}
|
||
|
||
async updateLoggedUserCounter() {
|
||
const counterElement = document.querySelector('.qr-counter');
|
||
if (!counterElement) return;
|
||
|
||
try {
|
||
// Fetch user's remaining QR count from the server
|
||
const response = await fetch('/api/QR/GetUserStats', {
|
||
method: 'GET',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
}
|
||
});
|
||
|
||
if (response.ok) {
|
||
const data = await response.json();
|
||
|
||
if (data.isPremium) {
|
||
// Premium user - show unlimited
|
||
const unlimitedText = this.getLocalizedString('UnlimitedToday');
|
||
counterElement.textContent = unlimitedText;
|
||
counterElement.className = 'badge bg-success qr-counter';
|
||
} else {
|
||
// Free user - show remaining count
|
||
const remaining = data.remainingCount || 0;
|
||
const remainingText = this.getLocalizedString('QRCodesRemainingToday');
|
||
if (remaining !== -1) {
|
||
counterElement.textContent = `${remaining} ${remainingText}`;
|
||
|
||
counterElement.className = 'badge bg-primary qr-counter';
|
||
if (remaining <= 3) {
|
||
counterElement.className = 'badge bg-warning qr-counter';
|
||
}
|
||
if (remaining === 0) {
|
||
counterElement.className = 'badge bg-danger qr-counter';
|
||
}
|
||
}
|
||
else {
|
||
const unlimitedText = this.getLocalizedString('UnlimitedToday');
|
||
counterElement.textContent = unlimitedText;
|
||
counterElement.className = 'badge bg-success qr-counter';
|
||
}
|
||
}
|
||
} else {
|
||
// Fallback to showing 50 remaining if API fails
|
||
const remainingText = this.getLocalizedString('QRCodesRemainingToday');
|
||
counterElement.textContent = `50 ${remainingText}`;
|
||
counterElement.className = 'badge bg-primary qr-counter';
|
||
}
|
||
} catch (error) {
|
||
console.warn('Failed to fetch user stats:', error);
|
||
// Fallback to showing 50 remaining if API fails
|
||
const remainingText = this.getLocalizedString('QRCodesRemainingToday');
|
||
counterElement.textContent = `50 ${remainingText}`;
|
||
counterElement.className = 'badge bg-primary qr-counter';
|
||
}
|
||
}
|
||
|
||
getLocalizedString(key) {
|
||
// Try to get from server-side localization first
|
||
const element = document.querySelector(`[data-localized="${key}"]`);
|
||
if (element) {
|
||
const text = element.textContent.trim() || element.value;
|
||
if (text) return text;
|
||
}
|
||
|
||
// Fallback to client-side strings
|
||
if (this.languageStrings[this.currentLang] && this.languageStrings[this.currentLang][key]) {
|
||
return this.languageStrings[this.currentLang][key];
|
||
}
|
||
|
||
// Default fallbacks based on key
|
||
const defaults = {
|
||
'UnlimitedToday': 'Ilimitado hoje',
|
||
'QRCodesRemainingToday': 'QR codes restantes hoje',
|
||
'RateLimitExceeded': 'Limite diário atingido! Faça login para acesso ilimitado.'
|
||
};
|
||
|
||
return defaults[key] || key;
|
||
}
|
||
|
||
setCookie(name, value, days) {
|
||
const expires = new Date();
|
||
expires.setTime(expires.getTime() + (days * 24 * 60 * 60 * 1000));
|
||
document.cookie = `${name}=${value};expires=${expires.toUTCString()};path=/;SameSite=Strict`;
|
||
}
|
||
|
||
getCookie(name) {
|
||
const nameEQ = name + "=";
|
||
const ca = document.cookie.split(';');
|
||
for (let i = 0; i < ca.length; i++) {
|
||
let c = ca[i];
|
||
while (c.charAt(0) === ' ') c = c.substring(1, c.length);
|
||
if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length, c.length);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// Debug/reset function - call from console if needed
|
||
resetRateLimit() {
|
||
// Multiple ways to clear the cookie
|
||
document.cookie = 'qr_daily_count=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
|
||
document.cookie = 'qr_daily_count=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; domain=' + window.location.hostname + ';';
|
||
document.cookie = 'qr_daily_count=; max-age=0; path=/;';
|
||
|
||
// Also clear from storage if exists
|
||
if (typeof Storage !== "undefined") {
|
||
localStorage.removeItem('qr_daily_count');
|
||
sessionStorage.removeItem('qr_daily_count');
|
||
}
|
||
|
||
this.updateRateDisplayCounter();
|
||
console.log('🧹 Rate limit completely reset!');
|
||
console.log('🍪 All cookies:', document.cookie);
|
||
}
|
||
}
|
||
|
||
// Initialize when DOM loads
|
||
document.addEventListener('DOMContentLoaded', () => {
|
||
window.qrGenerator = new QRRapidoGenerator();
|
||
window.vcardGenerator = new VCardGenerator();
|
||
window.wifiGenerator = new WiFiQRGenerator();
|
||
window.smsGenerator = new SMSQRGenerator();
|
||
window.emailGenerator = new EmailQRGenerator();
|
||
window.dynamicQRManager = new DynamicQRManager();
|
||
|
||
// Initialize AdSense if necessary
|
||
if (window.adsbygoogle && document.querySelector('.adsbygoogle')) {
|
||
(adsbygoogle = window.adsbygoogle || []).push({});
|
||
}
|
||
});
|
||
|
||
class DynamicQRManager {
|
||
constructor() {
|
||
this.initializeDynamicQR();
|
||
}
|
||
|
||
initializeDynamicQR() {
|
||
// Verificar se usuário é premium
|
||
this.isPremium = this.checkUserPremium();
|
||
|
||
// Configurar interface baseado no status
|
||
this.setupPremiumInterface();
|
||
|
||
// Event listeners
|
||
this.setupEventListeners();
|
||
|
||
// Preview inicial
|
||
this.updatePreview();
|
||
}
|
||
|
||
|
||
checkUserPremium() {
|
||
// IMPLEMENTAR: verificar se usuário atual é premium
|
||
// Pode ser via elemento hidden, variável global, ou chamada AJAX
|
||
|
||
// Exemplo 1: Via elemento hidden
|
||
const premiumStatus = document.getElementById('user-premium-status');
|
||
if (premiumStatus) {
|
||
return premiumStatus.value === 'true';
|
||
}
|
||
|
||
// Exemplo 2: Via variável global
|
||
if (window.userInfo && window.userInfo.isPremium !== undefined) {
|
||
return window.userInfo.isPremium;
|
||
}
|
||
|
||
// Fallback: assumir não-premium
|
||
return false;
|
||
}
|
||
|
||
setupPremiumInterface() {
|
||
const toggleContainer = document.getElementById('dynamic-toggle-container');
|
||
const upgradePrompt = document.querySelector('.premium-upgrade-prompt');
|
||
|
||
if (this.isPremium) {
|
||
// Usuário premium: mostrar toggle funcional
|
||
if(toggleContainer) toggleContainer.style.display = 'block';
|
||
if (upgradePrompt) upgradePrompt.style.display = 'none';
|
||
} else {
|
||
// Usuário não-premium: mostrar prompt de upgrade
|
||
if(toggleContainer) toggleContainer.style.display = 'none';
|
||
if (upgradePrompt) upgradePrompt.style.display = 'block';
|
||
}
|
||
}
|
||
|
||
setupEventListeners() {
|
||
// Toggle do QR Dinâmico
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
if (dynamicToggle) {
|
||
dynamicToggle.addEventListener('change', () => {
|
||
this.updatePreview();
|
||
});
|
||
}
|
||
|
||
// Campo URL
|
||
const urlField = document.getElementById('qr-content');
|
||
if (urlField) {
|
||
urlField.addEventListener('input', () => {
|
||
this.updatePreview();
|
||
});
|
||
}
|
||
}
|
||
|
||
updatePreview() {
|
||
const urlField = document.getElementById('qr-content');
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
const finalUrlDisplay = document.getElementById('final-url-display');
|
||
const typeDisplay = document.getElementById('qr-type-display');
|
||
|
||
if (!urlField || !finalUrlDisplay || !typeDisplay) return;
|
||
|
||
const originalUrl = urlField.value;
|
||
const isDynamic = dynamicToggle && dynamicToggle.checked && this.isPremium;
|
||
|
||
if (isDynamic && originalUrl) {
|
||
// QR Dinâmico: mostra URL do QRRapido
|
||
finalUrlDisplay.textContent = `https://qrrapido.site/r/{ID_UNICO}`;
|
||
typeDisplay.textContent = "QR Code Dinâmico com Analytics ";
|
||
typeDisplay.className = "text-success fw-bold";
|
||
} else {
|
||
// QR Estático: mostra URL original
|
||
finalUrlDisplay.textContent = originalUrl || 'Digite uma URL...';
|
||
typeDisplay.textContent = "QR Code Estático";
|
||
typeDisplay.className = "text-muted";
|
||
}
|
||
}
|
||
|
||
// Método para integração com collectFormData()
|
||
getDynamicQRData() {
|
||
const dynamicToggle = document.getElementById('qr-dynamic-toggle');
|
||
const isDynamic = dynamicToggle && dynamicToggle.checked && this.isPremium;
|
||
|
||
return {
|
||
isDynamic: isDynamic,
|
||
originalUrl: document.getElementById('qr-content').value,
|
||
requiresPremium: !this.isPremium && isDynamic
|
||
};
|
||
}
|
||
|
||
displayReadabilityAnalysis(readabilityInfo) {
|
||
if (!readabilityInfo || !readabilityInfo.hasLogo) return;
|
||
|
||
// Criar ou encontrar container para análise de legibilidade
|
||
let analysisContainer = document.getElementById('readability-analysis');
|
||
if (!analysisContainer) {
|
||
// Criar container se não existir
|
||
analysisContainer = document.createElement('div');
|
||
analysisContainer.id = 'readability-analysis';
|
||
analysisContainer.className = 'mt-3 p-3 border rounded bg-light';
|
||
|
||
// Inserir após o preview do QR code
|
||
const previewDiv = document.getElementById('qr-preview');
|
||
if (previewDiv && previewDiv.parentNode) {
|
||
previewDiv.parentNode.insertBefore(analysisContainer, previewDiv.nextSibling);
|
||
}
|
||
}
|
||
|
||
// Determinar classe de cor baseada no score
|
||
const getScoreClass = (score) => {
|
||
if (score >= 85) return 'text-success';
|
||
if (score >= 70) return 'text-info';
|
||
if (score >= 55) return 'text-warning';
|
||
return 'text-danger';
|
||
};
|
||
|
||
// Determinar ícone baseado no nível de dificuldade
|
||
const getIconClass = (score) => {
|
||
if (score >= 85) return 'fas fa-check-circle';
|
||
if (score >= 70) return 'fas fa-thumbs-up';
|
||
if (score >= 55) return 'fas fa-exclamation-triangle';
|
||
return 'fas fa-exclamation-circle';
|
||
};
|
||
|
||
// Gerar lista de dicas
|
||
const tipsHtml = readabilityInfo.tips && readabilityInfo.tips.length > 0
|
||
? `<div class="collapse mt-2" id="readabilityTips">
|
||
<ul class="list-unstyled mb-0">
|
||
${readabilityInfo.tips.map(tip => `<li class="mb-1"><small>${tip}</small></li>`).join('')}
|
||
</ul>
|
||
</div>`
|
||
: '';
|
||
|
||
// Criar HTML da análise
|
||
const scoreClass = getScoreClass(readabilityInfo.readabilityScore);
|
||
const iconClass = getIconClass(readabilityInfo.readabilityScore);
|
||
|
||
analysisContainer.innerHTML = `
|
||
<div class="d-flex align-items-center justify-content-between">
|
||
<div class="d-flex align-items-center">
|
||
<i class="${iconClass} ${scoreClass} me-2"></i>
|
||
<div>
|
||
<h6 class="mb-1 ${scoreClass}">Análise de Legibilidade</h6>
|
||
<p class="mb-0 small">${readabilityInfo.userMessage}</p>
|
||
</div>
|
||
</div>
|
||
<div class="text-end">
|
||
<div class="badge bg-secondary">${readabilityInfo.readabilityScore}/100</div>
|
||
${readabilityInfo.tips && readabilityInfo.tips.length > 0
|
||
? `<button class="btn btn-sm btn-outline-secondary ms-2" type="button"
|
||
data-bs-toggle="collapse" data-bs-target="#readabilityTips">
|
||
<i class="fas fa-lightbulb"></i> Dicas
|
||
</button>`
|
||
: ''}
|
||
</div>
|
||
</div>
|
||
${tipsHtml}
|
||
`;
|
||
|
||
// Animação de entrada suave
|
||
analysisContainer.style.opacity = '0';
|
||
analysisContainer.style.transform = 'translateY(-10px)';
|
||
|
||
setTimeout(() => {
|
||
analysisContainer.style.transition = 'all 0.3s ease';
|
||
analysisContainer.style.opacity = '1';
|
||
analysisContainer.style.transform = 'translateY(0)';
|
||
}, 100);
|
||
|
||
console.log('📊 Análise de legibilidade exibida:', {
|
||
score: readabilityInfo.readabilityScore,
|
||
level: readabilityInfo.difficultyLevel,
|
||
logoSize: readabilityInfo.logoSizePercent + '%',
|
||
tipsCount: readabilityInfo.tips?.length || 0
|
||
});
|
||
}
|
||
|
||
updateLogoReadabilityPreview() {
|
||
const logoUpload = document.getElementById('logo-upload');
|
||
const logoSizeSlider = document.getElementById('logo-size-slider');
|
||
|
||
// Só mostrar preview se há logo selecionado
|
||
if (!logoUpload || !logoUpload.files || logoUpload.files.length === 0) {
|
||
this.clearReadabilityPreview();
|
||
return;
|
||
}
|
||
|
||
const logoSize = parseInt(logoSizeSlider?.value || '20');
|
||
|
||
// Calcular score estimado baseado apenas no tamanho (simplificado para preview)
|
||
let estimatedScore = 100;
|
||
if (logoSize > 20) {
|
||
estimatedScore -= (logoSize - 20) * 2;
|
||
}
|
||
estimatedScore = Math.max(40, estimatedScore); // Mínimo de 40
|
||
|
||
// Simular análise básica para preview
|
||
const previewInfo = {
|
||
hasLogo: true,
|
||
logoSizePercent: logoSize,
|
||
readabilityScore: estimatedScore,
|
||
difficultyLevel: this.getDifficultyLevelFromScore(estimatedScore),
|
||
userMessage: this.generatePreviewMessage(estimatedScore, logoSize),
|
||
tips: this.generatePreviewTips(logoSize, estimatedScore)
|
||
};
|
||
|
||
this.displayReadabilityPreview(previewInfo);
|
||
}
|
||
|
||
getDifficultyLevelFromScore(score) {
|
||
if (score >= 85) return 'VeryEasy';
|
||
if (score >= 70) return 'Easy';
|
||
if (score >= 55) return 'Medium';
|
||
if (score >= 40) return 'Hard';
|
||
return 'VeryHard';
|
||
}
|
||
|
||
generatePreviewMessage(score, logoSize) {
|
||
if (score >= 85) {
|
||
return `✅ Estimativa: Excelente legibilidade com logo de ${logoSize}%`;
|
||
} else if (score >= 70) {
|
||
return `🟢 Estimativa: Boa legibilidade com logo de ${logoSize}%`;
|
||
} else if (score >= 55) {
|
||
return `⚠️ Estimativa: Legibilidade moderada com logo de ${logoSize}%`;
|
||
} else {
|
||
return `🟡 Estimativa: Legibilidade baixa com logo de ${logoSize}%`;
|
||
}
|
||
}
|
||
|
||
generatePreviewTips(logoSize, score) {
|
||
const tips = [];
|
||
|
||
if (logoSize > 22) {
|
||
tips.push(`📏 Considere reduzir para 18-20% (atual: ${logoSize}%)`);
|
||
}
|
||
|
||
if (score < 70) {
|
||
tips.push('💡 Use boa iluminação ao escanear');
|
||
}
|
||
|
||
tips.push('🎨 PNG transparente melhora a legibilidade');
|
||
tips.push('📱 Teste em vários apps de QR Code');
|
||
|
||
return tips;
|
||
}
|
||
|
||
displayReadabilityPreview(previewInfo) {
|
||
// Usar a mesma função de display, mas com ID diferente para preview
|
||
let previewContainer = document.getElementById('readability-preview');
|
||
if (!previewContainer) {
|
||
previewContainer = document.createElement('div');
|
||
previewContainer.id = 'readability-preview';
|
||
previewContainer.className = 'mt-2 p-2 border rounded bg-info bg-opacity-10 border-info border-opacity-25';
|
||
|
||
// Inserir após o slider de tamanho do logo
|
||
const logoSizeSlider = document.getElementById('logo-size-slider');
|
||
if (logoSizeSlider && logoSizeSlider.parentNode) {
|
||
logoSizeSlider.parentNode.insertBefore(previewContainer, logoSizeSlider.nextSibling);
|
||
}
|
||
}
|
||
|
||
const scoreClass = previewInfo.readabilityScore >= 85 ? 'text-success' :
|
||
previewInfo.readabilityScore >= 70 ? 'text-info' :
|
||
previewInfo.readabilityScore >= 55 ? 'text-warning' : 'text-danger';
|
||
|
||
const iconClass = previewInfo.readabilityScore >= 85 ? 'fas fa-check-circle' :
|
||
previewInfo.readabilityScore >= 70 ? 'fas fa-thumbs-up' :
|
||
previewInfo.readabilityScore >= 55 ? 'fas fa-exclamation-triangle' : 'fas fa-exclamation-circle';
|
||
|
||
previewContainer.innerHTML = `
|
||
<div class="d-flex align-items-center justify-content-between">
|
||
<div class="d-flex align-items-center">
|
||
<i class="${iconClass} ${scoreClass} me-2"></i>
|
||
<small class="${scoreClass}">${previewInfo.userMessage}</small>
|
||
</div>
|
||
<div class="badge bg-secondary">${previewInfo.readabilityScore}/100</div>
|
||
</div>
|
||
`;
|
||
}
|
||
|
||
clearReadabilityPreview() {
|
||
const previewContainer = document.getElementById('readability-preview');
|
||
if (previewContainer) {
|
||
previewContainer.remove();
|
||
}
|
||
}
|
||
}
|
||
|
||
class SMSQRGenerator {
|
||
constructor() {
|
||
this.initializeSMSInterface();
|
||
}
|
||
|
||
initializeSMSInterface() {
|
||
// Atualizar preview em tempo real
|
||
const fieldsToWatch = ['sms-number', 'sms-message'];
|
||
fieldsToWatch.forEach(fieldId => {
|
||
const element = document.getElementById(fieldId);
|
||
if (element) {
|
||
element.addEventListener('input', () => this.updatePreview());
|
||
element.addEventListener('change', () => this.updatePreview());
|
||
}
|
||
});
|
||
|
||
// Inicializar preview
|
||
this.updatePreview();
|
||
}
|
||
|
||
updatePreview() {
|
||
const smsString = this.generateSMSString();
|
||
const previewElement = document.getElementById('sms-preview-text');
|
||
if (previewElement) {
|
||
previewElement.textContent = smsString;
|
||
}
|
||
}
|
||
|
||
generateSMSString() {
|
||
const data = this.collectSMSData();
|
||
|
||
if (!data.number || !data.message) {
|
||
return 'SMSTO::';
|
||
}
|
||
|
||
return `SMSTO:${data.number}:${data.message}`;
|
||
}
|
||
|
||
collectSMSData() {
|
||
return {
|
||
number: document.getElementById('sms-number')?.value || '',
|
||
message: document.getElementById('sms-message')?.value || ''
|
||
};
|
||
}
|
||
|
||
validateSMSData() {
|
||
const data = this.collectSMSData();
|
||
const errors = [];
|
||
|
||
if (!data.number.trim()) {
|
||
errors.push('Número do celular é obrigatório');
|
||
}
|
||
|
||
if (!data.message.trim()) {
|
||
errors.push('Mensagem é obrigatória');
|
||
}
|
||
|
||
// Validação de telefone brasileiro básica
|
||
const phoneRegex = /^\d{10,11}$/;
|
||
if (data.number && !phoneRegex.test(data.number.replace(/\D/g, ''))) {
|
||
errors.push('Número deve ter 10 ou 11 dígitos (DDD + número)');
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
}
|
||
|
||
class EmailQRGenerator {
|
||
constructor() {
|
||
this.initializeEmailInterface();
|
||
}
|
||
|
||
initializeEmailInterface() {
|
||
// Atualizar preview em tempo real
|
||
const fieldsToWatch = ['email-to', 'email-subject', 'email-body'];
|
||
fieldsToWatch.forEach(fieldId => {
|
||
const element = document.getElementById(fieldId);
|
||
if (element) {
|
||
element.addEventListener('input', () => this.updatePreview());
|
||
element.addEventListener('change', () => this.updatePreview());
|
||
}
|
||
});
|
||
|
||
// Inicializar preview
|
||
this.updatePreview();
|
||
}
|
||
|
||
updatePreview() {
|
||
const emailString = this.generateEmailString();
|
||
const previewElement = document.getElementById('email-preview-text');
|
||
if (previewElement) {
|
||
previewElement.textContent = emailString;
|
||
}
|
||
}
|
||
|
||
generateEmailString() {
|
||
const data = this.collectEmailData();
|
||
|
||
if (!data.to) {
|
||
return 'mailto:?subject=&body=';
|
||
}
|
||
|
||
let emailString = `mailto:${data.to}`;
|
||
const params = [];
|
||
|
||
if (data.subject) {
|
||
params.push(`subject=${encodeURIComponent(data.subject)}`);
|
||
}
|
||
|
||
if (data.body) {
|
||
params.push(`body=${encodeURIComponent(data.body)}`);
|
||
}
|
||
|
||
if (params.length > 0) {
|
||
emailString += '?' + params.join('&');
|
||
}
|
||
|
||
return emailString;
|
||
}
|
||
|
||
collectEmailData() {
|
||
return {
|
||
to: document.getElementById('email-to')?.value || '',
|
||
subject: document.getElementById('email-subject')?.value || '',
|
||
body: document.getElementById('email-body')?.value || ''
|
||
};
|
||
}
|
||
|
||
validateEmailData() {
|
||
const data = this.collectEmailData();
|
||
const errors = [];
|
||
|
||
if (!data.to.trim()) {
|
||
errors.push('Email destinatário é obrigatório');
|
||
}
|
||
|
||
if (!data.subject.trim()) {
|
||
errors.push('Assunto é obrigatório');
|
||
}
|
||
|
||
// Validação básica de email
|
||
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
|
||
if (data.to && !emailRegex.test(data.to)) {
|
||
errors.push('Email destinatário inválido');
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
}
|
||
|
||
class WiFiQRGenerator {
|
||
constructor() {
|
||
this.initializeWiFiInterface();
|
||
}
|
||
|
||
initializeWiFiInterface() {
|
||
// Radio buttons: usar name para group
|
||
document.querySelectorAll('input[name="wifi-security"]').forEach(radio => {
|
||
radio.addEventListener('change', () => {
|
||
this.togglePasswordField();
|
||
this.updatePreview();
|
||
});
|
||
});
|
||
|
||
// Campos individuais: usar IDs únicos
|
||
const fieldsToWatch = ['wifi-ssid', 'wifi-password', 'wifi-hidden'];
|
||
fieldsToWatch.forEach(fieldId => {
|
||
const element = document.getElementById(fieldId);
|
||
if (element) {
|
||
element.addEventListener('input', () => this.updatePreview());
|
||
element.addEventListener('change', () => this.updatePreview());
|
||
}
|
||
});
|
||
|
||
const togglePassword = document.getElementById('toggle-password');
|
||
if (togglePassword) {
|
||
togglePassword.addEventListener('click', () => {
|
||
this.togglePasswordVisibility();
|
||
});
|
||
}
|
||
|
||
// Inicializar estado
|
||
this.togglePasswordField();
|
||
this.updatePreview();
|
||
}
|
||
|
||
togglePasswordField() {
|
||
const selectedRadio = document.querySelector('input[name="wifi-security"]:checked');
|
||
const securityType = selectedRadio ? selectedRadio.value : 'WPA';
|
||
|
||
const passwordGroup = document.getElementById('wifi-password-group');
|
||
const passwordInput = document.getElementById('wifi-password');
|
||
|
||
if (securityType === 'nopass') {
|
||
passwordGroup.style.display = 'none';
|
||
passwordInput.removeAttribute('required');
|
||
passwordInput.value = '';
|
||
} else {
|
||
passwordGroup.style.display = 'block';
|
||
passwordInput.setAttribute('required', 'required');
|
||
}
|
||
}
|
||
|
||
togglePasswordVisibility() {
|
||
const passwordInput = document.getElementById('wifi-password');
|
||
const toggleIcon = document.getElementById('toggle-password');
|
||
|
||
if (passwordInput.type === 'password') {
|
||
passwordInput.type = 'text';
|
||
toggleIcon.className = 'fas fa-eye-slash';
|
||
} else {
|
||
passwordInput.type = 'password';
|
||
toggleIcon.className = 'fas fa-eye';
|
||
}
|
||
}
|
||
|
||
updatePreview() {
|
||
const wifiString = this.generateWiFiString();
|
||
const previewText = document.getElementById('wifi-preview-text');
|
||
if(previewText) {
|
||
previewText.textContent = wifiString;
|
||
}
|
||
}
|
||
|
||
generateWiFiString() {
|
||
const data = this.collectWiFiData();
|
||
|
||
// Validar dados mínimos
|
||
if (!data.ssid) {
|
||
return 'WIFI:T:WPA;S:;P:;H:false;;';
|
||
}
|
||
|
||
// Escapar caracteres especiais
|
||
const ssid = this.escapeWiFiString(data.ssid);
|
||
const password = this.escapeWiFiString(data.password);
|
||
|
||
// Construir string WiFi
|
||
return `WIFI:T:${data.security};S:${ssid};P:${password};H:${data.hidden};;`;
|
||
}
|
||
|
||
collectWiFiData() {
|
||
return {
|
||
ssid: document.getElementById('wifi-ssid').value,
|
||
security: document.querySelector('input[name="wifi-security"]:checked')?.value || 'WPA',
|
||
password: document.getElementById('wifi-password').value,
|
||
hidden: document.getElementById('wifi-hidden').checked.toString()
|
||
};
|
||
}
|
||
|
||
escapeWiFiString(str) {
|
||
if (!str) return '';
|
||
// Escapar caracteres especiais do formato WiFi
|
||
return str.replace(/[\\;,:"]/g, '\\escapeWiFiString(str) { if (!str) return; }');
|
||
|
||
// Escapar caracteres especiais do formato WiFi
|
||
//return str.replace(/[\\;,:""]/g, '\\document.addEventListener('DOMContentLoaded', () => {
|
||
// window.qrGenerator = new QRRapidoGenerator();
|
||
// window.vcardGenerator = new VCardGenerator();
|
||
|
||
// // Initialize AdSense if necessary
|
||
// if (window.adsbygoogle && document.querySelector('.adsbygoogle')) {
|
||
// (adsbygoogle = window.adsbygoogle || []).push({});
|
||
// }
|
||
//});
|
||
return str.replace(/[\\;,:"']/g, '\\$&');
|
||
|
||
// VCard Generator Class');
|
||
}
|
||
|
||
validateWiFiData() {
|
||
const data = this.collectWiFiData();
|
||
const errors = [];
|
||
|
||
// Validações obrigatórias
|
||
if (!data.ssid.trim()) {
|
||
errors.push('Nome da rede (SSID) é obrigatório');
|
||
}
|
||
|
||
// Validação de senha conforme tipo de segurança
|
||
if ((data.security === 'WPA' || data.security === 'WEP') && !data.password.trim()) {
|
||
errors.push('Senha é obrigatória para redes protegidas');
|
||
}
|
||
|
||
// Validação de comprimento
|
||
if (data.ssid.length > 32) {
|
||
errors.push('Nome da rede deve ter no máximo 32 caracteres');
|
||
}
|
||
|
||
if (data.password.length > 63) {
|
||
errors.push('Senha deve ter no máximo 63 caracteres');
|
||
}
|
||
|
||
// Validação WEP específica
|
||
if (data.security === 'WEP' && data.password) {
|
||
const validWEPLengths = [5, 10, 13, 26]; // WEP 64/128 bit
|
||
if (!validWEPLengths.includes(data.password.length)) {
|
||
errors.push('Senha WEP deve ter 5, 10, 13 ou 26 caracteres');
|
||
}
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
}
|
||
|
||
// VCard Generator Class
|
||
|
||
class VCardGenerator {
|
||
constructor() {
|
||
this.initializeVCardInterface();
|
||
}
|
||
|
||
// Função para codificar caracteres especiais usando Quoted-Printable
|
||
encodeQuotedPrintable(text) {
|
||
if (!text) return '';
|
||
|
||
return text.replace(/[^\u0020-\u007E]/g, (char) => {
|
||
// Para caracteres especiais comuns do português, usar codificação UTF-8
|
||
const utf8Bytes = new TextEncoder().encode(char);
|
||
return Array.from(utf8Bytes)
|
||
.map(byte => `=${byte.toString(16).toUpperCase().padStart(2, '0')}`)
|
||
.join('');
|
||
});
|
||
}
|
||
|
||
// Função para preparar texto com codificação adequada
|
||
prepareTextForVCard(text, needsEncoding = true) {
|
||
if (!text) return '';
|
||
|
||
const trimmedText = text.trim();
|
||
if (!needsEncoding) return trimmedText;
|
||
|
||
// Verifica se há caracteres especiais que precisam de codificação
|
||
const hasSpecialChars = /[^\u0020-\u007E]/.test(trimmedText);
|
||
|
||
if (hasSpecialChars) {
|
||
return `CHARSET=UTF-8;ENCODING=QUOTED-PRINTABLE:${this.encodeQuotedPrintable(trimmedText)}`;
|
||
}
|
||
|
||
return trimmedText;
|
||
}
|
||
|
||
initializeVCardInterface() {
|
||
// Show/hide optional fields based on checkboxes
|
||
document.querySelectorAll('#vcard-interface .form-check-input').forEach(checkbox => {
|
||
checkbox.addEventListener('change', (e) => {
|
||
const groupId = e.target.id.replace('enable-', '') + '-group';
|
||
const group = document.getElementById(groupId);
|
||
if (group) {
|
||
group.style.display = e.target.checked ? 'block' : 'none';
|
||
// Clear values when hiding fields
|
||
if (!e.target.checked) {
|
||
const inputs = group.querySelectorAll('input');
|
||
inputs.forEach(input => input.value = '');
|
||
}
|
||
}
|
||
this.updatePreview();
|
||
});
|
||
});
|
||
|
||
// Update preview in real-time
|
||
document.querySelectorAll('#vcard-interface input').forEach(input => {
|
||
input.addEventListener('input', () => this.updatePreview());
|
||
input.addEventListener('blur', () => this.validateField(input));
|
||
});
|
||
}
|
||
|
||
updatePreview() {
|
||
const vcard = this.generateVCardContent();
|
||
const previewElement = document.getElementById('vcard-preview-text');
|
||
if (previewElement) {
|
||
previewElement.textContent = vcard;
|
||
}
|
||
}
|
||
|
||
generateVCardContent() {
|
||
const data = this.collectVCardData();
|
||
|
||
let vcard = 'BEGIN:VCARD\nVERSION:3.0\nCHARSET=UTF-8\n';
|
||
|
||
// Nome (obrigatório)
|
||
if (data.name) {
|
||
const nameParts = data.name.trim().split(' ');
|
||
const firstName = nameParts[0] || '';
|
||
const lastName = nameParts.slice(1).join(' ') || '';
|
||
|
||
// Codificar nome se necessário
|
||
const encodedLastName = this.prepareTextForVCard(lastName);
|
||
const encodedFirstName = this.prepareTextForVCard(firstName);
|
||
const encodedFullName = this.prepareTextForVCard(data.name.trim());
|
||
|
||
vcard += `N:${encodedLastName};${encodedFirstName}\n`;
|
||
vcard += `FN:${encodedFullName}\n`;
|
||
}
|
||
|
||
// Empresa
|
||
if (data.company) {
|
||
const encodedCompany = this.prepareTextForVCard(data.company);
|
||
vcard += `ORG:${encodedCompany}\n`;
|
||
}
|
||
|
||
// Título
|
||
if (data.title) {
|
||
const encodedTitle = this.prepareTextForVCard(data.title);
|
||
vcard += `TITLE:${encodedTitle}\n`;
|
||
}
|
||
|
||
// Endereço
|
||
if (data.address || data.city || data.state || data.zip) {
|
||
const encodedAddress = this.prepareTextForVCard(data.address || '');
|
||
const encodedCity = this.prepareTextForVCard(data.city || '');
|
||
const encodedState = this.prepareTextForVCard(data.state || '');
|
||
const encodedZip = this.prepareTextForVCard(data.zip || '', false); // ZIP não precisa de codificação especial
|
||
const encodedCountry = this.prepareTextForVCard('Brasil');
|
||
|
||
const addr = `;;${encodedAddress};${encodedCity};${encodedState};${encodedZip};${encodedCountry}`;
|
||
vcard += `ADR:${addr}\n`;
|
||
}
|
||
|
||
// Telefones
|
||
if (data.phone) vcard += `TEL;WORK;VOICE:${data.phone}\n`;
|
||
if (data.mobile) vcard += `TEL;CELL:${data.mobile}\n`;
|
||
|
||
// Email
|
||
if (data.email) vcard += `EMAIL;WORK;INTERNET:${data.email}\n`;
|
||
|
||
// Website
|
||
if (data.website) vcard += `URL:${data.website}\n`;
|
||
|
||
vcard += 'END:VCARD';
|
||
|
||
return vcard;
|
||
}
|
||
|
||
collectVCardData() {
|
||
return {
|
||
name: document.getElementById('vcard-name')?.value?.trim() || '',
|
||
mobile: document.getElementById('vcard-mobile')?.value?.trim() || '',
|
||
email: document.getElementById('vcard-email')?.value?.trim() || '',
|
||
company: document.getElementById('enable-company')?.checked ?
|
||
(document.getElementById('vcard-company')?.value?.trim() || '') : '',
|
||
title: document.getElementById('enable-title')?.checked ?
|
||
(document.getElementById('vcard-title')?.value?.trim() || '') : '',
|
||
website: document.getElementById('enable-website')?.checked ?
|
||
(document.getElementById('vcard-website')?.value?.trim() || '') : '',
|
||
address: document.getElementById('enable-address')?.checked ?
|
||
(document.getElementById('vcard-address')?.value?.trim() || '') : '',
|
||
city: document.getElementById('enable-address')?.checked ?
|
||
(document.getElementById('vcard-city')?.value?.trim() || '') : '',
|
||
state: document.getElementById('enable-address')?.checked ?
|
||
(document.getElementById('vcard-state')?.value?.trim() || '') : '',
|
||
zip: document.getElementById('enable-address')?.checked ?
|
||
(document.getElementById('vcard-zip')?.value?.trim() || '') : '',
|
||
phone: document.getElementById('enable-phone')?.checked ?
|
||
(document.getElementById('vcard-phone')?.value?.trim() || '') : ''
|
||
};
|
||
}
|
||
|
||
validateVCardData() {
|
||
const data = this.collectVCardData();
|
||
const errors = [];
|
||
|
||
// Required field validations
|
||
if (!data.name) errors.push('Nome é obrigatório');
|
||
if (!data.mobile) errors.push('Telefone celular é obrigatório');
|
||
if (!data.email) errors.push('Email é obrigatório');
|
||
|
||
// Format validations
|
||
if (data.email && !this.isValidEmail(data.email)) {
|
||
errors.push('Email inválido');
|
||
}
|
||
|
||
if (data.website && !this.isValidURL(data.website)) {
|
||
errors.push('Website inválido (deve começar com http:// ou https://)');
|
||
}
|
||
|
||
if (data.mobile && !this.isValidPhone(data.mobile)) {
|
||
errors.push('Telefone celular inválido (deve ter 10-11 dígitos)');
|
||
}
|
||
|
||
if (data.phone && !this.isValidPhone(data.phone)) {
|
||
errors.push('Telefone fixo inválido (deve ter 10-11 dígitos)');
|
||
}
|
||
|
||
return errors;
|
||
}
|
||
|
||
validateField(input) {
|
||
const value = input.value.trim();
|
||
let isValid = true;
|
||
let message = '';
|
||
|
||
switch (input.id) {
|
||
case 'vcard-email':
|
||
if (value && !this.isValidEmail(value)) {
|
||
isValid = false;
|
||
message = 'Email inválido';
|
||
}
|
||
break;
|
||
case 'vcard-website':
|
||
if (value && !this.isValidURL(value)) {
|
||
isValid = false;
|
||
message = 'Website inválido (deve começar com http:// ou https://)';
|
||
}
|
||
break;
|
||
case 'vcard-mobile':
|
||
case 'vcard-phone':
|
||
if (value && !this.isValidPhone(value)) {
|
||
isValid = false;
|
||
message = 'Telefone inválido (apenas números, 10-11 dígitos)';
|
||
}
|
||
break;
|
||
}
|
||
|
||
// Update field validation state
|
||
if (isValid) {
|
||
input.classList.remove('is-invalid');
|
||
input.classList.add('is-valid');
|
||
} else {
|
||
input.classList.remove('is-valid');
|
||
input.classList.add('is-invalid');
|
||
// Show error message
|
||
const feedback = input.parentNode.querySelector('.invalid-feedback');
|
||
if (feedback) {
|
||
feedback.textContent = message;
|
||
}
|
||
}
|
||
|
||
return isValid;
|
||
}
|
||
|
||
isValidEmail(email) {
|
||
return /^[^ @]+@[^ @]+\.[^ @]+$/.test(email);
|
||
}
|
||
|
||
isValidURL(url) {
|
||
try {
|
||
new URL(url);
|
||
return url.startsWith('http://') || url.startsWith('https://');
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
isValidPhone(phone) {
|
||
// Brazilian phone validation (DDD + number)
|
||
const digitsOnly = phone.replace(/\D/g, '');
|
||
return /^\d{10,11}$/.test(digitsOnly);
|
||
}
|
||
|
||
// Method to be called by main QR generator
|
||
getVCardContent() {
|
||
const errors = this.validateVCardData();
|
||
if (errors.length > 0) {
|
||
throw new Error('Erro na validação: ' + errors.join(', '));
|
||
}
|
||
return this.generateVCardContent();
|
||
}
|
||
}
|
||
|
||
// Global functions for ad control
|
||
window.QRApp = {
|
||
refreshAds: function() {
|
||
if (window.adsbygoogle) {
|
||
document.querySelectorAll('.adsbygoogle').forEach(ad => {
|
||
(adsbygoogle = window.adsbygoogle || []).push({});
|
||
});
|
||
}
|
||
},
|
||
|
||
hideAds: function() {
|
||
document.querySelectorAll('.ad-container').forEach(ad => {
|
||
ad.style.display = 'none';
|
||
});
|
||
}
|
||
};
|
||
|
||
// Google Analytics 4 Event Tracking
|
||
window.trackLanguageChange = function(from, to) {
|
||
if (typeof gtag !== 'undefined') {
|
||
gtag('event', 'language_change', {
|
||
'from_language': from,
|
||
'to_language': to
|
||
});
|
||
}
|
||
};
|
||
|
||
window.trackUpgradeClick = function(location) {
|
||
if (typeof gtag !== 'undefined') {
|
||
gtag('event', 'upgrade_click', {
|
||
'click_location': location
|
||
});
|
||
}
|
||
}; |