https://www.akralab.es/wp-content/plugins/kitify/assets/js/addons/subscribe-form.js?ver=1.0.4.5

1(function ($) {
2
3    "use strict";
4
5
6    /**
7     * Ajax Handlers
8     */
9    var KitifyHandlerUtils = {
10        /**
11         * Rendering notice message
12         *
13         * @param  {String} type    Message type
14         * @param  {String} message Message content
15         * @return {Void}
16         */
17        noticeCreate: function (type, message, isPublicPage) {
18            var notice,
19                rightDelta = 0,
20                timeoutId,
21                isPublic = isPublicPage || false;
22
23            if (!message || 'true' === isPublic) {
24                return false;
25            }
26
27            notice = $('<div class="kitify-handler-notice ' + type + '"><span class="dashicons"></span><div class="inner">' + message + '</div></div>');
28
29            $('body').prepend(notice);
30            reposition();
31            rightDelta = -1 * (notice.outerWidth(true) + 10);
32            notice.css({'right': rightDelta});
33
34            timeoutId = setTimeout(function () {
35                notice.css({'right': 10}).addClass('show-state');
36            }, 100);
37            timeoutId = setTimeout(function () {
38                rightDelta = -1 * (notice.outerWidth(true) + 10);
39                notice.css({right: rightDelta}).removeClass('show-state');
40            }, 4000);
41            timeoutId = setTimeout(function () {
42                notice.remove();
43                clearTimeout(timeoutId);
44            }, 4500);
45
46            function reposition() {
47                var topDelta = 100;
48
49                $('.kitify-handler-notice').each(function () {
50                    $(this).css({top: topDelta});
51                    topDelta += $(this).outerHeight(true);
52                });
53            }
54        },
55
56        /**
57         * Serialize form into
58         *
59         * @return {Object}
60         */
61        serializeObject: function (form) {
62
63            var self = this,
64                json = {},
65                pushCounters = {},
66                patterns = {
67                    'validate': /^[a-zA-Z][a-zA-Z0-9_-]*(?:\[(?:\d*|[a-zA-Z0-9_-]+)\])*$/,
68                    'key': /[a-zA-Z0-9_-]+|(?=\[\])/g,
69                    'push': /^$/,
70                    'fixed': /^\d+$/,
71                    'named': /^[a-zA-Z0-9_-]+$/
72                };
73
74            this.build = function (base, key, value) {
75                base[key] = value;
76
77                return base;
78            };
79
80            this.push_counter = function (key) {
81                if (undefined === pushCounters[key]) {
82                    pushCounters[key] = 0;
83                }
84
85                return pushCounters[key]++;
86            };
87
88            $.each(form.serializeArray(), function () {
89                var k, keys, merge, reverseKey;
90
91                // Skip invalid keys
92                if (!patterns.validate.test(this.name)) {
93                    return;
94                }
95
96                keys = this.name.match(patterns.key);
97                merge = this.value;
98                reverseKey = this.name;
99
100                while (undefined !== (k = keys.pop())) {
101
102                    // Adjust reverseKey
103                    reverseKey = reverseKey.replace(new RegExp('\\[' + k + '\\]$'), '');
104
105                    // Push
106                    if (k.match(patterns.push)) {
107                        merge = self.build([], self.push_counter(reverseKey), merge);
108                    } else if (k.match(patterns.fixed)) {
109                        merge = self.build([], k, merge);
110                    } else if (k.match(patterns.named)) {
111                        merge = self.build({}, k, merge);
112                    }
113                }
114
115                json = $.extend(true, json, merge);
116            });
117
118            return json;
119        }
120    };
121
122    var KitifyAjaxHandler = function (options) {
123        /**
124         * General default settings
125         *
126         * @type {Object}
127         */
128        var self = this,
129            settings = {
130                'handlerId': '',
131                'cache': false,
132                'processData': true,
133                'url': '',
134                'async': false,
135                'beforeSendCallback': function () { },
136                'errorCallback': function () { },
137                'successCallback': function () { },
138                'completeCallback': function () { }
139            };
140
141        /**
142         * Checking options, settings and options merging
143         *
144         */
145        if (options) {
146            $.extend(settings, options);
147        }
148
149        /**
150         * Set handler settings from localized global variable
151         *
152         * @type {Object}
153         */
154        self.handlerSettings = window.kitifySubscribeConfig || {};
155
156        /**
157         * Ajax request instance
158         *
159         * @type {Object}
160         */
161        self.ajaxRequest = null;
162
163        /**
164         * Ajax processing state
165         *
166         * @type {Boolean}
167         */
168        self.ajaxProcessing = false;

169
170        /**
171         * Set ajax request data
172         *
173         * @type {Object}
174         */
175        self.data = {
176            'action': self.handlerSettings.action,
177            'nonce': self.handlerSettings.nonce
178        };
179
180        /**
181         * Check ajax url is empty
182         */
183        if ('' === settings.url) {
184            // Check public request
185            settings.url = self.handlerSettings.ajax_url;
186        }
187
188        /**
189         * Init ajax request
190         *
191         * @return {Void}
192         */
193        self.send = function () {
194            if (self.ajaxProcessing) {
195                KitifyHandlerUtils.noticeCreate('error-notice', self.handlerSettings.sys_messages.wait_processing, self.handlerSettings.is_public);
196            }
197            self.ajaxProcessing = true;
198            self.ajaxRequest = $.ajax({
199                type: self.handlerSettings.type,
200                url: settings.url,
201                data: self.data,
202                cache: settings.cache,
203                dataType: self.handlerSettings.data_type,
204                processData: settings.processData,
205                beforeSend: function (jqXHR, ajaxSettings) {
206                    if (null !== self.ajaxRequest && !settings.async) {
207                        self.ajaxRequest.abort();
208                    }
209
210                    if (settings.beforeSendCallback && 'function' === typeof (settings.beforeSendCallback)) {
211                        settings.beforeSendCallback(jqXHR, ajaxSettings);
212                    }
213                },
214                error: function (jqXHR, textStatus, errorThrown) {
215                    $(document).trigger({
216                        type: 'kitify-ajax-handler-error',
217                        jqXHR: jqXHR,
218                        textStatus: textStatus,
219                        errorThrown: errorThrown
220                    });
221
222                    if (settings.errorCallback && 'function' === typeof (settings.errorCallback)) {
223                        settings.errorCallback(jqXHR, textStatus, errorThrown);
224                    }
225                },
226                success: function (data, textStatus, jqXHR) {
227                    self.ajaxProcessing = false;
228
229                    $(document).trigger({
230                        type: 'kitify-ajax-handler-success',
231                        response: data,
232                        jqXHR: jqXHR,
233                        textStatus: textStatus
234                    });
235
236                    if (settings.successCallback && 'function' === typeof (settings.successCallback)) {
237                        settings.successCallback(data, textStatus, jqXHR);
238                    }
239
240                    //KitifyHandlerUtils.noticeCreate(data.type, data.message, self.handlerSettings.is_public);
241                },
242                complete: function (jqXHR, textStatus) {
243                    $(document).trigger({
244                        type: 'kitify-ajax-handler-complete',
245                        jqXHR: jqXHR,
246                        textStatus: textStatus
247                    });
248
249                    if (settings.completeCallback && 'function' === typeof (settings.completeCallback)) {
250                        settings.completeCallback(jqXHR, textStatus);
251                    }
252                }
253
254            });
255        };
256
257        /**
258         * Send data ajax request
259         *
260         * @param  {Object} data User data
261         * @return {Void}
262         */
263        self.sendData = function (data) {
264            var sendData = data || {};
265            self.data = {
266                'action': 'kitify_ajax',
267                '_nonce': self.handlerSettings.nonce,
268                'actions': JSON.stringify({
269                    'newsletter_subscribe' : {
270                        'action': 'newsletter_subscribe',
271                        'data': sendData
272                    }
273                }),
274            };
275            self.send();
276        };
277
278        /**
279         * Send form serialized data
280         * @param  {String} formId Form selector
281         * @return {Void}
282         */
283        self.sendFormData = function (formId) {
284            var form = $(formId),
285                data;
286
287            data = KitifyHandlerUtils.serializeObject(form);
288
289            self.sendData(data);
290        };
291    };
292
293    var KitifySubscribeForm = function( $scope ) {
294        var $target = $scope.find('.kitify-subscribe-form'),
295            scoreId = $scope.data('id'),
296            settings = $target.data('settings'),
297            subscribeFormAjaxId = 'kitify_elementor_subscribe_form_ajax',
298            $subscribeForm = $('.kitify-subscribe-form__form', $target),
299            $fields = $('.kitify-subscribe-form__fields', $target),
300            $mailField = $('.kitify-subscribe-form__mail-field', $target),
301            $inputData = $mailField.data('instance-data'),
302            $submitButton = $('.kitify-subscribe-form__submit', $target),
303            $subscribeFormMessage = $('.kitify-subscribe-form__message', $target),
304            timeout = null,
305            invalidMailMessage = window.kitifySubscribeConfig.sys_messages.invalid_mail;
306
307        var kitifySubscribeFormAjax = new KitifyAjaxHandler({
308            handlerId: subscribeFormAjaxId,
309
310            errorCallback: function (jqXHR, textStatus, errorThrown){
311                var message = window.kitifySubscribeConfig.sys_messages.invalid_nonce,
312                    responceClass = 'kitify-subscribe-form--response-error';
313
314                $submitButton.removeClass('loading');
315
316                $target.addClass(responceClass);
317
318                $('span', $subscribeFormMessage).html(message);
319                $subscribeFormMessage.css({'visibility': 'visible'});
320
321                timeout = setTimeout(function () {
322                    $subscribeFormMessage.css({'visibility': 'hidden'});
323                    $target.removeClass(responceClass);
324                }, 20000);
325            },
326            successCallback: function ( response ) {
327                var successType, message, responceClass;
328                if(response.success){
329                    if(response.data.responses.newsletter_subscribe.success){
330                        message = response.data.responses.newsletter_subscribe.data.message;
331                        successType = response.data.responses.newsletter_subscribe.data.type;
332                    }
333                    else{
334                        message = response.data.responses.newsletter_subscribe.data;
335                        successType = 'error';
336                    }
337                }
338                else {
339                    successType = 'error';
340                    message = response.responses.error.data;
341                }
342
343                responceClass = 'kitify-subscribe-form--response-' + successType;
344
345                $submitButton.removeClass('loading');
346
347                $target.removeClass('kitify-subscribe-form--response-error');
348                $target.addClass(responceClass);
349
350                $('span', $subscribeFormMessage).html(message);
351                $subscribeFormMessage.css({'visibility': 'visible'});
352
353                timeout = setTimeout(function () {
354                    $subscribeFormMessage.css({'visibility': 'hidden'});
355                    $target.removeClass(responceClass);
356                }, 20000);
357
358                if (settings['redirect']) {
359                    window.location.href = settings['redirect_url'];
360                }
361
362                $(window).trigger({
363                    type: 'kitify/subscribe',
364                    elementId: scoreId,
365                    successType: successType,
366                    inputData: $inputData
367                });
368            }
369        });
370
371        $mailField.on('focus', function () {
372            $mailField.removeClass('mail-invalid');
373        });
374
375        $(document).keydown(function (event) {
376
377            if (13 === event.keyCode && $mailField.is(':focus')) {
378                subscribeHandle();
379
380                return false;

381            }
382        });
383
384        $submitButton.on('click', function () {
385            subscribeHandle();
386            return false;
387        });
388
389        function validateEmail (email) {
390            var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
391
392            return re.test(email);
393        }
394
395        function subscribeHandle() {
396            var inputValue = $mailField.val(),
397                sendData = {
398                    'email': inputValue,
399                    'use_target_list_id': settings['use_target_list_id'] || false,
400                    'target_list_id': settings['target_list_id'] || '',
401                    'data': $inputData
402                },
403                serializeArray = $subscribeForm.serializeArray(),
404                additionalFields = {};
405
406            if (validateEmail(inputValue)) {
407
408                $.each(serializeArray, function (key, fieldData) {
409
410                    if ('email' === fieldData.name) {
411                        sendData[fieldData.name] = fieldData.value;
412                    } else {
413                        additionalFields[fieldData.name] = fieldData.value;
414                    }
415                });
416
417                sendData['additional'] = additionalFields;
418
419                kitifySubscribeFormAjax.sendData(sendData);
420
421                $submitButton.addClass('loading');
422            }
423            else {
424                $mailField.addClass('mail-invalid');
425
426                $target.addClass('kitify-subscribe-form--response-error');
427                $('span', $subscribeFormMessage).html(invalidMailMessage);
428                $subscribeFormMessage.css({'visibility': 'visible'});
429
430                timeout = setTimeout(function () {
431                    $target.removeClass('kitify-subscribe-form--response-error');
432                    $subscribeFormMessage.css({'visibility': 'hidden'});
433                    $mailField.removeClass('mail-invalid');
434                }, 20000);
435            }
436        }
437    }
438
439    $(window).on('elementor/frontend/init', function () {
440        elementorFrontend.hooks.addAction('frontend/element_ready/kitify-subscribe-form.default', function ($scope) {
441            KitifySubscribeForm($scope);
442        });
443    });
444
445}(jQuery));