un_treemenu.~pas

信息系统工作核心代码,若要具体可以联系我,这只是一部分核心代码,大家一起交流分享.谢谢

unit Un_TreeMenu;

interface

uses
  classes, ComCtrls, Un_TreeRes, db, dbtables, SysUtils, Un_DAO;

type
  TNodeData=class
  private
    FChildren: TList;
  public
    Id: Integer;
    Caption: string;
    IsFunction: Boolean;
    FunctionStr: String;
    ImageIndex: Integer;
    ThisNode: TTreeNode;
    property Children: TList read FChildren;
    constructor Create;
    destructor Destroy; override;
  end;

  TNodeDataCollection=class
  private
    FList: TList;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(NodeData: TNodeData);
    procedure Clear;
  end;

  TNodeInfoProvider=class
  private
    FDAO: TDAO;
    FNodeDataCollection: TNodeDataCollection;
    function CreateNodeData: TNodeData;
  public
    constructor Create(NodeDataCollection: TNodeDataCollection);
    destructor Destroy; override;
    function GetRootNode: TNodeData;
    function GetChildrenNode(ParentId: Integer; Children: TList): Boolean;
  end;

  TUserRolePermission=class
  private
    FDAO: TDAO;
    FPermissionRoles: TStrings;
    FUserRoles: TStrings;
    FIsSA: Boolean;
    FRoleLoaded: Boolean;
    FIsSALoaded: Boolean;
    procedure LoadUserRoles(UId: Integer);
    procedure LoadPermissionRoles(TreeId: Integer);
    procedure GetIsSA(UId: Integer);
  public
    constructor Create;
    destructor Destroy; override;
    function GetPermission(UId, TreeId: Integer): Boolean;
  end;

  TMyTreeMenu=class
  private
    FUId: Integer;
    FTreeView: TTreeView;
    FTreeResModule: TTreeResModule;
    FNodeDataCollection: TNodeDataCollection;
    FNodeInfoProvider: TNodeInfoProvider;
    FUserRolePermission: TUserRolePermission;
    procedure MakeChildNodes(Parent: TTreeNode);
    procedure SetTreeNode(Node: TTreeNode; Data: TNodeData);
    function GetSelected: TTreeNode;
    procedure SetSelected(const Value: TTreeNode);
  public
    constructor Create(ATreeView: TTreeView);
    destructor Destroy; override;
    procedure FullCollapse;
    procedure FullExpand;
    procedure MakeTree(UId: Integer);
    procedure FreeTree;
    function GetSelectedNodeData: TNodeData;
    procedure ShowCurrentNodeChilds(AListView: TListView);
    property Selected: TTreeNode read GetSelected write SetSelected;
  end;

implementation
uses
  publics;
const
  FCLOSE_IMG_INDEX = 0;
  FOPEN_IMG_INDEX  = 1;

{ TNodeDataCollection }

procedure TNodeDataCollection.Add(NodeData: TNodeData);
begin
  FList.Add( NodeData);
end;

procedure TNodeDataCollection.Clear;
var
  i:integer;
begin
  for i:= 0 to FList.Count-1  do begin
    TNodeData(FList.Items[i]).Free;
  end;
  FList.Clear;
end;

constructor TNodeDataCollection.Create;
begin
  FList:= TList.Create;
end;

destructor TNodeDataCollection.Destroy;
begin
  Clear;
  FList.Free;
  inherited;
end;

{ TMyTreeMenu }

constructor TMyTreeMenu.Create(ATreeView: TTreeView);
begin
  FTreeView:= ATreeView;
  FTreeResModule:= TTreeResModule.Create(nil);
  FTreeView.Images:= FTreeResModule.ImageList1;
  FNodeDataCollection:= TNodeDataCollection.Create;
  FNodeInfoProvider:= TNodeInfoProvider.Create(FNodeDataCollection);
  FUserRolePermission:= TUserRolePermission.Create;
end;

destructor TMyTreeMenu.Destroy;
begin
  FTreeResModule.Free;
  FNodeDataCollection.Free;
  FNodeInfoProvider.Free;
  FUserRolePermission.Free;
  inherited;
end;

procedure TMyTreeMenu.FreeTree;
begin
  FTreeView.Items.BeginUpdate;
  try
    FNodeDataCollection.Clear;
    FTreeView.Items.Clear;
  finally
    FTreeView.Items.EndUpdate;
  end;
end;

procedure TMyTreeMenu.FullCollapse;
begin
  FTreeView.FullCollapse;
end;

procedure TMyTreeMenu.FullExpand;
begin
  FTreeView.FullExpand;
end;

function TMyTreeMenu.GetSelected: TTreeNode;
begin
  Result:= FTreeView.Selected;
end;

function TMyTreeMenu.GetSelectedNodeData: TNodeData;
begin
  Result:= TNodeData(Selected.Data)
end;

procedure TMyTreeMenu.MakeChildNodes(Parent: TTreeNode);
var
  i: Integer;
  Data, ChildData: TNodeData;
  Node: TTreeNode;
begin
  Data:= TNodeData(Parent.Data);
  FNodeInfoProvider.GetChildrenNode(Data.Id, Data.Children);
  for i:=0 to Data.Children.Count-1 do begin
    ChildData:= TNodeData(Data.Children.Items[i]);
    if not ChildData.IsFunction then begin
      if FUserRolePermission.GetPermission(FUId, ChildData.Id) then begin
        Node:= FTreeView.Items.AddChild(Parent, ChildData.Caption);
        SetTreeNode(Node, ChildData);
        MakeChildNodes(Node);
      end;
    end;
  end;
end;

procedure TMyTreeMenu.MakeTree(UId: Integer);
var
  Node: TTreeNode;
  Data: TNodeData;
begin
  FUId:= UId;
  FreeTree;
  Data:= FNodeInfoProvider.GetRootNode;
  try
    FTreeView.Items.BeginUpdate;
    try
      Node:= FTreeView.Items.AddChild(nil, Data.Caption);
      SetTreeNode(Node, Data);
      MakeChildNodes(Node);
      Node.Expand(false);
    finally
      FTreeView.Items.EndUpdate;
    end;
  except
    FTreeview.Invalidate;
    raise;
  end;
end;

procedure TMyTreeMenu.SetSelected(const Value: TTreeNode);
begin
  FTreeView.Selected:= Value;
end;

procedure TMyTreeMenu.SetTreeNode(Node: TTreeNode; Data: TNodeData);
begin
  Data.ThisNode:= Node;
  Node.Data:= Data;
  Node.ImageIndex:= FCLOSE_IMG_INDEX;
  Node.SelectedIndex:= FOPEN_IMG_INDEX;
end;

procedure TMyTreeMenu.ShowCurrentNodeChilds(AListView: TListView);
var
  PData,Data: TNodeData;
  i: Integer;
  NewItem: TListItem;
begin
  AListView.LargeImages:= FTreeResModule.ImageList1;
  PData:= TNodeData(FTreeView.Selected.Data);
  //重新LOAD
  //FNodeInfoProvider.GetChildrenNode(PData.Id, PData.Children);
  AListView.Items.BeginUpdate;
  try
    AListView.Items.Clear;
    for i:= 0 to PData.Children.Count-1 do begin
      Data:= TNodeData(PData.Children.Items[i]);
      if FUserRolePermission.GetPermission(FUId, Data.Id) then begin
        NewItem := AListView.Items.Add;
        NewItem.Data:= Data;
        NewItem.Caption := Data.Caption;
        NewItem.ImageIndex:= Data.ImageIndex;
      end;  
    end;
  finally
    AListView.Items.EndUpdate;
  end;
end;

{ TNodeData }

constructor TNodeData.Create;
begin
  FChildren:= TList.Create;
end;

destructor TNodeData.Destroy;
begin
  FChildren.Free;
  inherited;
end;

{ TNodeInfoProvider }

constructor TNodeInfoProvider.Create(NodeDataCollection: TNodeDataCollection);
begin
  FDAO:= TDAO.Create;
  FNodeDataCollection:= NodeDataCollection;
end;

function TNodeInfoProvider.CreateNodeData: TNodeData;
var
  NodeData: TNodeData;
begin
  NodeData:= TNodeData.Create;
  with FDAO.ResultSet do begin
    NodeData.Id          := FieldByName('Id').AsInteger;
    NodeData.Caption     := FieldByName('Caption').AsString;
    NodeData.IsFunction  := FieldByName('IsFunction').AsInteger=1;
    NodeData.FunctionStr := FieldByName('FunctionStr').AsString;
    NodeData.ImageIndex  := FieldByName('ImageIndex').AsInteger;
  end;
  Result:= NodeData;
end;

destructor TNodeInfoProvider.Destroy;
begin
  FDAO.Free;
  inherited;
end;

function TNodeInfoProvider.GetChildrenNode(ParentId: Integer;
  Children: TList): Boolean;
var
  NodeData: TNodeData;
begin
  FDAO.SQL:= 'Select * From Tree Where ParentId='+IntToStr(ParentId)+' Order By SeqNo';
  FDAO.ExecuteQuery;
  with FDAO.ResultSet do begin
    First;
    Children.Clear;
    while not Eof do begin
      NodeData:= CreateNodeData;
      FNodeDataCollection.Add(NodeData);
      Children.Add(NodeData);
      Next;
    end;
    if Eof and Bof then
      Result:= False
    else
      Result:= True;
  end;
  FDAO.Close;
end;

function TNodeInfoProvider.GetRootNode: TNodeData;
var
  NodeData: TNodeData;
begin
  FDAO.SQL:= 'Select * From Tree Where ParentId=-1';
  FDAO.ExecuteQuery;
  if FDAO.ResultSet.Eof And FDAO.ResultSet.Bof then
    raise Exception.Create('tree no root');
  NodeData:= CreateNodeData;
  FNodeDataCollection.Add(NodeData);
  FDAO.Close;
  Result:= NodeData;
end;

{ TUserRolePermission }

constructor TUserRolePermission.Create;
begin
  FDAO:= TDAO.Create;
  FPermissionRoles:= TStringList.Create;
  FUserRoles:= TStringList.Create;
  FRoleLoaded:= False;
  FIsSALoaded:= False;
  FIsSA:= False;
end;

destructor TUserRolePermission.Destroy;
begin
  FDAO.Free;
  FUserRoles.Free;
  FPermissionRoles.Free;
  inherited;
end;

procedure TUserRolePermission.GetIsSA(UId: Integer);
begin
  if FIsSALoaded then Exit;
  FDAO.SQL:= 'Select IsSA From MyUsers Where Id='+IntToStr(UId);
  FDAO.ExecuteQuery;
  FIsSA:= FDAO.ResultSet.FieldByName('IsSA').AsInteger=1;
  FIsSALoaded:= True;
end;

function TUserRolePermission.GetPermission(UId, TreeId: Integer): Boolean;
var
  i: Integer;
begin
  Result:= False;
  GetIsSA(UId);
  if FIsSA then begin
    Result:= True;
    Exit;
  end;
  LoadUserRoles(UId);
  LoadPermissionRoles(TreeId);
  if (FUserRoles.Count=0) or (FPermissionRoles.Count=0) then begin
    Result:= False;
  end
  else begin
    for i:= 0 to FUserRoles.Count-1 do begin
      if FPermissionRoles.IndexOf(FUserRoles.Strings[i])<>-1 then begin
        Result:= True;
        Break;
      end;
    end;
  end;
end;

procedure TUserRolePermission.LoadPermissionRoles(TreeId: Integer);
begin
  FDAO.SQL:= 'Select RoleId From Permissions, MyRoles '
            +'Where Permissions.RoleId=MyRoles.Id and TreeId='+IntToStr(TreeId)+' '
            +'and MyRoles.Useable=1';
  FDAO.ExecuteQuery;
  FRoleLoaded:= True;
  FPermissionRoles.Clear;
  While not FDAO.ResultSet.Eof do begin
    FPermissionRoles.Add(FDAO.ResultSet.FieldByName('RoleId').AsString);
    FDAO.ResultSet.Next;
  end;
end;

procedure TUserRolePermission.LoadUserRoles(UId: Integer);
begin
  if FRoleLoaded then Exit;
  try
    FDAO.SQL:= 'Select RId From UserRole Where UId='+IntToStr(UId);
    FDAO.ExecuteQuery;
    FRoleLoaded:= True;
    FUserRoles.Clear;
    While not FDAO.ResultSet.Eof do begin
      FUserRoles.Add(FDAO.ResultSet.FieldByName('RId').AsString);
      FDAO.ResultSet.Next;
    end;
  except
    FRoleLoaded:= False;
    Raise;
  end;
end;

end.