s="lines-num lines-num-old"> 2291 
            item[3] && recognizer.requireFailure(item[3]);
2292 
        }, this);
2293 
    }
2302 2294
2303 
        // Options that need a little more setup
2304 
        if (options.touchAction) {
2305 
            this.touchAction.update();
2306 
        }
2307 
        if (options.inputTarget) {
2308 
            // Clean up existing event listeners and reinitialize
2309 
            this.input.destroy();
2310 
            this.input.target = options.inputTarget;
2311 
            this.input.init();
2312 
        }
2313 
        return this;
2314 
    },
2295 
    Manager.prototype = {
2296 
        /**
2297 
         * set options
2298 
         * @param {Object} options
2299 
         * @returns {Manager}
2300 
         */
2301 
        set: function(options) {
2302 
            assign(this.options, options);
2315 2303
2316 
    /**
2317 
     * stop recognizing for this session.
2318 
     * This session will be discarded, when a new [input]start event is fired.
2319 
     * When forced, the recognizer cycle is stopped immediately.
2320 
     * @param {Boolean} [force]
2321 
     */
2322 
    stop: function(force) {
2323 
        this.session.stopped = force ? FORCED_STOP : STOP;
2324 
    },
2304 
            // Options that need a little more setup
2305 
            if (options.touchAction) {
2306 
                this.touchAction.update();
2307 
            }
2308 
            if (options.inputTarget) {
2309 
                // Clean up existing event listeners and reinitialize
2310 
                this.input.destroy();
2311 
                this.input.target = options.inputTarget;
2312 
                this.input.init();
2313 
            }
2314 
            return this;
2315 
        },
2325 2316
2326 
    /**
2327 
     * run the recognizers!
2328 
     * called by the inputHandler function on every movement of the pointers (touches)
2329 
     * it walks through all the recognizers and tries to detect the gesture that is being made
2330 
     * @param {Object} inputData
2331 
     */
2332 
    recognize: function(inputData) {
2333 
        var session = this.session;
2334 
        if (session.stopped) {
2335 
            return;
2336 
        }
2317 
        /**
2318 
         * stop recognizing for this session.
2319 
         * This session will be discarded, when a new [input]start event is fired.
2320 
         * When forced, the recognizer cycle is stopped immediately.
2321 
         * @param {Boolean} [force]
2322 
         */
2323 
        stop: function(force) {
2324 
            this.session.stopped = force ? FORCED_STOP : STOP;
2325 
        },
2337 2326
2338 
        // run the touch-action polyfill
2339 
        this.touchAction.preventDefaults(inputData);
2327 
        /**
2328 
         * run the recognizers!
2329 
         * called by the inputHandler function on every movement of the pointers (touches)
2330 
         * it walks through all the recognizers and tries to detect the gesture that is being made
2331 
         * @param {Object} inputData
2332 
         */
2333 
        recognize: function(inputData) {
2334 
            var session = this.session;
2335 
            if (session.stopped) {
2336 
                return;
2337 
            }
2340 2338
2341 
        var recognizer;
2342 
        var recognizers = this.recognizers;
2339 
            // run the touch-action polyfill
2340 
            this.touchAction.preventDefaults(inputData);
2343 2341
2344 
        // this holds the recognizer that is being recognized.
2345 
        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
2346 
        // if no recognizer is detecting a thing, it is set to `null`
2347 
        var curRecognizer = session.curRecognizer;
2342 
            var recognizer;
2343 
            var recognizers = this.recognizers;
2348 2344
2349 
        // reset when the last recognizer is recognized
2350 
        // or when we're in a new session
2351 
        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
2352 
            curRecognizer = session.curRecognizer = null;
2353 
        }
2345 
            // this holds the recognizer that is being recognized.
2346 
            // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED
2347 
            // if no recognizer is detecting a thing, it is set to `null`
2348 
            var curRecognizer = session.curRecognizer;
2354 2349
2355 
        var i = 0;
2356 
        while (i < recognizers.length) {
2357 
            recognizer = recognizers[i];
2358
2359 
            // find out if we are allowed try to recognize the input for this one.
2360 
            // 1.   allow if the session is NOT forced stopped (see the .stop() method)
2361 
            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
2362 
            //      that is being recognized.
2363 
            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
2364 
            //      this can be setup with the `recognizeWith()` method on the recognizer.
2365 
            if (session.stopped !== FORCED_STOP && ( // 1
2366 
                    !curRecognizer || recognizer == curRecognizer || // 2
2367 
                    recognizer.canRecognizeWith(curRecognizer))) { // 3
2368 
                recognizer.recognize(inputData);
2369 
            } else {
2370 
                recognizer.reset();
2350 
            // reset when the last recognizer is recognized
2351 
            // or when we're in a new session
2352 
            if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {
2353 
                curRecognizer = session.curRecognizer = null;
2371 2354 
            }
2372 2355
2373 
            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
2374 
            // current active recognizer. but only if we don't already have an active recognizer
2375 
            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
2376 
                curRecognizer = session.curRecognizer = recognizer;
2356 
            var i = 0;
2357 
            while (i < recognizers.length) {
2358 
                recognizer = recognizers[i];
2359
2360 
                // find out if we are allowed try to recognize the input for this one.
2361 
                // 1.   allow if the session is NOT forced stopped (see the .stop() method)
2362 
                // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one
2363 
                //      that is being recognized.
2364 
                // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.
2365 
                //      this can be setup with the `recognizeWith()` method on the s can be setup with the `recognizeWith()` method on the recognizer.
2366 
                if (session.stopped !== FORCED_STOP && ( // 1
2367 
                  !curRecognizer || recognizer == curRecognizer || // 2
2368 
                  recognizer.canRecognizeWith(curRecognizer))) { // 3
2369 
                    recognizer.recognize(inputData);
2370 
                } else {
2371 
                    recognizer.reset();
2372 
                }
2373
2374 
                // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the
2375 
                // current active recognizer. but only if we don't already have an active recognizer
2376 
                if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {
2377 
                    curRecognizer = session.curRecognizer = recognizer;
2378 
                }
2379 
                i++;
2377 2380 
            }
2378 
            i++;
2379 
        }
2380 
    },
2381 
        },
2381 2382
2382 
    /**
2383 
     * get a recognizer by its event name.
2384 
     * @param {Recognizer|String} recognizer
2385 
     * @returns {Recognizer|Null}
2386 
     */
2387 
    get: function(recognizer) {
2388 
        if (recognizer instanceof Recognizer) {
2383 
        /**
2384 
         * get a recognizer by its event name.
2385 
         * @param {Recognizer|String} recognizer
2386 
         * @returns {Recognizer|Null}
2387 
         */
2388 
        get: function(recognizer) {
2389 
            if (recognizer instanceof Recognizer) {
2390 
                return recognizer;
2391 
            }
2392
2393 
            var recognizers = this.recognizers;
2394 
            for (var i = 0; i < recognizers.length; i++) {
2395 
                if (recognizers[i].options.event == recognizer) {
2396 
                    return recognizers[i];
2397 
                }
2398 
            }
2399 
            return null;
2400 
        },
2401
2402 
        /**
2403 
         * add a recognizer to the manager
2404 
         * existing recognizers with the same event name will be removed
2405 
         * @param {Recognizer} recognizer
2406 
         * @returns {Recognizer|Manager}
2407 
         */
2408 
        add: function(recognizer) {
2409 
            if (invokeArrayArg(recognizer, 'add', this)) {
2410 
                return this;
2411 
            }
2412
2413 
            // remove existing
2414 
            var existing = this.get(recognizer.options.event);
2415 
            if (existing) {
2416 
                this.remove(existing);
2417 
            }
2418
2419 
            this.recognizers.push(recognizer);
2420 
            recognizer.manager = this;
2421
2422 
            this.touchAction.update();
2389 2423 
            return recognizer;
2390 
        }
2424 
        },
2391 2425
2392 
        var recognizers = this.recognizers;
2393 
        for (var i = 0; i < recognizers.length; i++) {
2394 
            if (recognizers[i].options.event == recognizer) {
2395 
                return recognizers[i];
2426 
        /**
2427 
         * remove a recognizer by name or instance
2428 
         * @param {Recognizer|String} recognizer
2429 
         * @returns {Manager}
2430 
         */
2431 
        remove: function(recognizer) {
2432 
            if (invokeArrayArg(recognizer, 'remove', this)) {
2433 
                return this;
2434 
            }
2435
2436 
            recognizer = this.get(recognizer);
2437
2438 
            // let's make sure this recognizer exists
2439 
            if (recognizer) {
2440 
                var recognizers = this.recognizers;
2441 
                var index = inArray(recognizers, recognizer);
2442
2443 
                if (index !== -1) {
2444 
                    recognizers.splice(index, 1);
2445 
                    this.touchAction.update();
2446 
                }
2396 2447 
            }
2397 
        }
2398 
        return null;
2399 
    },
2400 2448
2401 
    /**
2402 
     * add a recognizer to the manager
2403 
     * existing recognizers with the same event name will be removed
2404 
     * @param {Recognizer} recognizer
2405 
     * @returns {Recognizer|Manager}
2406 
     */
2407 
    add: function(recognizer) {
2408 
        if (invokeArrayArg(recognizer, 'add', this)) {
2409 2449 
            return this;
2410 
        }
2450 
        },
2411 2451
2412 
        // remove existing
2413 
        var existing = this.get(recognizer.options.event);
2414 
        if (existing) {
2415 
            this.remove(existing);
2416 
        }
2452 
        /**
2453 
         * bind event
2454 
         * @param {String} events
2455 
         * @param {Function} handler
2456 
         * @returns {EventEmitter} this
2457 
         */
2458 
        on: function(events, handler) {
2459 
            if (events === undefinedVar) {
2460 
                return;
2461 
            }
2462 
            if (handler === undefinedVar) {
2463 
                return;
2464 
            }
2417 2465
2418 
        this.recognizers.push(recognizer);
2419 
        recognizer.manager = this;
2466 
            var handlers = this.handlers;
2467 
            each(splitStr(events), function(event) {
2468 
                handlers[event] = handlers[event] || [];
2469 
                handlers[event].push(handler);
2470 
            });
2471 
            return this;
2472 
        },
2420 2473
2421 
        this.touchAction.update();
2422 
        return recognizer;
2423 
    },
2474 
        /**
2475 
         * unbind event, leave emit blank to remove all handlers
2476 
         * @param {String} events
2477 
         * @param {Function} [handler]
2478 
         * @returns {EventEmitter} this
2479 
         */
2480 
        off: function(events, handler) {
2481 
            if (events === undefinedVar) {
2482 
                return;
2483 
            }
2424 2484
2425 
    /**
2426 
     * remove a recognizer by name or instance
2427 
     * @param {Recognizer|String} recognizer
2428 
     * @returns {Manager}
2429 
     */
2430 
    remove: function(recognizer) {
2431 
        if (invokeArrayArg(recognizer, 'remove', this)) {
2485 
            var handlers = this.handlers;
2486 
            each(splitStr(events), function(event) {
2487 
                if (!handler) {
2488 
                    delete handlers[event];
2489 
                } else {
2490 
                    handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
2491 
                }
2492 
            });
2432 2493 
            return this;
2433 
        }
2494 
        },
2434 2495
2435 
        recognizer = this.get(recognizer);
2496 
        /**
2497 
         * emit event to the listeners
2498 
         * @param {String} event
2499 
         * @param {Object} data
2500 
         */
2501 
        emit: function(event, data) {
2502 
            // we also want to trigger dom events
2503 
            if (this.options.domEvents) {
2504 
                triggerDomEvent(event, data);
2505 
            }
2436 2506
2437 
        // let's make sure this recognizer exists
2438 
        if (recognizer) {
2439 
            var recognizers = this.recognizers;
2440 
            var index = inArray(recognizers, recognizer);
2507 
            // no handlers, so skip it all
2508 
            var handlers = this.handlers[event] && this.handlers[event].slice();
2509 
            if (!handlers || !handlers.length) {
2510 
                return;
2511 
            }
2441 2512
2442 
            if (index !== -1) {
2443 
                recognizers.splice(index, 1);
2444 
                this.touchAction.update();
2513 
            data.type = event;
2514 
            data.preventDefault = function() {
2515 
                data.srcEvent.preventDefault();
2516 
            };
2517
2518 
            var i = 0;
2519 
            while (i < handlers.length) {
2520 
                handlers[i](data);
2521 
                i++;
2445 2522 
            }
2446 
        }
2523 
        },
2447 2524
2448 
        return this;
2449 
    },
2525 
        /**
2526 
         * destroy the manager and unbinds all events
2527 
         * it doesn't unbind dom events, that is the user own responsibility
2528 
         */
2529 
        destroy: function() {
2530 
            this.element && toggleCssProps(this, false);
2450 2531
2451 
    /**
2452 
     * bind event
2453 
     * @param {String} events
2454 
     * @param {Function} handler
2455 
     * @returns {EventEmitter} this
2456 
     */
2457 
    on: function(events, handler) {
2458 
        if (events === undefined) {
2459 
            return;
2460 
        }
2461 
        if (handler === undefined) {
2462 
            return;
2532 
            this.handlers = {};
2533 
            this.session = {};
2534 
            this.input.destroy();
2535 
            this.element = null;
2463 2536 
        }
2464
2465 
        var handlers = this.handlers;
2466 
        each(splitStr(events), function(event) {
2467 
            handlers[event] = handlers[event] || [];
2468 
            handlers[event].push(handler);
2469 
        });
2470 
        return this;
2471 
    },
2537 
    };
2472 2538
2473 2539 
    /**
2474 
     * unbind event, leave emit blank to remove all handlers
2475 
     * @param {String} events
2476 
     * @param {Function} [handler]
2477 
     * @returns {EventEmitter} this
2540 
     * add/remove the css properties as defined in manager.options.cssProps
2541 
     * @param {Manager} manager
2542 
     * @param {Boolean} add
2478 2543 
     */
2479 
    off: function(events, handler) {
2480 
        if (events === undefined) {
2544 
    function toggleCssProps(manager, add) {
2545 
        var element = manager.element;
2546 
        if (!element.style) {
2481 2547 
            return;
2482 2548 
        }
2483
2484 
        var handlers = this.handlers;
2485 
        each(splitStr(events), function(event) {
2486 
            if (!handler) {
2487 
                delete handlers[event];
2549 
        var prop;
2550 
        each(manager.options.cssProps, function(value, name) {
2551 
            prop = prefixed(element.style, name);
2552 
            if (add) {
2553 
                manager.oldCssProps[prop] = element.style[prop];
2554 
                element.style[prop] = value;
2488 2555 
            } else {
2489 
                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);
2556 
                element.style[prop] = manager.oldCssProps[prop] || '';
2490 2557 
            }
2491 2558 
        });
2492 
        return this;
2493 
    },
2559 
        if (!add) {
2560 
            manager.oldCssProps = {};
2561 
        }
2562 
    }
2494 2563
2495 2564 
    /**
2496 
     * emit event to the listeners
2565 
     * trigger dom event
2497 2566 
     * @param {String} event
2498 2567 
     * @param {Object} data
2499 2568 
     */
2500 
    emit: function(event, data) {
2501 
        // we also want to trigger dom events
2502 
        if (this.options.domEvents) {
2503 
            triggerDomEvent(event, data);
2504 
        }
2505
2506 
        // no handlers, so skip it all
2507 
        var handlers = this.handlers[event] && this.handlers[event].slice();
2508 
        if (!handlers || !handlers.length) {
2509 
            return;
2510 
        }
2511
2512 
        data.type = event;
2513 
        data.preventDefault = function() {
2514 
            data.srcEvent.preventDefault();
2515 
        };
2516
2517 
        var i = 0;
2518 
        while (i < handlers.length) {
2519 
            handlers[i](data);
2520 
            i++;
2521 
        }
2522 
    },
2523
2524 
    /**
2525 
     * destroy the manager and unbinds all events
2526 
     * it doesn't unbind dom events, that is the user own responsibility
2527 
     */
2528 
    destroy: function() {
2529 
        this.element && toggleCssProps(this, false);
2569 
    function triggerDomEvent(event, data) {
2570 
        var gestureEvent = document.createEvent('Event');
2571 
        gestureEvent.initEvent(event, true, true);
2572 
        gestureEvent.gesture = data;
2573 
        data.target.dispatchEvent(gestureEvent);
2574 
    }
2530 2575
2531 
        this.handlers = {};
2532 
        this.session = {};
2533 
        this.input.destroy();
2534 
        this.element = null;
2535 
    }
2536 
};
2537
2538 
/**
2539 
 * add/remove the css properties as defined in manager.options.cssProps
2540 
 * @param {Manager} manager
2541 
 * @param {Boolean} add
2542 
 */
2543 
function toggleCssProps(manager, add) {
2544 
    var element = manager.element;
2545 
    if (!element.style) {
2546 
        return;
2547 
    }
2548 
    var prop;
2549 
    each(manager.options.cssProps, function(value, name) {
2550 
        prop = prefixed(element.style, name);
2551 
        if (add) {
2552 
            manager.oldCssProps[prop] = element.style[prop];
2553 
            element.style[prop] = value;
2554 
        } else {
2555 
            element.style[prop] = manager.oldCssProps[prop] || '';
2556 
        }
2576 
    assign(Hammer, {
2577 
        INPUT_START: INPUT_START,
2578 
        INPUT_MOVE: INPUT_MOVE,
2579 
        INPUT_END: INPUT_END,
2580 
        INPUT_CANCEL: INPUT_CANCEL,
2581
2582 
        STATE_POSSIBLE: STATE_POSSIBLE,
2583 
        STATE_BEGAN: STATE_BEGAN,
2584 
        STATE_CHANGED: STATE_CHANGED,
2585 
        STATE_ENDED: STATE_ENDED,
2586 
        STATE_RECOGNIZED: STATE_RECOGNIZED,
2587 
        STATE_CANCELLED: STATE_CANCELLED,
2588 
        STATE_FAILED: STATE_FAILED,
2589
2590 
        DIRECTION_NONE: DIRECTION_NONE,
2591 
        DIRECTION_LEFT: DIRECTION_LEFT,
2592 
        DIRECTION_RIGHT: DIRECTION_RIGHT,
2593 
        DIRECTION_UP: DIRECTION_UP,
2594 
        DIRECTION_DOWN: DIRECTION_DOWN,
2595 
        DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
2596 
        DIRECTION_VERTICAL: DIRECTION_VERTICAL,
2597 
        DIRECTION_ALL: DIRECTION_ALL,
2598
2599 
        Manager: Manager,
2600 
        Input: Input,
2601 
        TouchAction: TouchAction,
2602
2603 
        TouchInput: TouchInput,
2604 
        MouseInput: MouseInput,
2605 
        PointerEventInput: PointerEventInput,
2606 
        TouchMouseInput: TouchMouseInput,
2607 
        SingleTouchInput: SingleTouchInput,
2608
2609 
        Recognizer: Recognizer,
2610 
        AttrRecognizer: AttrRecognizer,
2611 
        Tap: TapRecognizer,
2612 
        Pan: PanRecognizer,
2613 
        Swipe: SwipeRecognizer,
2614 
        Pinch: PinchRecognizer,
2615 
        Rotate: RotateRecognizer,
2616 
        Press: PressRecognizer,
2617
2618 
        on: addEventListeners,
2619 
        off: removeEventListeners,
2620 
        each: each,
2621 
        merge: merge,
2622 
        extend: extend,
2623 
        assign: assign,
2624 
        inherit: inherit,
2625 
        bindFn: bindFn,
2626 
        prefixed: prefixed
2557 2627 
    });
2558 
    if (!add) {
2559 
        manager.oldCssProps = {};
2560 
    }
2561 
}
2562
2563 
/**
2564 
 * trigger dom event
2565 
 * @param {String} event
2566 
 * @param {Object} data
2567 
 */
2568 
function triggerDomEvent(event, data) {
2569 
    var gestureEvent = document.createEvent('Event');
2570 
    gestureEvent.initEvent(event, true, true);
2571 
    gestureEvent.gesture = data;
2572 
    data.target.dispatchEvent(gestureEvent);
2573 
}
2574
2575 
assign(Hammer, {
2576 
    INPUT_START: INPUT_START,
2577 
    INPUT_MOVE: INPUT_MOVE,
2578 
    INPUT_END: INPUT_END,
2579 
    INPUT_CANCEL: INPUT_CANCEL,
2580
2581 
    STATE_POSSIBLE: STATE_POSSIBLE,
2582 
    STATE_BEGAN: STATE_BEGAN,
2583 
    STATE_CHANGED: STATE_CHANGED,
2584 
    STATE_ENDED: STATE_ENDED,
2585 
    STATE_RECOGNIZED: STATE_RECOGNIZED,
2586 
    STATE_CANCELLED: STATE_CANCELLED,
2587 
    STATE_FAILED: STATE_FAILED,
2588
2589 
    DIRECTION_NONE: DIRECTION_NONE,
2590 
    DIRECTION_LEFT: DIRECTION_LEFT,
2591 
    DIRECTION_RIGHT: DIRECTION_RIGHT,
2592 
    DIRECTION_UP: DIRECTION_UP,
2593 
    DIRECTION_DOWN: DIRECTION_DOWN,
2594 
    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,
2595 
    DIRECTION_VERTICAL: DIRECTION_VERTICAL,
2596 
    DIRECTION_ALL: DIRECTION_ALL,
2597
2598 
    Manager: Manager,
2599 
    Input: Input,
2600 
    TouchAction: TouchAction,
2601
2602 
    TouchInput: TouchInput,
2603 
    MouseInput: MouseInput,
2604 
    PointerEventInput: PointerEventInput,
2605 
    TouchMouseInput: TouchMouseInput,
2606 
    SingleTouchInput: SingleTouchInput,
2607
2608 
    Recognizer: Recognizer,
2609 
    AttrRecognizer: AttrRecognizer,
2610 
    Tap: TapRecognizer,
2611 
    Pan: PanRecognizer,
2612 
    Swipe: SwipeRecognizer,
2613 
    Pinch: PinchRecognizer,
2614 
    Rotate: RotateRecognizer,
2615 
    Press: PressRecognizer,
2616
2617 
    on: addEventListeners,
2618 
    off: removeEventListeners,
2619 
    each: each,
2620 
    merge: merge,
2621 
    extend: extend,
2622 
    assign: assign,
2623 
    inherit: inherit,
2624 
    bindFn: bindFn,
2625 
    prefixed: prefixed
2626 
});
2627 2628
2628 2629 
// this prevents errors when Hammer is loaded in the presence of an AMD
2629 2630 
//  style loader but by script tag, not by the loader.
2630 
var freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line
2631 
freeGlobal.Hammer = Hammer;
2631 
    var freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line
2632 
    freeGlobal.Hammer = Hammer;
2632 2633
2633 
if (typeof define === 'function' && define.amd) {
2634 
    define(function() {
2635 
        return Hammer;
2636 
    });
2637 
} else if (typeof module != 'undefined' && module.exports) {
2638 
    module.exports = Hammer;
2639 
} else {
2640 
    window[exportName] = Hammer;
2641 
}
2634 
    if (typeof define === 'function' && define.amd) {
2635 
        define(function() {
2636 
            return Hammer;
2637 
        });
2638 
    } else if (typeof module != 'undefined' && module.exports) {
2639 
        module.exports = Hammer;
2640 
    } else {
2641 
        window[exportName] = Hammer;
2642 
    }
2642 2643
2643 2644 
})(window, document, 'Hammer');

+ 1 - 1
static-res/hz-tyjh/ui/dist/js/ipu.js
Bestand weergeven 

@ -1288,7 +1288,7 @@
1288 1288 
    };
1289 1289 
    ipu.closeModal = function (modal) {
1290 1290 
        modal = $(modal || '.ipu-modal-in');
1291 
        if (typeof modal !== 'undefined' && modal.length === 0) {
1291 
        if (typeof modalObj === 'undefined' || modalObj == null || (typeof modalObj !== 'undefined' && modalObj.length === 0)) {
1292 1292 
            return;
1293 1293 
        }
1294 1294 
        var isModal = modal.hasClass('ipu-modal'),

shenli3 - Nuosi Git Service
Home Explore Help
Sign In
shenli3
Repositories Public Activity
修改考勤类型必填的问题 · b853fa9490 - Nuosi Git Service
Главная Обзор Помощь
Войти
asiainfo
/
ebc
Следить 4
В избранное 0
Ответвить 0
Код Обсуждения 0 Запросы на слияние 0 Коммиты 397 Релизы 0 Вики
Просмотр исходного кода

修改考勤类型必填的问题

konghl лет назад: 4
Родитель
902b99be6a
Сommit
b853fa9490
1 измененных файлов с 2 добавлено и 2 удалено
Разделённый вид Показать статистику Diff
  1. 2 2
      security-protection-service/src/main/java/com/ai/bss/security/protection/service/task/AiResultRecordKafkaTask.java

+ 2 - 2
security-protection-service/src/main/java/com/ai/bss/security/protection/service/task/AiResultRecordKafkaTask.java
Просмотреть файл 

@ -92,14 +92,14 @@ public class AiResultRecordKafkaTask {
92 92 
			aiIdenLog.setResourceToolName(StringUtils.defaultIfBlank(String.valueOf(resourceToolMap.get("resourceToolName")),""));
93 93 
			aiIdenLog.setMonitorSceneId(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("monitorSceneId")),""));
94 94 
			aiIdenLog.setMonitorSceneName(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("monitorSceneName")),""));
95 
			aiIdenLog.setEffectType(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("effectType")),EbcConstant.TERMINAL_EFFECT_TYPE_OTH));
95 
			//aiIdenLog.setEffectType(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("effectType")),EbcConstant.TERMINAL_EFFECT_TYPE_OTH));
96 96 
			aiIdenLog.setTerminalPosition(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("place")),""));
97 97 
			aiIdenLog.setOrganizationId(StringUtils.defaultIfBlank(String.valueOf(sceneTerminalRelMap.get("orgId")),""));
98 98 
			aiIdenLog.setAiTaskId(aiTaskMap.get("aiTaskId")==null?0L:Long.valueOf(String.valueOf(aiTaskMap.get("aiTaskId"))));
99 99
100 100 
			//TODO 人员信息暂时默认
101 101 
			aiIdenLog.setRelateEmployeeRoleId("201613310867");
102 
			aiIdenLog.setRelateEmployeeRoleId("王浩");
102 
			aiIdenLog.setRelateEmployeeRoleName("王浩");
103 103
104 104 
			//执行操作
105 105 
			CommonRequest<AiIdenLog> aiIdenLogRequest=new CommonRequest<AiIdenLog>(aiIdenLog);