Se crea el método que elimina la alerta del contenedor
504988
function smkAlertHide(){
      timer = setTimeout(function() {
        obj.animate({
          opacity: '0',
        }, 300, function() {
          obj.remove();
        });
      }, (settings.time * 1000) );
    }
465746
public function renderAlert()
    {
        $user = \Yii::app()->user;
        if (count($user->getFlashes(false)) == 0) {
            return;
        }
        $alerts = array();
        foreach ($this->config as $style => $config) {
            if ($user->hasFlash($style)) {
                $options = ArrayHelper::getValue($config, 'htmlOptions', array());
                Html::addCssClass($options, $style);
                $close    = ArrayHelper::getValue($config, 'close', '&times;');
                $alerts[] = \foundation\helpers\Alert::alert($user->getFlash($style), $options, $close);
            }
        }
        $this->registerEvents("#{$this->htmlOptions['id']} > .alert-box", $this->events);

        return \CHtml::tag('div', $this->htmlOptions, implode("\n", $alerts));
    }
843025
public function alert()
	{
		?>
		<p>The format of the function is:</p>
		<pre class="code php">alert($html, $class = 'info', $icon = '');</pre>
		<?php
		p('Pass text only to output a basic Bootstrap "info" alert box:');
		alert('Just text passed');

		p('Pass a 2nd argument of a Bootstrap <a href="http://getbootstrap.com/components/#alerts" target="_blank">alert</a> message class:');
		alert('Passed with "success"', 'success');
		alert('Passed with "warning"', 'warning');
		alert('Passed with "danger"', 'danger');

		p('Pass a 2nd argument of a boolean state to render tick or cross icons:');
		alert('Passed with true', true);
		alert('Passed with false', false);

		p('Pass a 3rd argument of a string to render a custom <a href="http://fontawesome.io/icons/" target="_blank">Font Awesome</a> icon:');
		alert('Passed with "info" and "info"', 'info', 'info');
		alert('Passed with "warning" and "bolt"', 'warning', 'bolt');
	}
194697
private function step1()
    {
        // amente
        //      delete if in R1
        //      if preceded by iv, delete if in R2 (and if further preceded by at, delete if in R2), otherwise,
        //      if preceded by os, ic or abil, delete if in R2
        if ( ($position = $this->search(array('amente'))) !== false) {
            if ($this->inR1($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }

            // if preceded by iv, delete if in R2 (and if further preceded by at, delete if in R2), otherwise,
            if ( ($position2 = $this->searchIfInR2(array('iv'))) !== false) {
                $this->word = Utf8::substr($this->word, 0, $position2);
                if ( ($position3 = $this->searchIfInR2(array('at'))) !== false) {
                    $this->word = Utf8::substr($this->word, 0, $position3);
                }

                // if preceded by os, ic or ad, delete if in R2
            } elseif ( ($position4 = $this->searchIfInR2(array('os', 'ic', 'abil'))) != false) {
                $this->word = Utf8::substr($this->word, 0, $position4);
            }
            return true;
        }

        // delete if in R2
        if ( ($position = $this->search(array(
            'ibili', 'atrice', 'abili', 'abile', 'ibile', 'atrici', 'mente',
            'anza', 'anze', 'iche', 'ichi', 'ismo', 'ismi', 'ista', 'iste', 'isti', 'istà', 'istè', 'istì', 'ante', 'anti',
            'ico', 'ici', 'ica', 'ice', 'oso', 'osi', 'osa', 'ose'
        ))) !== false) {

            if ($this->inR2($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }
            return true;
        }

        // azione   azioni   atore   atori
        //      delete if in R2
        //      if preceded by ic, delete if in R2
        if ( ($position = $this->search(array('azione', 'azioni', 'atore', 'atori'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);

                if ( ($position2 = $this->search(array('ic'))) !== false) {
                    if ($this->inR2($position2)) {
                        $this->word = Utf8::substr($this->word, 0, $position2);
                    }
                }
            }
            return true;
        }

        // logia   logie
        //      replace with log if in R2
        if ( ($position = $this->search(array('logia', 'logie'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = preg_replace('#(logia|logie)$#u', 'log', $this->word);
            }
            return true;
        }

        // uzione   uzioni   usione   usioni
        //      replace with u if in R2
        if ( ($position = $this->search(array('uzione', 'uzioni', 'usione', 'usioni'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = preg_replace('#(uzione|uzioni|usione|usioni)$#u', 'u', $this->word);
            }
            return true;
        }

        // enza   enze
        //      replace with ente if in R2
        if ( ($position = $this->search(array('enza', 'enze'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = preg_replace('#(enza|enze)$#u', 'ente', $this->word);
            }
            return true;
        }

        // amento   amenti   imento   imenti
        //      delete if in RV
        if ( ($position = $this->search(array('amento', 'amenti', 'imento', 'imenti'))) !== false) {
            if ($this->inRv($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }
            return true;
        }

        // ità
        //      delete if in R2
        //      if preceded by abil, ic or iv, delete if in R2
        if ( ($position = $this->search(array('ità'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }

            if ( ($position2 = $this->searchIfInR2(array('abil', 'ic', 'iv'))) != false) {
                $this->word = Utf8::substr($this->word, 0, $position2);
            }
            return true;
        }

        // ivo   ivi   iva   ive
        //      delete if in R2
        //      if preceded by at, delete if in R2 (and if further preceded by ic, delete if in R2)
        if ( ($position = $this->search(array('ivo', 'ivi', 'iva', 'ive'))) !== false) {
            if ($this->inR2($position)) {
                $this->word = Utf8::substr($this->word, 0, $position);
            }

            if ( ($position2 = $this->searchIfInR2(array('at'))) !== false) {
                $this->word = Utf8::substr($this->word, 0, $position2);
                if ( ($position3 = $this->searchIfInR2(array('ic'))) !== false) {
                    $this->word = Utf8::substr($this->word, 0, $position3);
                }
            }
            return true;
        }

        return false;
    }
973889
def exception_info(current_filename=None, index=-1):
    ""
    # guardo el traceback original (por si hay una excepción):
    info = sys.exc_info() #         exc_type, exc_value, exc_traceback
    # importante: no usar unpacking porque puede causar memory leak
    if not current_filename:
        # genero un call stack para ver quien me llamó y limitar la traza: 
        # advertencia: esto es necesario ya que en py2exe no tengo __file__ 
        try:
            raise ZeroDivisionError
        except ZeroDivisionError:
            f = sys.exc_info()[2].tb_frame.f_back
        current_filename = os.path.normpath(os.path.abspath(f.f_code.co_filename))

    # extraer la última traza del archivo solicitado:
    # (útil para no alargar demasiado la traza con lineas de las librerías)
    ret = {'filename': "", 'lineno': 0, 'function_name': "", 'code': ""}
    try:
        for (filename, lineno, fn, text) in traceback.extract_tb(info[2]):
            if os.path.normpath(os.path.abspath(filename)) == current_filename:
                ret = {'filename': filename, 'lineno': lineno, 
                       'function_name': fn, 'code': text}
    except Exception, e:
        pass
    # obtengo el mensaje de excepcion tal cual lo formatea python:
    # (para evitar errores de encoding)
    try:
        ret['msg'] = traceback.format_exception_only(*info[0:2])[0]
    except: 
        ret['msg'] = '<no disponible>'
    # obtener el nombre de la excepcion (ej. "NameError")
    try:
        ret['name'] = info[0].__name__
    except:
        ret['name'] = 'Exception'
    # obtener la traza formateada como string:
    try:
        tb = traceback.format_exception(*info)
        ret['tb'] = ''.join(tb)
    except:
        ret['tb'] = ""
    return ret
1198208
public function getAlertMessageType()
    {
        // Obtain Base Alert Class:
        
        $classes = $this->styles('alert');
        
        // Determine Message Type:
        
        switch ($this->owner->MessageType) {
            case ValidationResult::TYPE_GOOD:
                $classes[] = $this->style('alert.success');
                break;
            case ValidationResult::TYPE_INFO:
                $classes[] = $this->style('alert.info');
                break;
            case ValidationResult::TYPE_ERROR:
                $classes[] = $this->style('alert.danger');
                break;
            default:
                $classes[] = $this->style('alert.warning');
        }
        
        // Answer Classes:
        
        return ViewTools::singleton()->array2att($classes);
    }
535984
def ConsultarCondicionesVenta(self, sep="||"):
        ""
        ret = self.client.consultarCondicionesVenta(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('condicionVenta', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
718462
protected function registerAlertContainer()
    {
        $this->app->singleton('alert', function ($app) {
            $this->loadConfigurationOptions();

            $alert = new Alert(
                $this->getAlertHandler(),
                $this->getTheme()
            );

            if ($this->options['translate_texts']) {
                $alert->setLang($app['translator']);
            }

            return $alert;
        });

        $this->app->alias('alert', Alert::class);
    }
1206451
public function toggleAction()
    {
        //wyszukiwanie relacji do edycji
        if (null === $widgetRelation = (new \Cms\Orm\CmsCategoryWidgetCategoryQuery)
            ->whereCmsCategoryId()->equals($this->categoryId)
            ->findPk($this->id)) {
            return '';
        }
        //zmiana widoczności relacji
        $widgetRelation->toggle();
        return '';
    }
728125
function(input) {

			// Nos deshacemos del caracter final `:` para su validación

			var size = (input = _toString(input)).length;

			input = (input.substr(size-1, 1) === ':') ? input.substr(0, input.length-1) : input;

			// Si el protocolo es correcto añadimos `:` al final del mismo
			// si no lo es devolvemos una cadena vacía

			return Public.normalize.regex_rfc3986_schema.test((input = input.toLowerCase())) ? (input + ':') : '';

		}
1248280
def ConsultarMotivos(self, sep="||"):
        ""
        ret = self.client.consultarMotivos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('motivo', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
665256
def ConsultarTiposEstado(self, sep="||"):
        ""
        ret = self.client.consultarTiposEstado(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarTiposEstadoReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayTiposEstado', [])
        lista = [it['codigoDescripcionString'] for it in array]
        return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista]
359184
public function getAlerts()
    {
        if (! isset($this->config['access_token'])) {
            throw new Exception('StatHat Alerts API Access Token not set.');
        }

        $result = $this->curlGet($this->alerts_url.'/x/'.$this->config['access_token'].'/alerts');

        return $result;
    }
65175
public function handleRemoveImage()
    {
        if ($this->presenter->isAjax())
        {
            $removed = $this->onPageManager->removeSocialImage($this->activePage);

            if ($removed)
            {
                $this->presenter->notificationAjax(
                    'On-Page faktory',
                    'Obrázek pro sociální sítě byl odstaněn.',
                    'info',
                    FALSE
                );

                $this->onRemoveImage();
            }
        }
    }
1184866
function() {

			// Construimos los atributos en base a la localización

			var attr = Public.unbuild(this._attributes, this.location);

			// Si no se encuentra disponible la instancia localización

			if (!(this.location instanceof Public))

				// La dirección será externa si tiene definido el atributo `protocol` o `host`

				return (attr.protocol || attr.host) ? true : false;

			// La URL será externa si `protocol` o `host` no coincide con el de localización

			return (this.location.attr('protocol') !== attr.protocol || this.location.attr('host') !== attr.host);

		}
801262
public function buildAlerts()
    {
        $str = '';
        foreach ($this->alerts as $alert) {
            $str = $this->build($alert);
        }
        return $str;
    }
1207828
def AnularLiquidacionSecundaria(self, coe):
        ""
        ret = self.client.lsgAnular(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        )
        ret = ret['anulacionReturn']
        self.__analizar_errores(ret)
        self.Resultado = ret['resultado']
        return self.COE