unit FPolicyView;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes,
  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, VirtualTrees,
  System.ImageList, Vcl.ImgList, PngImageList, ManagerModel;

type
  PPolicyEnt = ^TPolicyEnt;
  TPolicyEnt = record
    sName, sVal: String;
  end;

  TFrmPolicyView = class(TFrame)
    vtList: TVirtualStringTree;
    imgList: TPngImageList;
    procedure vtListGetNodeDataSize(Sender: TBaseVirtualTree;
      var NodeDataSize: Integer);
    procedure vtListFreeNode(Sender: TBaseVirtualTree; Node: PVirtualNode);
    procedure vtListGetHint(Sender: TBaseVirtualTree; Node: PVirtualNode;
      Column: TColumnIndex; var LineBreakStyle: TVTTooltipLineBreakStyle;
      var HintText: string);
    procedure vtListGetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
      Column: TColumnIndex; TextType: TVSTTextType; var CellText: string);
    procedure vtListBeforeCellPaint(Sender: TBaseVirtualTree;
      TargetCanvas: TCanvas; Node: PVirtualNode; Column: TColumnIndex;
      CellPaintMode: TVTCellPaintMode; CellRect: TRect; var ContentRect: TRect);
    procedure vtListPaintText(Sender: TBaseVirtualTree;
      const TargetCanvas: TCanvas; Node: PVirtualNode; Column: TColumnIndex;
      TextType: TVSTTextType);
    procedure vtListNodeClick(Sender: TBaseVirtualTree;
      const HitInfo: THitInfo);
    procedure vtListGetImageIndex(Sender: TBaseVirtualTree; Node: PVirtualNode;
      Kind: TVTImageKind; Column: TColumnIndex; var Ghosted: Boolean;
      var ImageIndex: TImageIndex);
  private
    { Private declarations }
    bDetail_: Boolean;
    PrefModel_: TPrefModel;
    sEulaContent_: String;
    PoViewKind_: TPoViewKind;
    function AddEnt(pParentNode: PVirtualNode; sName, sVal: String): PVirtualNode;
  public
    { Public declarations }
    Constructor Create(aOwner: TComponent); override;

    procedure AddModePolicy(PO: TPrefModel; bClear: Boolean = false;
        bDetail: Boolean = false; bIsDef: Boolean = false);
  end;

implementation

uses
  Tocsg.VTUtil, Tocsg.Convert, DLiteInfo, Tocsg.Safe,
  ManagerService, superobject, GlobalDefine, Tocsg.Exception, Define, Condition;

resourcestring
  RS_NetConnMg = '네트워크 접속 관리';
  RS_OutBodyBlock = '아웃룩 본문 차단';
  RS_SoftBlock = '소프트웨어 차단';
  RS_IgrCaptureApp = '특정 캡쳐 APP 허용';
  RS_CapBlockApps = '캡쳐 행위 차단';
  RS_WBCapBLock = '브라우저 캡쳐 차단';
  RS_CutList = '목록만 차단';
  RS_AllowList = '목록만 허용';
  RS_UseImgWater = '이미지 워터마크 사용';
  RS_Info = '정보';
  RS_NetSecuMg = '네트워크 보안 설정';
  RS_UsbNetBlock = '유선/무선 외 네트워크 차단';
  RS_HostChangeCut = '호스트 변경 차단';
  RS_RouteChangeCut = '라우팅테이블 변경 차단';
  RS_CollectDomainLog = '브라우저 접속 관리';
  RS_DefPortCut = '기본 포트 차단';
  RS_WIFIControl = '무선 접속 제한 (WIFI)';
//  RS_Notify = '알림';
  RS_Cut = '차단';
  RS_CutAll = '차단 (전체)';
  RS_CutAdd = '차단 (신규 생성)';
  RS_PortExCut = '추가 포트 차단';
  RS_WhiteApp = '지정된 APP만 허용';
  RS_BlackApp = '지정된 APP 차단';
  RS_WhiteIP = '지정된 접속만 허용';
  RS_BlackIP = '지정된 접속 차단';
  RS_AppSecuSet = '어플리케이션 보안 설정';
  RS_AppInstCut = '소프트웨어 설치 감시';
  RS_DeviceControl = '매체 제어';
  RS_USBCut = 'USB 차단';
  RS_MTPCut = 'MTP 차단';
  RS_BlueCut = '블루투스 차단';
  RS_CdCut = 'CD/DVD 차단';
  RS_MonHardDrive = 'HARD-DRIVE 감시';
  RS_PrinterCut = '프린터 차단';
  RS_PrinterWater = '프린터 워터마크';
  RS_Log = '로그';
  RS_All = '전체';
  RS_Dept = '부서';
  RS_Person = '개인';
  RS_UrlBlock = 'URL 차단';
  RS_UrlAllow = 'URL 허용';
  RS_InfoSecuSet = '정보 보안 설정';
  RS_ClipCut = '클립보드 차단';
  RS_UseFWater = '워터마크 사용';
  RS_FWatch = '파일 변경 감시';
  RS_FCut = '파일 생성 차단';
  RS_FMask = '생성파일 마스크';
  RS_DownCut = '다운로드 폴더 차단';
  RS_WebAB = '브라우저 파일 차단';
  RS_OutAB = '아웃룩 파일 차단';
  RS_EtcProcAB = '프로세스 파일 차단';
  RS_SharedFolderBlock = '공유폴더 차단';
  RS_OpenDRM = 'DRM 열람 권한';
  RS_DecDRM = 'DRM 복호화 허용';
  RS_ModifyDRM = 'DRM 수정 권한';
  RS_AttDRM = 'DRM 외 반출차단';
  RS_BlockFdRename = '파일명 변경 차단 (경로)';
  RS_BlockFRename = '파일명 변경 차단 (파일)';
  RS_IncSub = '하위 폴더 포함';
  RS_ExcSub = '하위 폴더 미포함';
  RS_BlockExeOnly = '실행파일만 차단';
  RS_BlockNoExeOnly = '비 실행파일만 차단';
  RS_BlockAllFile = '모든 파일 차단';
  RS_ScreenLogoSet = '화면 및 클립보드 설정';
  RS_ScreenLogUse = '상시 로고 사용';
  RS_NameCut = '특정 연결만 차단';
  RS_NameAllow = '특정 연결만 허용';
  RS_WIFIPublicBlock = '암호 미사용 WIFI 차단';
  RS_ReadOnly = '읽기만';
  RS_SecuModeIf = '보안모드 조건';
  RS_AgentManager = '에이전트 관리';
  RS_ProcessExecute = '프로세스 실행';
  RS_VirtualNicActive = '가상 NIC 활성화';
  RS_IpSite = 'IP 범위 진입';
  RS_VideoMeet = '화상회의 연결';
  RS_Always = '항상';
  RS_ItHour = '특정 시간';
  RS_SecuModeBlock = '보안모드 종료시 동작';
  RS_ProcessTerminate = '프로세스 종료';
  RS_VirtualNicTerminate = '가상 NIC 종료';
  RS_NetRefresh = '네트워크 새로고침';
  RS_VulCheckBlock = '취약점 점검 및 차단';
  RS_EmpNoVerify = '사번 검증';
  RS_OsUpdateCheck = 'OS 최신 패치 점검';
//  RS_OsUpdateNoti = 'OS 최신 패치 알림';
  RS_StartupLockScreen = '시작 시 화면 잠금';
  RS_AfterTimeLock = '일정시간 뒤 잠금';
  RS_LockDef = '윈도우 기본 잠금';
  RS_LockCustom = 'QS-eCRM 잠금';
  RS_LockCustom2 = 'BSOne 잠금';
  RS_AfterTimeClose = '종료시 동작 대기 시간';
  RS_ConnectionManager = '보안모드 관리';
  RS_AllowAccess = '보안모드 허용';
  RS_TempConn = '취약 PC 보안모드 허용';
  RS_LongtTimeDisconn = '미접속 PC 차단 (90일)';
  RS_SetNoti = '알림 및 잠금 설정';
  RS_NotiPop = '알림 항목';
  RS_AllActive = '전체 활성화';
  RS_VulNoti = '취약 상태만 알림';
  RS_PolNoti = '정책 위반만 알림';
  RS_NotiCenter = '알림 센터 사용';
  RS_AfterReport = '근무 보고서 징수';
  RS_Eulasubmit = '보안서약서 징수';
  RS_Eula = '보안서약서';
  RS_DailyEula = '하루1회 서약 징구';
  RS_NoticeNoti = '공지사항 알림';
  RS_Min = '분';
  RS_PopupOnly = '팝업';
  RS_MustApp = '필수 사용 APP';
  RS_AllExt = '전체 확장자';
  RS_IncExt = '지정 확장자만';
  RS_IgrExt = '확장자 예외';
  RS_BlockAll = '전체 차단';
  RS_AllowSome = '일부 허용';
  RS_LogAll = '전체 로그';
  RS_IncBlock = '특정 연결만 차단';
  RS_IncAllow = '특정 연결만 허용';
  RS_IncPopup = '특정 연결만 팝업';
  RS_IncLog = '특정 연결만 로그';
  RS_FileCollect = '파일 수집';
  RS_IncFile = '지정 파일';
  RS_IncOnPath = '지정 경로만';
  RS_IncPath = '지정 경로 전체';
  RS_FileCollectTerm = '파일 수집 주기';
  RS_FileCollectOpt1 = '1회 수행';
  RS_FileCollectOpt2 = '매주 (요일)';
  RS_FileCollectOpt3 = '매주 (날짜)';
  RS_FileCollectOpt4 = '매월 (요일)';
  RS_FileCollectDate = '파일 수집 요청일';
  RS_FileCollectPath = '파일 수집 경로';
  RS_ExceptVpnNAllBlock = 'VPN 외 네트워크 차단';
  RS_PersonalInfoVul = '개인정보 초과 시 취약';
  RS_Gae = '개';
  RS_PiAction = '개인정보 강제 대응';
  RS_PiActionOpt1 = '보안모드 차단';
  RS_PiActionOpt2 = '파일 완전 삭제';
  RS_PiActionOpt3 = '파일 DRM 암호화';
  RS_AlramKind = '알림 종류';
  RS_AlramKind1 = '팝업 - 기본';
  RS_AlramKind2 = '팝업 - 요약';
  RS_AlramKind3 = '알림센터 사용';
  RS_AfterShutdown = '일정시간 뒤 PC 종료';

{$R *.dfm}

Constructor TFrmPolicyView.Create(aOwner: TComponent);
begin
  Inherited Create(aOwner);
  bDetail_ := false;
  PrefModel_ := nil;
  sEulaContent_ := '';
end;

procedure TFrmPolicyView.vtListBeforeCellPaint(Sender: TBaseVirtualTree;
  TargetCanvas: TCanvas; Node: PVirtualNode; Column: TColumnIndex;
  CellPaintMode: TVTCellPaintMode; CellRect: TRect; var ContentRect: TRect);
begin
  if (Sender.AbsoluteIndex(Node) mod 2) = 0 then
  begin
    TargetCanvas.Brush.Color := $F7F7F7;
    TargetCanvas.FillRect(CellRect);
  end;
end;

procedure TFrmPolicyView.vtListFreeNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode);
var
  pData: PPolicyEnt;
begin
  pData := Sender.GetNodeData(Node);
  Finalize(pData^);
end;

procedure TFrmPolicyView.vtListGetHint(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Column: TColumnIndex;
  var LineBreakStyle: TVTTooltipLineBreakStyle; var HintText: string);
begin
  HintText := vtList.Text[Node, Column];
end;

procedure TFrmPolicyView.vtListGetImageIndex(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Kind: TVTImageKind; Column: TColumnIndex;
  var Ghosted: Boolean; var ImageIndex: TImageIndex);
var
  pData: PPolicyEnt;
begin
  try
    if Column = 0 then
    begin
      case Kind of
        ikNormal,
        ikSelected :
        begin
          pData := Sender.GetNodeData(Node);
          if (pData.sName = RS_NetConnMg) or
             (pData.sName = RS_SoftBlock) or
             (pData.sName = RS_MustApp) or
           
             (pData.sName = RS_ProcessExecute) or
             (pData.sName = RS_ProcessTerminate) or
             (pData.sName = RS_IpSite) or
             (pData.sName = RS_VideoMeet) or
             (pData.sName = RS_ItHour) or
             (pData.sName = RS_AfterTimeLock) or
             (pData.sName = RS_AfterTimeClose) or
             (pData.sName = RS_Eula) or
             (pData.sName = RS_NoticeNoti) then
          begin
            ImageIndex := 0;
          end else
          if bDetail_ and (
             (pData.sName = RS_USBCut) or
             (pData.sName = RS_MTPCut) or
             (pData.sName = RS_BlueCut) or
             (pData.sName = RS_PrinterCut) or
             (pData.sName = RS_ClipCut) or
             (pData.sName = RS_PortExCut) or
             (pData.sName = RS_TempConn) or
             (pData.sName = RS_IgrCaptureApp) or
             (pData.sName = RS_BlockFdRename) or
             (pData.sName = RS_BlockFRename) or
             (pData.sName = RS_EtcProcAB)
              ) then
          begin
            ImageIndex := 0;
          end else
            ImageIndex := -1;
        end;
      end;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. vtListGetImageIndex()');
  end;
end;

procedure TFrmPolicyView.vtListGetNodeDataSize(Sender: TBaseVirtualTree;
  var NodeDataSize: Integer);
begin
  NodeDataSize := SizeOf(TPolicyEnt);
end;

procedure TFrmPolicyView.vtListGetText(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Column: TColumnIndex; TextType: TVSTTextType;
  var CellText: string);
var
  pData: PPolicyEnt;
begin
  try
    pData := Sender.GetNodeData(Node);

    case Column of
      0 : CellText := pData.sName;
      1 : CellText := pData.sVal;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. vtListGetText()');
  end;
end;

procedure TFrmPolicyView.vtListNodeClick(Sender: TBaseVirtualTree;
  const HitInfo: THitInfo);
var
  pData: PPolicyEnt;
  StrList: TStringList;
  i: Integer;
  dlg: TDlgLiteInfo;
  pt: TPoint;
  sbInfo: TScrollBarInfo;
begin
  try
    if hiOnNormalIcon in HitInfo.HitPositions then
    begin
      if PrefModel_ = nil then
        exit;

      Guard(StrList, TStringList.Create);
      pData := Sender.GetNodeData(HitInfo.HitNode);
      if pData.sName = RS_NetConnMg then
      begin
        StrList.Text := PrefModel_.NetworkBlockList;
        if (StrList.Text = '') or (pData.sVal = 'OFF') then
          StrList.Text := '(none)';
      end else
      if pData.sName = RS_SoftBlock then
      begin
        if bDetail_ then
        begin
          StrList.Add(Format('Date : %s ~ %s',
              [DateTimeToStr(PrefModel_.AppBlackDateB), DateTimeToStr(PrefModel_.AppBlackDateE)]));
          if PrefModel_.IsAppBlackTime then
            StrList.Add(Format('Hour : %d ~ %d', [PrefModel_.AppBlackTimeB, PrefModel_.AppBlackTimeE]));
        end;
        StrList.Add(PrefModel_.SoftwareListB);
      end else
      if pData.sName = RS_MustApp then
      begin
        StrList.Add(PrefModel_.SoftwareListW);
      end else
      if (pData.sName = RS_ProcessExecute) or (pData.sName = RS_ProcessTerminate) then
      begin
        StrList.Text := StringReplace(PrefModel_.VpnAppName, ';', #13#10, [rfReplaceAll]);
      end else
      if pData.sName = RS_IpSite then
      begin
        StrList.Text := PrefModel_.VpnIpList;
      end else
      if pData.sName = RS_VideoMeet then
      begin
        var sList := gMgSvc.PrefModel.VpnRcAppList;
        if sList <> '' then
        begin
          if sList.Contains('zo') then
            StrList.Add('ZOOM');
          if sList.Contains('we') then
            StrList.Add('Cisco WebEx');
          if sList.Contains('wh') then
            StrList.Add('Naver WhaleOn');
          if sList.Contains('cu') then
            StrList.Add('uPrism Curix');
        end;
      end else
      if pData.sName = RS_ItHour then
      begin
        StrList.Text := PrefModel_.VpnHour;
      end else
      if pData.sName = RS_AfterTimeLock then
      begin
        StrList.Text := IntToStr(gMgSvc.PrefModel.ForceScreenLockMin) + ' ' + RS_Min;
      end else
      if pData.sName = RS_AfterTimeClose then
      begin
        StrList.Text := IntToStr(PrefModel_.UnsafeActionsMin) + ' ' + RS_Min;
      end else
      if pData.sName = RS_Eula then
      begin
        if sEulaContent_ = '' then
          exit;

        var O: ISuperObject;
        try
          O := SO(sEulaContent_);
          if (O = nil) or (O.O['resultStr'] = nil) then
            exit;
        except
        // ...
        end;
        StrList.Add(O.O['resultStr'].S['eulatitle']);
        StrList.Add('');
        StrList.Add(StringReplace(O.O['resultStr'].S['eulacontent'], '\r\n', #13#10, [rfReplaceAll]));
      end else
      if pData.sName = RS_NoticeNoti then
      begin
        StrList.Text := StringReplace(PrefModel_.NoticeContent, 'ㅄ', #13#10, [rfReplaceAll]);
      end else
      if pData.sName = RS_USBCut then
      begin
        StrList.Add('Except Serial :');
        StrList.Add(PrefModel_.IgrUsbSerialList.Text);
        StrList.Add('Except Vender :');
        StrList.Add(PrefModel_.UsbExceptVender);
      end else
      if pData.sName = RS_BlueCut then
      begin
        StrList.Add('Except Serial, Type :');
        StrList.Add(PrefModel_.BlueExcept);
        StrList.Add('Except Vender :');
        StrList.Add(PrefModel_.BlueExceptVender);
      end else
      if pData.sName = RS_MTPCut then
      begin
        StrList.Add('Except Serial :');
        StrList.Add(PrefModel_.MtpExcept);
        StrList.Add('Except Vender :');
        StrList.Add(PrefModel_.MtpExceptVender);
      end else
      if pData.sName = RS_PrinterCut then
      begin
        StrList.Add('Except PrinterName :');
        StrList.Add(PrefModel_.Print.sPrinterExcepts);
      end else
      if pData.sName = RS_ClipCut then
      begin
        StrList.Add('Except Process :');
        StrList.Add(PrefModel_.ClipboardExceptApp);
      end else
      if pData.sName = RS_PortExCut then
      begin
        StrList.Add(PrefModel_.BlockPortList);
      end else
      if pData.sName = RS_TempConn then
      begin
        StrList.Text := IntToStr(PrefModel_.TemporaryConnMin) + ' ' + RS_Min;
      end else
      if pData.sName = RS_IgrCaptureApp then
      begin
        StrList.Add(PrefModel_.IgrCaptureApps);
      end else
      if pData.sName = RS_BlockFdRename then
      begin
        StrList.Add(PrefModel_.BlockDirFileRenames);
      end else
      if pData.sName = RS_BlockFRename then
      begin
        StrList.Add(PrefModel_.BlockFRenames);
      end else
      if pData.sName = RS_EtcProcAB then
      begin
        StrList.Add(PrefModel_.EtcABApps);
      end;

      StrList.Text := Trim(StrList.Text);
      if StrList.Text = '' then
        StrList.Text := '(none)';

      dlg := TDlgLiteInfo.Create(Self);
      dlg.SetInfo(pData.sName + ' ' + RS_Info, StrList);

      pt := vtList.ClientToScreen(HitInfo.HitPoint);

      dlg.Left := pt.X - dlg.Width;
      dlg.Top := pt.Y - dlg.Height;


      ZeroMemory(@sbInfo, SizeOf(sbInfo));
      sbInfo.cbSize := SizeOf(sbInfo);
      if GetScrollBarInfo(vtList.Handle, Integer(OBJID_VSCROLL), sbInfo) then
        dlg.Top := dlg.Top - (sbInfo.xyThumbTop - sbInfo.dxyLineButton);

      dlg.Show;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. vtListNodeClick()');
  end;
end;

procedure TFrmPolicyView.vtListPaintText(Sender: TBaseVirtualTree;
  const TargetCanvas: TCanvas; Node: PVirtualNode; Column: TColumnIndex;
  TextType: TVSTTextType);
var
  pData: PPolicyEnt;
begin
  try
    case Column of
      0 : if Node.Parent = Sender.RootNode then TargetCanvas.Font.Style := TargetCanvas.Font.Style + [fsBold];
      1 :
      begin
        pData := Sender.GetNodeData(Node);
        if pData.sVal <> 'OFF' then
          TargetCanvas.Font.Style := TargetCanvas.Font.Style + [fsBold];
      end;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. vtListPaintText()');
  end;
end;

function TFrmPolicyView.AddEnt(pParentNode: PVirtualNode; sName, sVal: String): PVirtualNode;
var
  pData: PPolicyEnt;
begin
  case PoViewKind_ of
    pvkAll      : ;
    pvkEnabled  : if sVal = 'OFF' then exit;
    pvkDisabled : if (sVal <> '') and (sVal <> 'OFF') then exit;
  end;

  pData := VT_AddChildDataN(vtList, Result, pParentNode);
  pData.sName := sName;
  pData.sVal := sVal;
end;

procedure TFrmPolicyView.AddModePolicy(PO: TPrefModel; bClear: Boolean = false;
        bDetail: Boolean = false; bIsDef: Boolean = false);
var
  pNode, pNode2: PVirtualNode;
  sTemp: String;
  MgPO: TPrefModel;
begin
  if PO = nil then
    exit;

  try
    vtList.BeginUpdate;
    try
      if bClear then
      begin
        PrefModel_ := PO;
        VT_Clear(vtList);
      end;

      if gMgSvc.PrefModel <> nil then
        PoViewKind_ := gMgSvc.PrefModel.PoViewKind
      else
        PoViewKind_ := pvkAll;

      MgPO := gMgSvc.PrefModel;
      bDetail_ := bDetail;
      if bIsDef then
      begin
        sEulaContent_ := gMgSvc.EulaContent;
      
      // 관리 정책 표시
        pNode := AddEnt(nil, RS_AgentManager, '');

        AddEnt(pNode, RS_VulCheckBlock, BooleanToStr(MgPO.IsEnableCheck, 'ON', 'OFF'));
        AddEnt(pNode, RS_EmpNoVerify, BooleanToStr(MgPO.IsEmpVerify, 'ON', 'OFF'));
        case MgPO.OsPatchCheck of
          opcNone  : AddEnt(pNode, RS_OsUpdateCheck, 'OFF');
          opcCheck : AddEnt(pNode, RS_OsUpdateCheck, 'ON');
          opcPopup : AddEnt(pNode, RS_OsUpdateCheck, RS_PopupOnly);
          opcLog   : AddEnt(pNode, RS_OsUpdateCheck, RS_Log);
        end;
//        AddEnt(pNode, RS_OsUpdateNoti, BooleanToStr(PO.IsOsPatchPopupOnly, RS_PopupOnly, '차단'));

        AddEnt(pNode, RS_StartupLockScreen, BooleanToStr(MgPO.IsStartupScreenLock, 'ON', 'OFF'));
        case MgPO.FileCollectKind of
          fckNone         : AddEnt(pNode, RS_FileCollect, 'OFF');
          fckFile         : AddEnt(pNode, RS_FileCollect, RS_IncFile);
          fckFolder       : AddEnt(pNode, RS_FileCollect, RS_IncOnPath);
          fckFolderIncSub : AddEnt(pNode, RS_FileCollect, RS_IncPath);
        end;
        case MgPO.FileCollectPlan of
          fcpNone      : AddEnt(pNode, RS_FileCollectTerm, 'OFF');
          fcpOnce      : AddEnt(pNode, RS_FileCollectTerm, RS_FileCollectOpt1);
          fcpWeek      : AddEnt(pNode, RS_FileCollectTerm, RS_FileCollectOpt2);
          fcpMonthDate : AddEnt(pNode, RS_FileCollectTerm, RS_FileCollectOpt3);
          fcpMonthWeek : AddEnt(pNode, RS_FileCollectTerm, RS_FileCollectOpt4);
        end;
        AddEnt(pNode, RS_FileCollectDate, DateToStr(MgPO.FileCollectDate));
        AddEnt(pNode, RS_FileCollectPath, MgPO.TgFileCollect);

        pNode := AddEnt(nil, RS_ConnectionManager, '');
        sTemp := MgPO.VpnMethod;
        if (sTemp <> '') and not sTemp.Contains('false;false;false;false;false;false') then
        begin
          if MgPO.IsVpnAndCondition then
            pNode2 := AddEnt(pNode, RS_SecuModeIf + ' (AND)', '')
          else
            pNode2 := AddEnt(pNode, RS_SecuModeIf + ' (OR)', '');

          AddEnt(pNode2, RS_ProcessExecute, BooleanToStr(sTemp.Contains('app'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_VirtualNicActive, BooleanToStr(sTemp.Contains('nic'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_IpSite, BooleanToStr(sTemp.Contains('ip'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_VideoMeet, BooleanToStr(sTemp.Contains('rc'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_Always, BooleanToStr(sTemp.Contains('time'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_ItHour, BooleanToStr(sTemp.Contains('hour'), 'ON', 'OFF'));
        end else
          AddEnt(pNode, RS_SecuModeIf, 'OFF');

        sTemp := MgPO.UnsafeActions;
        if (sTemp <> '') and not sTemp.Contains('false;false;false') then
        begin
          pNode2 := AddEnt(pNode, RS_SecuModeBlock, '');
          AddEnt(pNode2, RS_ProcessTerminate, BooleanToStr(sTemp.Contains('app'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_VirtualNicTerminate, BooleanToStr(sTemp.Contains('vnic'), 'ON', 'OFF'));
          AddEnt(pNode2, RS_NetRefresh, BooleanToStr(sTemp.Contains('net'), 'ON', 'OFF'));
        end else
          AddEnt(pNode, RS_SecuModeBlock, 'OFF');
        AddEnt(pNode, RS_AfterTimeClose, BooleanToStr(MgPO.UnsafeActionsMin > 0, 'ON', 'OFF'));
        AddEnt(pNode, RS_AllowAccess, BooleanToStr(MgPO.IsAllowAccess, 'ON', 'OFF'));
        AddEnt(pNode, RS_TempConn, BooleanToStr(MgPO.IsTemporaryConn, 'ON', 'OFF'));
        AddEnt(pNode, RS_LongtTimeDisconn, BooleanToStr(MgPO.IsLongtimeDisconn, 'ON', 'OFF'));
        AddEnt(pNode, RS_ExceptVpnNAllBlock, BooleanToStr(MgPO.EtcNicBlock, 'ON', 'OFF'));
        if MgPO.PersonalInfoFileMax > 0 then
        begin
          AddEnt(pNode, RS_PersonalInfoVul, IntToStr(MgPO.PersonalInfoFileMax) + RS_Gae);
          case MgPO.ScanBlockKind of
            sbkNone   : AddEnt(pNode, RS_PiAction, 'OFF');
            sbkPopup  : AddEnt(pNode, RS_PiAction, RS_PopupOnly);
            sbkLog    : AddEnt(pNode, RS_PiAction, RS_Log);
            sbkDelete : AddEnt(pNode, RS_PiAction, RS_PiActionOpt2);
            sbkDrmEnc : AddEnt(pNode, RS_PiAction, RS_PiActionOpt3);
          end;
        end else
          AddEnt(pNode, RS_PiAction, 'OFF');
        AddEnt(pNode, RS_MustApp, BooleanToStr(MgPO.IsMustSecuApp, 'ON', 'OFF'));

//        AddEnt(pNode, RS_AfterReport, BooleanToStr(PO.IsUseAfterReport, 'ON', 'OFF'));
//        AddEnt(pNode, RS_Eulasubmit, BooleanToStr(PO.IsEulaSubmit, 'ON', 'OFF'));
//        if sEulaContent_ <> '' then
//        begin
//          var O: ISuperObject;
//          try
//            O := SO(sEulaContent_);
//            if (O <> nil) and (O.O['resultStr'] <> nil) then
//              AddEnt(pNode, RS_Eula, O.O['resultStr'].S['eulatitle']);
//          except;
//          // ..
//          end;
//        end else
//          AddEnt(pNode, RS_Eula, '(none)');
//        AddEnt(pNode, RS_DailyEula, BooleanToStr(PO.IsDailyEulaCheck, 'ON', 'OFF'));
//        AddEnt(pNode, RS_NoticeNoti, BooleanToStr(PO.IsNoticeEnable, 'ON', 'OFF'));

        exit;
      end;

      pNode := AddEnt(nil, RS_SetNoti, '');
      case PO.NotifyKind of
        nfkNone : AddEnt(pNode, RS_NotiPop, 'OFF');
        nfkAll  : AddEnt(pNode, RS_NotiPop, RS_AllActive);
        nfkVul  : AddEnt(pNode, RS_NotiPop, RS_VulNoti);
        nfkPol  : AddEnt(pNode, RS_NotiPop, RS_PolNoti);
      end;
      case PO.NotifyType of
        nftNormal  : AddEnt(pNode, RS_AlramKind,RS_AlramKind1);
        nftMin     : AddEnt(pNode, RS_AlramKind, RS_AlramKind2);
        nftACenter : AddEnt(pNode, RS_AlramKind, RS_AlramKind3);
      end;
      case MgPO.ScreenLockKind of
        slkNone   : AddEnt(pNode, RS_AfterTimeLock, 'OFF');
        slkDef    : AddEnt(pNode, RS_AfterTimeLock, RS_LockDef);
        slkBoth   : AddEnt(pNode, RS_AfterTimeLock, RS_LockCustom2 + ', ' + RS_LockDef);
        slkCustom :
        begin
          if IsBS1Display then
            AddEnt(pNode, RS_AfterTimeLock, RS_LockCustom2)
          else
            AddEnt(pNode, RS_AfterTimeLock, RS_LockCustom);
        end;
      end;
      if MgPO.IsForceShutdown then
        AddEnt(pNode, RS_AfterShutdown, IntToStr(MgPO.ForceShutdownMin) + RS_Min)
      else
        AddEnt(pNode, RS_AfterShutdown, 'OFF');

      pNode := AddEnt(nil, RS_NetSecuMg, '');
      AddEnt(pNode, RS_WIFIPublicBlock, BooleanToStr(PO.IsWifiPublicBlock, 'ON', 'OFF'));
//      TWifiCtrlKind = (wckNone, wckPopup, wckBlock, wckBlockName, wckWhiteName, wckLog);
      case PO.WifiCtrlKind of
        wckNone      : AddEnt(pNode, RS_WIFIControl, 'OFF');
        wckPopup     : AddEnt(pNode, RS_WIFIControl, RS_PopupOnly);
        wckBlock     : AddEnt(pNode, RS_WIFIControl, RS_Cut);
        wckBlockName : AddEnt(pNode, RS_WIFIControl, RS_NameCut);
        wckWhiteName : AddEnt(pNode, RS_WIFIControl, RS_NameAllow);
        wckLog       : AddEnt(pNode, RS_WIFIControl, RS_Log);
      end;
      AddEnt(pNode, RS_UsbNetBlock, BooleanToStr(PO.EtcNicBlock, 'ON', 'OFF'));
      AddEnt(pNode, RS_HostChangeCut, BooleanToStr(PO.HostEnable, 'ON', 'OFF'));
      AddEnt(pNode, RS_RouteChangeCut, BooleanToStr(PO.RouteEnable, 'ON', 'OFF'));
      AddEnt(pNode, RS_DefPortCut, BooleanToStr(PO.IsDefPortBlock, 'ON', 'OFF'));
      case PO.ExtraPortEnableType of
        PREF_PORTEX_FALSE : AddEnt(pNode, RS_PortExCut, 'OFF');
        PREF_PORTEX_BLACK : AddEnt(pNode, RS_PortExCut, 'Black List');
        PREF_PORTEX_WHITE : AddEnt(pNode, RS_PortExCut, 'White List');
      end;
  //    AddEnt(pNode, RS_NetConnMg, BooleanToStr(PO.HostEnable, 'ON', 'OFF'));
      case PO.WebbMonKind of
        wmkNone     : AddEnt(pNode, RS_CollectDomainLog, 'OFF');
        wmkBlock    : AddEnt(pNode, RS_CollectDomainLog, RS_BlockAll);
        wmkLog      : AddEnt(pNode, RS_CollectDomainLog, RS_LogAll);
        wmkIncBlock : AddEnt(pNode, RS_CollectDomainLog, RS_IncBlock);
        wmkIncAllow : AddEnt(pNode, RS_CollectDomainLog, RS_IncAllow);
        wmkIncPop   : AddEnt(pNode, RS_CollectDomainLog, RS_IncPopup);
        wmkIncLog   : AddEnt(pNode, RS_CollectDomainLog, RS_IncLog);
      end;
      if (PO.NetworkBlockType = '') or
         (PO.NetworkBlockType.ToLower = 'false') then
      begin
        AddEnt(pNode, RS_NetConnMg, 'OFF');
      end else
      if PO.NetworkBlockType = PREF_NETAPP_WHITELIST then
      begin
        AddEnt(pNode, RS_NetConnMg, RS_WhiteApp);
      end else
      if PO.NetworkBlockType = PREF_NETAPP_BLACKLIST then
      begin
        AddEnt(pNode, RS_NetConnMg, RS_BlackApp);
      end else
      if PO.NetworkBlockType = PREF_NETIP_WHITELIST then
      begin
        AddEnt(pNode, RS_NetConnMg, RS_WhiteIP);
      end else
      if PO.NetworkBlockType = PREF_NETIP_BLACKLIST then
      begin
        AddEnt(pNode, RS_NetConnMg, RS_BlackIP);
      end;
      if PO.OutPo.bActive then
        AddEnt(pNode, RS_OutBodyBlock, BooleanToStr(PO.OutPo.bBlock, RS_BlockAll, RS_Log))
      else
        AddEnt(pNode, RS_OutBodyBlock, 'OFF');

      pNode := AddEnt(nil, RS_AppSecuSet, '');
      case PO.AppInstKind of
        aikNone  : AddEnt(pNode, RS_AppInstCut, 'OFF');
        aikBlock : AddEnt(pNode, RS_AppInstCut, 'ON');
        aikPopup : AddEnt(pNode, RS_AppInstCut, RS_PopupOnly);
        aikLog   : AddEnt(pNode, RS_AppInstCut, RS_Log);
      end;
      AddEnt(pNode, RS_SoftBlock, BooleanToStr(PO.IsBlockApp, 'ON', 'OFF'));

      pNode := AddEnt(nil, RS_DeviceControl, '');
      case PO.Print.PrintKind of
        pkNone  : AddEnt(pNode, RS_PrinterCut, 'OFF');
        pkBlock : AddEnt(pNode, RS_PrinterCut, 'ON');
        pkLog   :
        begin
          if PO.Print.bPopup then
            AddEnt(pNode, RS_PrinterCut, RS_PopupOnly)
          else
            AddEnt(pNode, RS_PrinterCut, RS_Log);
        end;
//        pkWater : AddEnt(pNode, RS_PrinterCut, RS_UseFWater);
      end;
      AddEnt(pNode, RS_PrinterWater, BooleanToStr(PO.Print.PrintWater = pwActive, 'ON', 'OFF'));
      case PO.UsbBlockKind of
        ubkNone     : AddEnt(pNode, RS_USBCut, 'OFF');
        ubkBlock    : AddEnt(pNode, RS_USBCut, 'ON');
        ubkReadOnly : AddEnt(pNode, RS_USBCut, RS_ReadOnly);
        ubkLog      :
        begin
          if PO.USBPopup then
            AddEnt(pNode, RS_USBCut, RS_PopupOnly)
          else
            AddEnt(pNode, RS_USBCut, RS_Log);
        end;
      end;
      case PO.MtpBlockKind of
        ubkNone     : AddEnt(pNode, RS_MTPCut, 'OFF');
        ubkBlock    : AddEnt(pNode, RS_MTPCut, 'ON');
        ubkReadOnly : AddEnt(pNode, RS_MTPCut, RS_ReadOnly);
        ubkLog      :
        begin
          if PO.MTPPopup then
            AddEnt(pNode, RS_MTPCut, RS_PopupOnly)
          else
            AddEnt(pNode, RS_MTPCut, RS_Log);
        end;
      end;
      case PO.BlueBlockKind of
        dbkNone     : AddEnt(pNode, RS_BlueCut, 'OFF');
        dbkBlock    : AddEnt(pNode, RS_BlueCut, 'ON');
        dbkLog      :
        begin
          if PO.BTPopup then
            AddEnt(pNode, RS_BlueCut, RS_PopupOnly)
          else
            AddEnt(pNode, RS_BlueCut, RS_Log);
        end;
      end;
      case PO.CdromBlockKind of
        dbkNone     : AddEnt(pNode, RS_CdCut, 'OFF');
        dbkBlock    : AddEnt(pNode, RS_CdCut, 'ON');
        _dbkPopup : AddEnt(pNode, RS_CdCut, RS_PopupOnly);
        dbkLog      : AddEnt(pNode, RS_CdCut, RS_Log);
      end;
      AddEnt(pNode, RS_MonHardDrive, BooleanToStr(PO.DetectFixedDisk, 'ON', 'OFF'));

      pNode := AddEnt(nil, RS_InfoSecuSet, '');
      case PO.WebbAB.Kind of
        abkNone  : AddEnt(pNode, RS_WebAB, 'OFF');
        abkBlock : AddEnt(pNode, RS_WebAB, 'ON');
//        abkPopup : AddEnt(pNode, RS_WebAB, RS_PopupOnly);
        abkLog   :
        begin
          if PO.WebbAB.bPopup then
            AddEnt(pNode, RS_WebAB, RS_PopupOnly)
          else
            AddEnt(pNode, RS_WebAB, RS_Log);
        end;
        abkUrlBlock : AddEnt(pNode, RS_WebAB, RS_UrlBlock);
        abkUrlAllow : AddEnt(pNode, RS_WebAB, RS_UrlAllow);
      end;

      case PO.OutlookAB.Kind of
        abkNone  : AddEnt(pNode, RS_OutAB, 'OFF');
        abkBlock : AddEnt(pNode, RS_OutAB, 'ON');
//        abkPopup : AddEnt(pNode, RS_OutAB, RS_PopupOnly);
        abkLog   :
        begin
          if PO.OutlookAB.bPopup then
            AddEnt(pNode, RS_OutAB, RS_PopupOnly)
          else
            AddEnt(pNode, RS_OutAB, RS_Log);
        end;
      end;

      case PO.EtcAB.Kind of
        abkNone  : AddEnt(pNode, RS_EtcProcAB, 'OFF');
        abkBlock : AddEnt(pNode, RS_EtcProcAB, 'ON');
//        abkPopup : AddEnt(pNode, RS_EtcProcAB, RS_PopupOnly);
        abkLog   :
        begin
          if PO.EtcAB.bPopup then
            AddEnt(pNode, RS_EtcProcAB, RS_PopupOnly)
          else
            AddEnt(pNode, RS_EtcProcAB, RS_Log);
        end;
      end;

      case PO.BlockFdRename of
        bdrFalse : AddEnt(pNode, RS_BlockFdRename, 'OFF');
        bdrAll   : AddEnt(pNode, RS_BlockFdRename, RS_IncSub);
        bdrThis  : AddEnt(pNode, RS_BlockFdRename, RS_ExcSub);
        bdrPopup : AddEnt(pNode, RS_BlockFdRename, RS_PopupOnly);
        bdrLog   : AddEnt(pNode, RS_BlockFdRename, RS_Log);
      end;
      case PO.BlockFRename of
        bfrFalse : AddEnt(pNode, RS_BlockFRename, 'OFF');
        bfrAll   : AddEnt(pNode, RS_BlockFRename, RS_BlockAllFile);
        bfrExe   : AddEnt(pNode, RS_BlockFRename, RS_BlockExeOnly);
        bfrNoExe : AddEnt(pNode, RS_BlockFRename, RS_BlockNoExeOnly);
        bfrPopup : AddEnt(pNode, RS_BlockFRename, RS_PopupOnly);
        bfrLog   : AddEnt(pNode, RS_BlockFRename, RS_Log);
      end;
      case PO.FileMon.Kind of
        fmkNone   : AddEnt(pNode, RS_FWatch, 'OFF');
        fmkAll    : AddEnt(pNode, RS_FWatch, RS_AllExt);
        fmkIncExt : AddEnt(pNode, RS_FWatch, RS_IncExt);
        fmkIgrExt : AddEnt(pNode, RS_FWatch, RS_IgrExt);
      end;
      case PO.FileBlock.Kind of
        fmkNone   : AddEnt(pNode, RS_FCut, 'OFF');
        fmkAll    : AddEnt(pNode, RS_FCut, RS_AllExt);
        fmkIncExt : AddEnt(pNode, RS_FCut, RS_IncExt);
        fmkIgrExt : AddEnt(pNode, RS_FCut, RS_IgrExt);
      end;
      AddEnt(pNode, RS_FMask, BooleanToStr(PO.IsMasking, 'ON', 'OFF'));
      AddEnt(pNode, RS_DownCut, BooleanToStr(PO.IsPreventDownloads, 'ON', 'OFF'));
      case PO.ShareFolder of
        sfkNone     : AddEnt(pNode, RS_SharedFolderBlock, 'OFF');
        sfkAllBlock : AddEnt(pNode, RS_SharedFolderBlock, RS_CutAll);
        sfkAddBlock : AddEnt(pNode, RS_SharedFolderBlock, RS_CutAdd);
        sfkPopup    : AddEnt(pNode, RS_SharedFolderBlock, RS_PopupOnly);
        sfkLog      : AddEnt(pNode, RS_SharedFolderBlock, RS_Log);
      end;
      case PO.DrmAccessKind of
        dakNone  : AddEnt(pNode, RS_OpenDRM, 'OFF');
        dakEmpNo : AddEnt(pNode, RS_OpenDRM, RS_Person);
        dakDept  : AddEnt(pNode, RS_OpenDRM, RS_Dept);
        dakAll   : AddEnt(pNode, RS_OpenDRM, RS_All);
      end;
      case PO.DrmModifyKind of
        dakNone  : AddEnt(pNode, RS_ModifyDRM, 'OFF');
        dakEmpNo : AddEnt(pNode, RS_ModifyDRM, RS_Person);
        dakDept  : AddEnt(pNode, RS_ModifyDRM, RS_Dept);
        dakAll   : AddEnt(pNode, RS_ModifyDRM, RS_All);
      end;
      AddEnt(pNode, RS_DecDRM, BooleanToStr(PO.IsDrmDecrypt, 'ON', 'OFF'));
      AddEnt(pNode, RS_AttDRM, BooleanToStr(PO.IsDrmAttAble, 'ON', 'OFF'));

    // 화면 및 클립보드 설정
      pNode := AddEnt(nil, RS_ScreenLogoSet, '');
      case PO.ClipBlockKind of
        cbkNone  : AddEnt(pNode, RS_ClipCut, 'OFF');
        cbkBlock : AddEnt(pNode, RS_ClipCut, 'ON');
        cbkPopup : AddEnt(pNode, RS_ClipCut, RS_PopupOnly);
        cbkLog   : AddEnt(pNode, RS_ClipCut, RS_Log);
      end;
      case PO.CapAppMonKind of
        camNone     : AddEnt(pNode, RS_IgrCaptureApp, 'OFF');
        camBlockAll : AddEnt(pNode, RS_IgrCaptureApp, RS_BlockAll);
        camIncAllow : AddEnt(pNode, RS_IgrCaptureApp, RS_AllowSome);
        camPopup    : AddEnt(pNode, RS_IgrCaptureApp, RS_PopupOnly);
        camLog      : AddEnt(pNode, RS_IgrCaptureApp, RS_Log);
      end;
      AddEnt(pNode, RS_CapBlockApps, BooleanToStr(PO.bCaptureBlockApps_, 'ON', 'OFF'));
      case PO.CaptureBlockUrlKind of
        bkNone  : AddEnt(pNode, RS_WBCapBLock, 'OFF');
        bkBlack : AddEnt(pNode, RS_WBCapBLock, RS_CutList);
        bkWhite : AddEnt(pNode, RS_WBCapBLock, RS_AllowList);
        bkAll   :
        begin
          AddEnt(pNode, RS_WBCapBLock, RS_Cut);
        end;
      end;
//      AddEnt(pNode, RS_UseImgWater, BooleanToStr(PO.bCaptureBlockApps_, 'ON', 'OFF'));

      AddEnt(pNode, RS_UseImgWater, BooleanToStr(PO.IsWaterMark, 'ON', 'OFF'));
      AddEnt(pNode, RS_ScreenLogUse, BooleanToStr(PO.ScreenLogo <> askNone, 'ON', 'OFF'));

      pNode := vtList.GetFirst;
      while pNode <> nil do
      begin
        pNode2 := pNode;
        pNode := pNode.NextSibling;

        if pNode2.ChildCount = 0 then
          vtList.DeleteNode(pNode2);
      end;
    finally
      if bClear then
        VT_ExpandAll(vtList, true);
        
      vtList.EndUpdate;
    end;
  except
    on E: Exception do
      ETgException.TraceException(Self, E, 'Fail .. AddModePolicy()');
  end;
end;

end.