الگوی زنجیره مسئولیت

""" Chain of responsibility pattern example. """ from abc import ABCMeta, abstractmethod from enum import Enum, auto  class LogLevel(Enum):     """     Log Levels Enum.     """     NONE = auto()     INFO = auto()     DEBUG = auto()     WARNING = auto()     ERROR = auto()     FUNCTIONAL_MESSAGE = auto()     FUNCTIONAL_ERROR = auto()     ALL = auto()  class Logger:     """     Abstract handler in chain of responsibility pattern.     """     __metaclass__ = ABCMeta      next = None      def __init__(self, levels):         """         Initialize new logger          Args:             levels (list[str]): List of log levels.         """         self.log_levels = []          for level in levels:             self.log_levels.append(level)      def set_next(self, next_logger):         """         Set next responsible logger in the chain.          Args:             next_logger (Logger): Next responsible logger.          Returns:             Logger: Next responsible logger.         """         self.next = next_logger         return self.next      def message(self, msg, severity):         """         Message writer handler.          Args:             msg (str): Message string.             severity (LogLevel): Severity of message as log level enum.         """         if LogLevel.ALL in self.log_levels or severity in self.log_levels:             self.write_message(msg)          if self.next is not None:             self.next.message(msg, severity)      @abstractmethod     def write_message(self, msg):         """         Abstract method to write a message.          Args:             msg (str): Message string.          Raises:             NotImplementedError         """         raise NotImplementedError("You should implement this method.")  class ConsoleLogger(Logger):     def write_message(self, msg):         """         Overrides parent's abstract method to write to console.          Args:             msg (str): Message string.         """         print("Writing to console:", msg)  class EmailLogger(Logger):     """     Overrides parent's abstract method to send an email.      Args:         msg (str): Message string.     """     def write_message(self, msg):         print("Sending via email:", msg)  class FileLogger(Logger):     """     Overrides parent's abstract method to write a file.      Args:         msg (str): Message string.     """     def write_message(self, msg):         print("Writing to log file:", msg)  def main():     """     Building the chain of responsibility.     """     logger = ConsoleLogger([LogLevel.ALL])     email_logger = logger.set_next(         EmailLogger([LogLevel.FUNCTIONAL_MESSAGE, LogLevel.FUNCTIONAL_ERROR])     )     # As we don't need to use file logger instance anywhere later     # We will not set any value for it.     email_logger.set_next(         FileLogger([LogLevel.WARNING, LogLevel.ERROR])     )      # ConsoleLogger will handle this part of code since the message     # has a log level of all     logger.message("Entering function ProcessOrder().", LogLevel.DEBUG)     logger.message("Order record retrieved.", LogLevel.INFO)      # ConsoleLogger and FileLogger will handle this part since file logger     # implements WARNING and ERROR     logger.message(         "Customer Address details missing in Branch DataBase.",         LogLevel.WARNING     )     logger.message(         "Customer Address details missing in Organization DataBase.",         LogLevel.ERROR     )      # ConsoleLogger and EmailLogger will handle this part as they implement     # functional error     logger.message(         "Unable to Process Order ORD1 Dated D1 for customer C1.",         LogLevel.FUNCTIONAL_ERROR     )     logger.message("OrderDispatched.", LogLevel.FUNCTIONAL_MESSAGE)  if __name__ == "__main__":     main()