/**
    * Copyright By Grandsoft Company Limited.  
    * 2012-3-27 下午08:37:50
    */
   package gboat2.base.core.validate;
   
   import gboat2.base.core.Activator;
   
   import java.util.List;
  import java.util.Map;
  import java.util.concurrent.CopyOnWriteArrayList;
  
  import org.osgi.framework.Bundle;
  import org.osgi.framework.BundleContext;
  import org.osgi.framework.Filter;
  import org.osgi.framework.InvalidSyntaxException;
  import org.osgi.framework.ServiceReference;
  import org.osgi.util.tracker.ServiceTracker;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * 注册 PrivilegeCheckService 服务实现
   * 
   * @author zhaic
   * @since 1.0
   * @date 2012-3-27
   */
  
  public class PrivilegeCheckServiceFactory {
  
      private static Logger logger = LoggerFactory.getLogger(PrivilegeCheckServiceFactory.class);
  
      private static ServiceTracker<IOperaPrivilegeCheckService, IOperaPrivilegeCheckService> operaPriviTracker;
  
      private static ServiceTracker<IDataPrivilegeCheckService, IDataPrivilegeCheckService> dataPriviTracker;
  
      /**
       * 操作权限判断服务
       */
      private static List<IOperaPrivilegeCheckService> priCheckSerList = new CopyOnWriteArrayList<IOperaPrivilegeCheckService>();
  
      /**
       * 数据权限判断服务
       */
      private static List<IDataPrivilegeCheckService> dataPriCheckSerList = new CopyOnWriteArrayList<IDataPrivilegeCheckService>();
  
      public PrivilegeCheckServiceFactory() {
          BundleContext context = Activator.LOCAL_BUNDLE.getBundleContext();
          try {
              Filter operaFilter = context.createFilter("(objectClass=gboat2.base.core.validate.IOperaPrivilegeCheckService)");
              operaPriviTracker = new ServiceTracker<IOperaPrivilegeCheckService, IOperaPrivilegeCheckService>(context, operaFilter, null) {
                  @Override
                  public IOperaPrivilegeCheckService addingService(ServiceReference<IOperaPrivilegeCheckService> refer) {
                      IOperaPrivilegeCheckService operaPrivilege = context.getService(refer);
                      registValidateService(operaPrivilege);
                      return super.addingService(refer);
                  }
  
                  @Override
                  public void remove(ServiceReference<IOperaPrivilegeCheckService> refer) {
                      IOperaPrivilegeCheckService operaPrivilege = context.getService(refer);
                      unRegistValidateService(operaPrivilege);
                  }
              };
              operaPriviTracker.open();
          } catch (InvalidSyntaxException e) {
              logger.error("", e);
          }
  
          try {
              Filter dataFilter = context.createFilter("(objectClass=gboat2.base.core.validate.PrivilegeCheckService)");
              dataPriviTracker = new ServiceTracker<IDataPrivilegeCheckService, IDataPrivilegeCheckService>(
                      Activator.LOCAL_BUNDLE.getBundleContext(), dataFilter, null) {
  
                  @Override
                  public IDataPrivilegeCheckService addingService(ServiceReference<IDataPrivilegeCheckService> refer) {
                      IDataPrivilegeCheckService dataPrivilege =  context.getService(refer);
                      registDataValidateService(dataPrivilege);
                      return dataPrivilege;
                  }
  
                  @Override
                  public void remove(ServiceReference<IDataPrivilegeCheckService> refer) {
                      IDataPrivilegeCheckService dataPrivilege =  context.getService(refer);
                      unRegistDataValidateService(dataPrivilege);
                  }
              };
              dataPriviTracker.open();
          } catch (InvalidSyntaxException e) {
              logger.error("", e);
          }
      }
  
      public static void close() {
          if (operaPriviTracker != null) {
              operaPriviTracker.close();
          }
          if (dataPriviTracker != null) {
             dataPriviTracker.close();
         }
     }
 
     public static List<IOperaPrivilegeCheckService> getPrivilegeSerivce() {
         return priCheckSerList;
     }
 
     public static List<IDataPrivilegeCheckService> getDataPrivelegeService() {
         return dataPriCheckSerList;
     }
 
     private void registValidateService(IOperaPrivilegeCheckService priCheckSer) {
         logger.info("regist opera validate service : {}", priCheckSer.getClass().getName());
         priCheckSerList.add(priCheckSer);
     }
 
     private void unRegistValidateService(IOperaPrivilegeCheckService validateServ) {
         logger.info("unregist opera validate service : {}", validateServ.getClass().getName());
         priCheckSerList.remove(validateServ);
     }
 
     private void registDataValidateService(IDataPrivilegeCheckService validateServ) {
         logger.info("regist data validate service : {}", validateServ.getClass().getName());
         dataPriCheckSerList.add(validateServ);
     }
 
     private void unRegistDataValidateService(IDataPrivilegeCheckService validateServ) {
         logger.info("unregist data validate service : {}", validateServ.getClass().getName());
         dataPriCheckSerList.remove(validateServ);
     }
 
     /**
      * 循环判断是否具有该操作
      * 
      * @param params 操作集合
      * @param bd 当前bundle实例
      * @return 权限验证 有权限 返回 true 否则 false
      */
     public static boolean operationCheckServiceByMethodCode(Map<?, ?> params) {
         for (IOperaPrivilegeCheckService tempCheckSer : priCheckSerList) {
             if (!tempCheckSer.privilegeCheckServiceByMethodCode(params, null))
                 return Boolean.FALSE;
         }
         return Boolean.TRUE;
     }
 
     /**
      * 循环判断是否具有该操作
      * 
      * @param params 操作集合
      * @param bd 当前bundle实例
      * @return 权限验证 有权限 返回 true 否则 false
      */
     public static boolean operationCheckServiceByMethodName(Map<?, ?> params, Bundle bd) {
         for (IOperaPrivilegeCheckService tempCheckSer : priCheckSerList) {
             if (!tempCheckSer.privilegeCheckServiceByMethodName(params, bd))
                 return Boolean.FALSE;
         }
         return Boolean.TRUE;
     }
 
     public static boolean operationDataCheckService(Map<?, ?> params, Bundle bd) {
         for (IDataPrivilegeCheckService tempCheckSer : dataPriCheckSerList) {
             if (!tempCheckSer.privilegeCheckServiceByMethodName(params, bd))
                 return Boolean.FALSE;
         }
         return Boolean.TRUE;
     }
 }