Python Logger.info方法代码示例

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def apply_rule(self, rule, field, message_id, label_id, resource):

        """
        Busca una regla a aplicar en el subject del mensaje.
        :param rule: Regla a aplicar.
        :param field: Campo a aplicar la regla.
        :param message_id: Identificador del mensaje.
        :param label_id: Identificador de la label.
        :param resource: Recurso Gmail API.
        """

        from re import MULTILINE, IGNORECASE, search
        from core.logger import Logger

        matches = search(rule, field, MULTILINE | IGNORECASE)
        if matches:
            Logger.info("Labeling message: {}".format(message_id))
            # Modificamos el mensaje.
            resource.modify(
                id=message_id,
                body={
                    "addLabelIds": [label_id],  # Añadimos la etiqueta indicada.
                    "removeLabelIds": ["INBOX"]  # Quitamos el mensaje del inbox.
                }
            )
            return True
        return False

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
        def wrapper(request_handler, *args, **kwargs):

            # Almacenamos la URL de origen.
            self._origin = request_handler.request.path

            # Obtenemos las credenciales del usuario en sesión a partir de su almacén.
            storage = self.get_storage_for_user_in_request(request_handler)
            credentials = storage.get()
            Logger.info("Credentials...{}".format(credentials))
            Logger.info("Origin......{}".format(self._origin))
            # Si no existen credenciales de usuario almacenadas o bien están caducadas.
            if credentials is None or credentials.access_token_expired:

                # Creamos un flujo OAuth.
                self.create_flow(request_handler)
                # Obtenemos la URL de autorización.
                authorize_url = self._flow.step1_get_authorize_url()
                # Llevamos al usuario a la pantalla de autorización.
                output = request_handler.redirect(authorize_url)

            # En caso contrario, ejecutamos el método decorado.
            else:
                output = method(request_handler, *args, **kwargs)

            return output

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def _post_message(self, message):

        """
        Send the given message to the Facebook Messenger platform.
        :param message: The message to post.
        :return: The Facebook Messenger response.
        """

        from core.logger import Logger
        from google.appengine.api import urlfetch
        from json import dumps

        try:
            # Post the message to the Facebook Messenger platform.
            r = urlfetch.fetch(
                url=self._fb_messenger_api_url,
                method=urlfetch.POST,
                headers={"Content-Type": "application/json"},
                payload=dumps(message)
            )

            # Parse the response.
            response = r.content if r.status_code == 200 else None
            Logger.info("Facebook response:\n%s" % response)

        # In case of error.
        except BaseException as e:
            Logger.error(e)
            response = None

        # Return the parsed response.
        return response

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def authorize(self, email):

        """
        Autoriza el buzón de correo indicado.
        :param email: Identificador de buzón de correo.
        :return: El buzón de correo autorizado.
        """

        from managers.pending_authorization import PendingAuthorizationManager
        from core.logger import Logger

        try:
            entity = self.get_by_email(email)
            if entity is not None:
                Logger.info("It's authorized: {}".format(entity.is_authorized))
                # Marcamos el buzón como autorizado.
                entity.is_authorized = True
                entity.updated_by = self._user
                entity.put()
                # Obtenemos el diccionario que representa el buzón actualizado.
                entity = entity.to_dict()
                # Eliminamos la autorización.
                PendingAuthorizationManager.delete(entity["user_id"])
        except Exception as e:
            Logger.error(e)
            raise e
        return entity

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
            def get(self):

                from core.logger import Logger

                # Almacenamos las credenciales de usuario contenidas en la petición.
                myself.store_credentials(self)
                Logger.info("Origin...{}".format(myself.get_origin()))
                # Navegamos a la URL de origen.
                self.redirect("/" if myself is None or myself.get_origin() is None else myself.get_origin())

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def create_label(self, label):

        """
        Crea una nueva etiqueta, estableciendo el buzón de correo indicado como padre.
        :param label: Etiqueta.
        :return: La etiqueta creada.
        """

        from clients.gmail_api import GmailApiClient
        from core.logger import Logger
        from models.label import LabelDao

        try:

            # Comprobamos que los datos obligatorios vengan informados.
            if label.gmail_name is None:
                raise Exception("Label gmail_name cannot be empty.")
            # Establecemos el nombre de la etiqueta.
            gmail_name = label.gmail_name
            entity = self.get()
            # Obtenemos el acceso al recurso 'labels' de Gmail API.
            resource = GmailApiClient(entity.email).labels()
            # Obtenemos todas las etiquetas del buzón para, en caso de
            # existir ya, seleccionar dicha etiqueta en vez de crearla.
            mailbox_labels = resource.list()
            # Comprobamos si ya existe una etiqueta con el nombre propuesto.
            current_label = next((l for l in mailbox_labels["labels"] if l["name"].lower() == gmail_name.lower()), None)
            Logger.info("Current label: %s ", current_label)
            # Si no existe la creamos.
            if current_label is None:
                response = resource.create(body={
                    "name": gmail_name,
                    "labelListVisibility": "labelShow",
                    "messageListVisibility": "show"
                })
                entity.updated_by = self._user
                # Añadimos el identificador obtenido.
                label_dao = LabelDao(**{"gmail_name": gmail_name, "gmail_id": response["id"]})
                entity.labels.append(label_dao)
                Logger.info("Created label: {}".format(label_dao.to_dict()))
            else:
                raise Exception("This label is already in this account.")

            # manager.add_label(entity.gmail_id)
            entity.put()
        except Exception as e:
            Logger.error(e)
            raise e
        return entity

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def get(self):

        """
        Obtiene los mensajes del buzón correspondiente al día recién cerrado.
        """

        from google.appengine.api import taskqueue
        from managers.sender_account import SenderAccountManager
        from managers.recipient_account import RecipientAccountManager
        from managers.group import GroupManager
        from core.logger import Logger
        from json import dumps

        # Obtenemos las cuentas emisoras activas y autorizadas.
        senders = filter(lambda x: x["is_active"] and x["is_authorized"], SenderAccountManager.list())
        # Obtenemos las cuentas receptoras activas y autorizadas.
        recipients = filter(lambda x: x["is_active"] and x["is_authorized"], RecipientAccountManager.list())
        # Obtenemos los grupos activos.
        active_groups = filter(lambda x: x["is_active"], GroupManager.list())
        # Por cada cuenta emisora en las cuentas emisoras activas y autorizadas.
        for sender in senders:
            Logger.info("Sender for...{}".format(sender))
            groups = []
            # Por cada grupo a los cuales pertenecen las cuenta emisora.
            for group in sender["groups"]:
                # Si encontramos algún grupo activo de los cuales pertenece la cuenta emisora, lo almacenamos.
                if any([k for k in active_groups if k["id"] == group["id"]]):
                    groups.append(group)
            # Si hemos encontrado algún grupo activo al cual pertenezca la cuenta emisora.
            if groups:
                sender_recipients = []
                # Por cada cuenta receptora en las cuentas receptoras activas y autorizadas.
                for recipient in recipients:
                    # Si encontramos algúna grupo entre los cuales pertenece la cuenta receptora, que esté activo
                    # y a la vez en la cuenta emisora, lo almacenamos.
                    if filter(lambda x: x in recipient["groups"], groups):
                        sender_recipients.append(recipient)
                        Logger.info("sender-recipient...{}".format(sender_recipients))
                # Creamos la task.
                taskqueue.add(
                    queue_name="message-management",
                    url="/tasks/message/management",
                    method="POST",
                    params={
                        "recipient_accounts": dumps(sender_recipients),
                        "sender_account": dumps(sender)
                    }
                )

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def __init__(self, user):

        """
        Constructor de la clase.
        :param user: Usuario cuyas credenciales se usarán para conectar con Gmail API.
        :type user: str.
        """

        from core.logger import Logger

        Logger.info("Initializing gmail client...")
        # Obtenemos las credenciales para el usuario dado.
        credentials = StorageByKeyName(CredentialsModel, user, "credentials").get()
        # Securizamos el cliente HTTP con ellas.
        http = credentials.authorize(httplib2.Http())
        # Construimos el acceso a los recursos de Gmail API.
        self.resource = build("gmail", "v1", http=http)
        Logger.info("Gmail client initialized")

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def send_message(self, message, user):

        """
        Envía el mensaje dado.
        """

        try:
            # Si el mensaje no viene dado como corresponde.
            if not isinstance(message, GmailApiClient.MessageMapper):
                raise TypeError("The given message is not an instance of Message class.")
            Logger.info("Sending the message...")
            Logger.info("Message: {}".format(message))
            # Obtenemos el mensaje en bruto y lo enviamos.
            response = self.messages().send(
                userId=user,
                body={"raw": message.get_raw_message()}
            )
        except (errors.HttpError, TypeError), e:
            Logger.error(e)
            raise e

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def delete_rule(self, label_id, rule_id):

        """
        Elimina una regla de la label indicada.
        :param label_id: Identificador de la label.
        :param rule_id: Identificador de la regla.
        :return: El buzón actualizado.
        """

        from core.logger import Logger

        entity = self.get()
        for idx, label in enumerate(entity.labels):
            if label.gmail_id == label_id:
                entity.labels[idx].rules = filter(lambda x: int(x.id) != int(rule_id), label.rules)
                Logger.info("rules...{}".format(filter(lambda x: int(x.id) != int(rule_id), label.rules)))
                entity.updated_by = self._user
                entity.put()
                break
        else:
            raise Exception()
        return entity

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def update_label(self, label):

        """
        Actualiza la label indicada.
        :param label: Diccionario que representa la label.
        :return: El buzón modificado.
        """

        from clients.gmail_api import GmailApiClient
        from core.logger import Logger

        if "gmail_name" not in label or not label["gmail_name"]:
            raise Exception("The label must have a name.")
        if "gmail_id" not in label or not label["gmail_id"]:
            raise Exception("The label must have an id.")
        Logger.info("Gmail name...{} ... GmailID...{}".format(label["gmail_name"], label["gmail_id"]))
        entity = self.get()
        resource = GmailApiClient(entity.email).labels()
        for i in entity.labels:
            if i.gmail_id == label["gmail_id"]:
                updated_label = resource.update(
                    id=i.gmail_id,
                    body={
                        "name": label["gmail_name"],
                        "labelListVisibility": "labelShow",
                        "messageListVisibility": "show"
                    }
                )
                Logger.info("updated label:{}".format(updated_label))
                entity.updated_by = self._user
                i.gmail_name = label["gmail_name"]
                break
        else:
            raise Exception("This label is not in this account.")

        entity.updated_by = self._user
        entity.put()
        return entity

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
    def post(self):

        """
        Obtiene los mensajes del buzón correspondiente al día recién cerrado.
        """

        from core.logger import Logger
        from json import loads
        from clients.gmail_api import GmailApiClient

        try:
            # Obtenemos los datos de la petición.
            sender = loads(self.request.get("sender_account"))
            recipients = loads(self.request.get("recipient_accounts"))
            # Obtenemos los mensajes de la cuenta emisora.
            messages = self.find_messages(sender["email"])
            resource = GmailApiClient(sender["email"]).messages()
            if messages:
                # Por cada mensaje encontrado.
                for message in messages:
                    # Creamos un mensaje.
                    mssg = GmailApiClient.Message(resource.get(id=message["id"]))
                    # Creamos un mensaje para mappear el mensaje obtenido.
                    mssg2 = GmailApiClient.MessageMapper()
                    Logger.info(u"From address: {}".format(mssg.get_from()))
                    Logger.info(u"Sender address: {}".format(mssg.get_sender()))
                    # Seteamos los campos que nos interesan.
                    mssg2.set_html_body(mssg.get_html_body())
                    mssg2.set_subject(mssg.get_from() + "$ " + mssg.get_subject())
                    mssg2.add_header("Return-Path", u"{}".format(mssg.get_from()))
                    mssg2.add_header("X-Env-Sender", u"{}".format(mssg.get_from()))
                    mssg2.from_address = u"{}".format(mssg.get_from())
                    Logger.info(u"New from: {}".format(mssg2.from_address))
                    # Agregamos los buzones receptores.
                    for recipient in recipients:
                        mssg2.add_recipient(recipient["email"])
                    sender_email = sender["email"]
                    response = GmailApiClient(sender_email).send_message(mssg2, sender_email)
                    # Si obtenemos respuesta, borramos los mensajes del buzón emisor.
                    if response:
                        GmailApiClient(sender_email).messages().delete(
                            id=message["id"],
                            userId=sender_email
                        )

        except Exception as e:
            Logger.error(e)

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
                if retry_interval < 60 * 30:
                    retry_interval = int(retry_interval * 1.3)

                # Ensure we never go over 30 minutes
                if retry_interval > 60 * 30:
                    retry_interval = 60 * 30

                log.warn('Unable to authentication with trakt.tv, will try again in %s seconds', retry_interval)
                schedule(cls.authenticate, retry_interval, retry_interval)
            else:
                log.warn('Authentication failed, username or password is incorrect')

            Main.update_config(False)
            return False

        log.info('Authentication successful')

        Main.update_config(True)
        return True

    def start(self):
        # Check for authentication token
        log.info('X-Plex-Token: %s', 'available' if os.environ.get('PLEXTOKEN') else 'unavailable')

        # Validate username/password
        spawn(self.authenticate)

        # Start modules
        names = []

        for module in self.modules:

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
        def do_request(**kwargs):

            """
            Realiza una petición a un recurso de Gmail API.
            :param kwargs: Parámetros de la petición.
            :type kwargs: dict.
            :return: Respuesta de Gmail API.
            """

            """
            Puede que ocurra un error de rateLimitExceeded o userRateLimitExceeded.
            En ese caso la documentación oficial recomienda implementar un exponential backoff
            https://developers.google.com/gmail/api/guides/migrate-from-emapi
            https://developers.google.com/drive/v2/web/handle-errors
            https://github.com/google/google-api-python-client/blob/master/googleapiclient/http.py#L65
            """

            from core.logger import Logger

            if "userId" not in kwargs:
                kwargs["userId"] = "me"

            Logger.info("Executing request...")
            # Reintentamos 3 veces.
            for n in range(0, 3):
                try:
                    Logger.info("Try #{}".format(n + 1))
                    response = method(**kwargs).execute(num_retries=3)
                    return response
                except errors.HttpError, e:
                    Logger.info(e)
                    Logger.info("Execution failed...")
                    Logger.info("Status: {}".format(e.resp.status))
                    Logger.info("Reason: {}".format(e.resp.reason))
                    if e.resp.status in [403, 429, 503] or \
                            e.resp.reason in ["rateLimitExceeded", "userRateLimitExceeded"]:
                        Logger.warning("Error {}. Retrying".format(e.resp.status))
                        time.sleep((2 ** n) + random.randint(0, 1000) / 1000)
                    else:
                        Logger.error("Unknown error: {}".format(e))
                        raise e

# 需要导入模块: from core.logger import Logger [as 别名]
# 或者: from core.logger.Logger import info [as 别名]
        def __create_message(self):

            """
            Construye un mensaje -email- con los datos almacenados en la instancia actual.
            :return: El mensaje como MIMEText o MIMEMultipart.
            """

            try:
                Logger.info("Generating the message...")
                # Si se han indicado cuerpos tanto en texto plano como en HTML.
                if self.plain_body is not None and self.html_body is not None:
                    message = MIMEMultipart("alternative")
                    message.attach(MIMEText(self.plain_body, "plain"))
                    message.attach(MIMEText(self.html_body, "html"))
                # Si solo se ha indicado el cuerpo en texto plano.
                elif self.plain_body is not None:
                    message = MIMEText(self.plain_body, "plain")
                # Si solo se ha indicado el cuerpo en HTML.
                else:
                    message = MIMEText(self.html_body, "html")
                Logger.info("Appending the attachments...")
                # Si existen adjuntos.
                if len(self.attachments) > 0:
                    # El mensaje pasa a ser un MIMEMultipart con los cuerpos adjuntos.
                    aux = message
                    message = MIMEMultipart()
                    message.attach(aux)
                    # Por cada adjunto.
                    for filename, content in self.attachments:
                        # Obtenemos su mimetype.
                        mimetype, encoding = mimetypes.guess_type(filename)
                        if mimetype is None or encoding is not None:
                            mimetype = "application/octet-stream"
                        maintype, subtype = mimetype.split("/", 1)
                        # Construimos el part correspondiente al adjunto en base al mimetype.
                        if maintype == "text":
                            part = MIMEText(content, _subtype=subtype)
                        elif maintype == "image":
                            part = MIMEImage(content, _subtype=subtype)
                        elif maintype == "audio":
                            part = MIMEAudio(content, _subtype=subtype)
                        else:
                            part = MIMEBase(maintype, subtype)
                            part.set_payload(content)
                        part.add_header("Content-Disposition", "attachment", filename=filename)
                        # Añadimos el part del adjunto al principal.
                        message.attach(part)
                Logger.info("Appending the headers...")
                # Añadimos las cabeceras comunes.
                message["Subject"] = self.subject
                message["From"] = self.from_address
                message["To"] = ", ".join([r[0] if r[1] is None else "%s <%s>" % r for r in self.to_recipients])
                message["Cc"] = ", ".join([r[0] if r[1] is None else "%s <%s>" % r for r in self.cc_recipients])
                message["Bcc"] = ", ".join([r[0] if r[1] is None else "%s <%s>" % r for r in self.bcc_recipients])
                Logger.info(u"Final from:{}".format(message["From"]))
                # Si existen otras cabeceras.
                if len(self.headers) > 0:
                    # Las añadimos al part principal.
                    for key, value in self.headers:
                        message[key] = value
                Logger.info("Message generated successfully")
                Logger.info("The message: {}".format(message))

            except Exception as e:
                Logger.error(e)
                raise e
            return message