RealICQClient/Client/Services/UsersService.pas

unit UsersService;

interface

uses
  StrUtils, SysUtils, Windows, superobject, RealICQClient, Classes, RealICQContacterTreeView,
  RealICQContacterListView, ComCtrls, BaseService, AsynResponseUserInfo, RealICQModel,
  WideStrings;

type
  

  TUsersService = class(TBaseService)
  private
    {$REGION '本地用户数据管理'}
    FUsers: TStringList;
    
    {$ENDREGION}
    {$REGION '根据部门ID获取用户简单信息'}
    procedure HandleBranchUsers(AJo: ISuperObject; ARealICQClient: TRealICQClient);
    procedure DoGettedUsersByBranchID(AServerID, ABranchID: string; AUsers: TStringList);
    {$ENDREGION}
    {$REGION '单位用户'}
    procedure HandleCompanyUsers(AJo: ISuperObject; ARealICQClient: TRealICQClient);

    {$ENDREGION}
    {$REGION '群组用户'}
    procedure HandleTeamUsers(AJo: ISuperObject; ARealICQClient: TRealICQClient);

    {$ENDREGION}
    {$region '好友'}
    /// <summary>
    ///  响应好友简单消息
    ///  协议号03
    /// </summary>
    /// <param name="AJo">{[{simple user}, {simple user}, {simple user}]}</param>
    /// <param name="ARealICQClient"></param>
    procedure HandleFriends(AJo: ISuperObject; ARealICQClient: TRealICQClient);
    /// <summary>
    ///  响应好友详细消息
    ///  协议号05
    /// </summary>
    /// <param name="AJo">{"s":"ServerID", "us":[{detail user}, {detail user}, {detail user}]}</param>
    /// <param name="ARealICQClient"></param>
    procedure HandleDetailFriends(AJo: ISuperObject; ARealICQClient: TRealICQClient);
    procedure UpdateOrAddFriends(AUsers: TStringList);


    {$ENDREGION}
    {$REGION '用户详细信息'}
    /// <summary>
    /// 响应用户详细信息
    ///  协议号00
    /// </summary>
    /// <param name="AJo">{"s":"ServerID", "us":[{detail user}, {detail user}, {detail user}]}</param>
    /// <param name="ARealICQClient"></param>
    procedure HandleUserInformations(AJo: ISuperObject; ARealICQClient: TRealICQClient);
    procedure DoReceivedUserInformations(AServerID: string; AUsers: TStringList);
    {$ENDREGION}

    constructor Create;
    procedure HandleMessage(ASender: TObject; const AData: TBytes);
    //function GetAndSaveUsersByJsons(AJo: ISuperObject; ARealICQClient: TRealICQClient): TStringList;
    procedure RequestUserInformation(ALoginName: string; ARealICQClient: TRealICQClient);

    /// <summary>
    ///  更新内存用户信息并保存到本地数据库 
    /// </summary>
    /// <param name="AJo">{"s":"ServerID","us":[{detail user},{detail user},...,{detail user}]}</param>
    /// <param name="ARealICQClient"></param>
    function InitAndSaveUsers(AJo: ISuperObject;
      ARealICQClient: TRealICQClient; AUpdateType: TUpdateUIType = uutAll): TStringList;
    procedure HandleDetailWorkmates(AJo: ISuperObject;
      ARealICQClient: TRealICQClient);
    function GetUserRemark(ALoginName: string): ISuperObject;
  public
    destructor Destroy; override;
    class function GetUsersService: TUsersService;

    procedure Init;
    procedure Uninstall;
    procedure RequestWorkmatesInfos(ALoginNames: TStrings);
    procedure RequestUserInformations(ALoginNames: TStrings; ARealICQClient: TRealICQClient); overload;
    procedure RequestUserInformations(ALoginNames: array of string; ARealICQClient: TRealICQClient); overload;
    procedure RequestUserStatus(AProtocol: Byte; AUsers: TStringList);
    procedure RequestUsersByBranchID(AServerID: string; ABranchIDs: TStrings; ARealICQClient: TRealICQClient);
    procedure RequestFriends(ARealICQClient: TRealICQClient);
    procedure RequestCompany(ARealICQClient: TRealICQClient);
    procedure RequestUserDetailByUserSimple(AProtocol: Byte; AUserSimples: TInterfaceList; ARealICQClient: TRealICQClient);
    procedure RequestUserDetailByLoginName(AProtocol: Byte; ALoginName: TInterfaceList; ARealICQClient: TRealICQClient);
    function GetOrRequestUser(ALoginName: string; ARealICQClient: TRealICQClient = nil): TRealICQUser;
    function GetUser(ALoginName: string): TRealICQUser;
    function GetMe: TRealICQUser;
    procedure DoOnReceivedUserStatus(ALoginName: string; ALoginState: TRealICQLoginState; ALeaveMessage: string);
    /// <summary>
    /// 获取用户信息
    /// </summary>
    /// <param name="ALoginNames">登录名</param>
    /// <param name="ARealICQClient"></param>
    /// <returns>所有的用户信息</returns>
    function GetOrCreateUsers(ALoginNames: TStrings; ARealICQClient: TRealICQClient = nil): TStringList;
    function GetWorkmatesAndFriends(): TStringList;
    function IsWorkmateOrFriend(ALoginName: string): Boolean;
    function RequestAndGetTeamMembers(AMembers: TStrings; ARealICQClient: TRealICQClient): TStringList;
    function IsCanSee(ALoginName: string): Boolean;

    {$REGION '更新到UI'}
    procedure DoGettedCompanyUsers(AUsers: TStringList; ABranch: string);
    procedure DoGettedFriends(AUsers: TStringList);
    procedure UpdateOrAddUsersToTreeView(AUsers: TStringList; ATreeView: TRealICQContacterTreeView; ABranchID: string = '');
    procedure UpdateUsersToTreeView(AUsers: TStringList; ATreeView: TRealICQContacterTreeView);
    procedure UpdateUserStateToTreeView(AUsers: TStringList; ATreeView: TRealICQContacterTreeView);
    procedure UpdateOrAddUsersToListView(AListView: TRealICQContacterListView; AUsers: TStringList);
    procedure UpdateUsersToListView(AListView: TRealICQContacterListView;
      AUsers: TStringList);
    procedure UpdateUserStateListView(AListView: TRealICQContacterListView; AUsers: TStringList);
    procedure UpdateListItem(AListItem: TRealICQContacterListItem;
      AUser: TRealICQUser; AShowNavBarNumeric: Boolean = True);
    procedure UpdateTreeNode(Employee: TRealICQEmployee;
      RealICQUser: TRealICQUser; AShowNavBarNumeric: Boolean = True);
    procedure UpdateFriends(AUsers: TStringList);
    procedure UpdateTeamsMembers(AUsers: TStringList);
    procedure UpdateOrAddFriend(AUser: TRealICQUser);
    {$ENDREGION}

    {$REGION '本地用户数据管理'}
    function InitAndRequestUsers(AJo: ISuperObject; ARealICQClient: TRealICQClient;
      ARequestRealTime: Boolean = True; ANeedRequestUsers: TStringList = nil): TStringList;
    function GetOrCreateUser(ALoginName: string; ARealICQClient: TRealICQClient): TRealICQUser;
    procedure AddMoreUser(AUser: TRealICQUser);
    {$ENDREGION}

    
  end;

const
  /// <summary>
  /// 协议$00
  /// <para>request {"s":"ServerID","us":["u1","u2",..,"un"]}</para>
  /// <para>response {"s":"ServerID","us":[{detail user},{detail user},...,{detail user}]}</para>
  /// </summary>
  USERINFO_PROLOCOL: byte = $00;
  /// <summary>
  /// 协议$01
  /// <para>request {"s":"ServerID", "bs":[b1, b2, ..., bn]}</para>
  /// <para>request {"s":"ServerID","us":["u1","u2",..,"un"]}</para>
  /// <para>response {
  /// "s":"ServerID",
  /// "bs":{
  /// "b1":[{simple user}, {simple user}, {simple user}],
  /// "b2":[{simple user}, {simple user}, {simple user}]
  /// }
  /// }</para>
  /// </summary>
  /// </summary>
  BRANCH_USERS_PROLOCOL: byte = $01;
  /// <summary>
  /// 协议$02
  /// <para>request 就一个协议头</para>
  /// <para>response
  /// {
  /// "completed":true,
  /// "bs":{
  /// "b1":[{simple user}, {simple user}, {simple user}],
  /// "b2":[{simple user}, {simple user}, {simple user}]
  /// }
  /// }</para>
  /// </summary>
  COMPANY_USERS_PROLOCOL: byte = $02;
  /// <summary>
  /// 协议$03
  /// <para>request 就一个协议头</para>
  /// <para>response
  /// {
  /// [{simple user}, {simple user}, {simple user}]
  /// }
  /// }</para>
  /// </summary>
  FRIENDS_PROLOCOL: byte = $03;
  /// <summary>
  /// 协议$04
  /// <para>request {"s":"ServerID", "us":[{simple user}, {simple user}, {simple user}]}</para>
  /// <para>response {"s":"ServerID","us":[{detail user},{detail user},...,{detail user}]}</para>
  /// </summary>
  TEAM_USER_PROLOCOL: byte = $04;
  /// <summary>
  /// 协议$05
  /// <para>request {"s":"ServerID", "us":[{simple user}, {simple user}, {simple user}]}</para>
  /// <para>response {"s":"ServerID","us":[{detail user},{detail user},...,{detail user}]}</para>
  /// </summary>
  FRIENDS_DETAIL_PROLOCOL: byte = $05;
  /// <summary>
  /// 协议$06
  /// <para>request {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// <para>response {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// </summary>
  WORKMATES_USERSTATE_PROLOCOL: byte = $06;
  /// <summary>
  /// 协议$07
  /// <para>request {"s":"ServerID","us":["u1","u2",..,"un"]}</para>
  /// <para>response {"s":"ServerID","us":[{detail user},{detail user},...,{detail user}]}</para>
  /// </summary>
  WORKMATEINFO_PROLOCOL: byte = $07;
  /// <summary>
  /// 协议$08
  /// <para>request {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// <para>response {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// </summary>
  TEAMMEMBERS_USERSTATE_PROLOCOL: byte = $08;
  /// <summary>
  /// 协议$09
  /// <para>request {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// <para>response {"s":"ServerID", "us":[{user state}, {user state},...,{user state}]}</para>
  /// </summary>
  FRIENDS_USERSTATE_PROLOCOL: byte = $09;

implementation

uses
  MainFrm, DataProviderImport, InterfaceDataProvider, LoggerImport, GIFImage,
  Messages, TalkingFrm, UserCardDetailView, SMSFrm, TeamOptionsFrm, FriendsService,
  WorkmatesService, Forms, AsynRequestUserInfo, TeamsService, UserRemarkService,
  LimitCondition, Dialogs, ConditionConfig;

var
  AUsersService: TUsersService;


procedure TUsersService.AddMoreUser(AUser: TRealICQUser);
var
  AUser1: TRealICQUSer;
begin
  if (AUser = nil) or (Auser.LoginName = '')  then
    Exit;
  AUser1 := GetUser(Auser.LoginName);
  if AUser1 <> nil then
    Exit;
  AUser1 := GetOrCreateUser(Auser.LoginName, Mainform.RealICQClient);
  AUser1.DisplayName:= AUser.DisplayName;
  AUser1.BranchID := AUser.BranchID;
  AUser1.LoginState := AUser.LoginState;
  AUser1.Tel:=AUser.Tel;
  AUser1.Mobile:=AUser.Mobile;
  AUser1.Email:=AUser.Email;
  AUser1.LeaveMessage :=AUser.LeaveMessage;
end;

constructor TUsersService.Create;
begin
  FUsers := TStringList.Create;
end;

destructor TUsersService.Destroy;
begin
  FreeStringList(FUsers);
  inherited;
end;

procedure TUsersService.DoGettedCompanyUsers(AUsers: TStringList; ABranch: string);
var
  ATreeVeiw: TRealICQContacterTreeView;
  iLoop: Integer;
begin
  ATreeVeiw := GetTreeView(LVMyContacters);
  if ATreeVeiw <> nil then     
    UpdateOrAddUsersToTreeView(AUsers, ATreeVeiw, ABranch);
end;

procedure TUsersService.DoGettedFriends(AUsers: TStringList);
begin
  TFriendsService.GetService.AddFriends(AUsers);
  UpdateOrAddFriends(AUsers);
  TFriendsService.GetService.RequestUserStatus(AUsers);
end;

procedure TUsersService.DoGettedUsersByBranchID(AServerID, ABranchID: string;
  AUsers: TStringList);
var
  ATreeView: TRealICQContacterTreeView;
begin
  if SameText(AServerID, MainForm.RealICQClient.ServerID) then
  begin
    ATreeView := GetTreeView(LVMyContacters);
    if ATreeView <> nil then
    begin
      UpdateOrAddUsersToTreeView(AUsers, ATreeView, ABranchID);
    end;
  end;

  if SameText(AServerID, MainForm.CurrentServerID) then
  begin
    ATreeView := GetTreeView(LVMoreUsers);
    if ATreeView <> nil then
    begin
      UpdateOrAddUsersToTreeView(AUsers, ATreeView, ABranchID);
    end;
  end;
end;

procedure TUsersService.DoOnReceivedUserStatus(ALoginName: string;
  ALoginState: TRealICQLoginState; ALeaveMessage: string);
var
  AUser: TRealICQUser;
begin
  AUser := GetUser(ALoginName);
  if AUser = nil then Exit;

  if (ALoginState = stMobileOnline) and (AUser.LoginState <> stOffline) then
    Exit
  else
    AUser.LoginState := ALoginState;

  AUser.LeaveMessage := ALeaveMessage;
  if (AUser.LoginState <> stOffline) and (AUser.LoginState <> stHidden) then
  begin
    AUser.GettedOffliceAutoResponseSet := False;
    AUser.OfflineAutoResponseEnabled := False;
    AUser.OfflineAutoResponseText := '';
  end;

  MainForm.RealICQClientUserInformationReady(nil, AUser);
end;

procedure TUsersService.DoReceivedUserInformations(AServerID: string;
  AUsers: TStringList);
var
  ATreeView: TRealICQContacterTreeView;
  iLoop: Integer;
  AUser: TRealICQUser;
begin
  if (AUsers = nil) or (AUsers.Count = 0) then
    Exit;
  if SameText(AServerID, MainForm.RealICQClient.ServerID) then
  begin
    ATreeView := GetTreeView(LVMyContacters);
    if ATreeView <> nil then
      UpdateUsersToTreeView(AUsers, ATreeView);
  end;

  if SameText(AServerID, MainForm.CurrentServerID) then
  begin
    ATreeView := GetTreeView(LVMoreUsers);
    if ATreeView <> nil then
    begin
      UpdateUsersToTreeView(AUsers, ATreeView);
    end;
  end;

  for iLoop := 0 to AUsers.Count - 1 do
  begin
    AUser := AUsers.Objects[iLoop] as TRealICQUser;

//    UpdateSeeInformationForm(AUser);
    UpdateTalkingForm(AUser);
    UpdateSMSForm(AUser);
    UpdateMemberInfoOfTeamOptionsForm(AUser);
    Mainform.UpdateAddrBookInfo(AUser);

    if (Length(AUser.HeadImageFile) > 0) and not FileExists(AUser.HeadImageFile) then
      MainForm.RealICQClient.SendDownloadHeadImageRequest(AUser.LoginName);
  end;

  UpdateTeamsMembers(AUsers);
  UpdateFriends(AUsers);
end;

function TUsersService.GetMe: TRealICQUser;
begin
  Result := MainForm.RealICQClient.Me;
end;

function TUsersService.GetOrCreateUser(ALoginName: string; ARealICQClient: TRealICQClient): TRealICQUser;
var
  iIndex: Integer;
  AJson: string;
begin
  ALoginName := GetLocalUID(ALoginName);
  iIndex := FUsers.IndexOf(ALoginName);
  if iIndex < 0 then
  begin
    Result := TRealICQUser.Create(ALoginName, ARealICQClient);
//    AJson := Trim(GetUsersHashProvider.Find(ALoginName));
//    if AJson <> '' then
//      InitUserObject(Result, AJson);
    FUsers.AddObject(ALoginName, Result);
    Exit;
  end;
  Result := FUsers.Objects[iIndex] as TRealICQUser;
end;

function TUsersService.IsCanSee(ALoginName: string): Boolean;
var
  isMe, isSeeRight: Boolean;
  AUser: TRealICQUser;
begin
  if not TConditionConfig.GetConfig.UserInfoController then
  begin
    Result := True;
    Exit;
  end;

  Result := False;
  AUser := GetUser(ALoginName);
  if AUser = nil then
    Exit;

  if AnsiSameText(ALoginName, MainForm.RealICQClient.LoginName) then
  begin
    Result := True;
    Exit;
  end;

  case AUser.Secret  of
    slOnlyFriendCanSee:
    begin
      Result := IsWorkmateOrFriend(ALoginName);
      Exit;
    end;
    slAllCanSee:
    begin
      Result := True;
      Exit;
    end;
    slAllCannotSee:
    begin
      Exit;
    end;
  end;
end;

function TUsersService.IsWorkmateOrFriend(ALoginName: string): Boolean;
begin
  Result := TFriendsService.GetService.IsFriend(ALoginName) or
    TWorkmatesService.GetService.IsWorkmate(ALoginName);
end;

procedure TUsersService.Init;
var
  AUsers: TWideStrings;
  i, iIndex: Integer;
  JO: ISuperObject;
  ALoginName: string;
  AUser: TRealICQUser;
begin
  MainForm.RealICQClient.OnUsersHandleMessages := HandleMessage;
  MainForm.RealICQClient.Me := GetOrCreateUser(Mainform.RealICQClient.LoginName, Mainform.RealICQClient);
  MainForm.RealICQClient.Me.LoginState := MainForm.RealICQClient.LoginState;
//  if Trim(MainForm.RealICQClient.Me.TrueName) = '' then
//    MainForm.RealICQClient.Me.TrueName := MainForm.RealICQClient.Me.DisplayName;
  
//  MainForm.RealICQClient.GetUserLoginState()
  LoggerImport.LoginName := Mainform.RealICQClient.LoginName;
  LoggerImport.Monitor;
  MainForm.ShowMeInformation;
  
  AUsers := GetUsersHashProvider.FindAll;
  for i := 0 to AUsers.Count - 1 do
  begin
    JO := SO(AUsers[I]);
    AUser := TRealICQUser.Create(ALoginName, MainForm.RealICQClient);
    InitUserObject(AUser, JO);
    ALoginName := GetLocalUID(JO.S['l']);
    FUsers.AddObject(ALoginName, AUser);
  end;
end;

function TUsersService.GetUserRemark(ALoginName: string): ISuperObject;
begin

end;

procedure TUsersService.Uninstall;
begin
  MainForm.RealICQClient.Me := nil;
  MainForm.RealICQClient.OnUsersHandleMessages := nil;
  ClearStringList(FUsers);
end;
{$REGION 'Old InitAndRequestUsers'}
//function TUsersService.InitAndRequestUsers(
//  AJo: ISuperObject;
//  ARealICQClient: TRealICQClient;
//  ARequestRealTime: Boolean = True;
//  ANeedRequestUsers: TStringList = nil): TStringList;
//var
//  AjaUsers: TSuperArray;
//  iLoop, jLoop, ALen: Integer;
//  ALoginNames: array of WideString;
//  ALoginNames2: TStrings;
//  AUsers: TKeyValues;
//  IsDownloaded: Boolean;
//  AUser: TRealICQUser;
//begin
//  Result := TStringList.Create();
//  AjaUsers := AJo.AsArray;
//  if AjaUsers.Length = 0 then
//    Exit;
//  SetLength(ALoginNames, AjaUsers.Length);
//  for iLoop := 0 to AjaUsers.Length - 1 do
//  begin
//    AjaUsers[iLoop].S['l'] := GetLocalUID(AjaUsers[iLoop].S['l']);
//    ALoginNames[iLoop] := WideString(AjaUsers[iLoop].S['l']);
//    Result.AddObject(ALoginNames[iLoop], GetOrCreateUser(ALoginNames[iLoop], ARealICQClient));
//  end;
//
//  AUsers := GetUsersHashProvider.Find(ALoginNames);
//  ALoginNames2 := TStringList.Create;
//  ALen := Length(AUsers);
//  try
//    for jLoop := 0 to ALen - 1 do
//      AUsers[jLoop][0] := GetLocalUID(AUsers[jLoop][0]);
//    for iLoop := 0 to AjaUsers.Length - 1 do
//    begin
//      AUser := GetOrCreateUser(AjaUsers[iLoop].S['l'], ARealICQClient);
//      IsDownloaded := False;
//      for jLoop := 0 to ALen - 1 do
//        if SameText(AjaUsers[iLoop].S['l'], AUsers[jLoop][0]) then
//        begin
//          IsDownloaded := True and ARequestRealTime;
//          InitUserObject(AUser, AUsers[jLoop][1]);
//          if (AjaUsers[iLoop].I['v'] <> StrToIntDef(AUsers[jLoop][2], -1)) then
//            ALoginNames2.Add(AUsers[jLoop][0])
//          else
//            IsDownloaded := True;
//          Break;
//        end;
//      AUser.IsComparedVer := True and ARequestRealTime;
//      if not IsDownloaded then
//        ALoginNames2.Add(AjaUsers[iLoop].S['l']);
//    end;
//    if not ARequestRealTime then
//    begin
//      if ANeedRequestUsers = nil then
//        Exit;
//      ANeedRequestUsers.Duplicates := dupIgnore;
//      ANeedRequestUsers.AddStrings(ALoginNames2);
//    end
//    else
//    if ALoginNames2.Count > 0 then
//      RequestUserInformations(ALoginNames2, ARealICQClient);
//  except
//    on E: Exception do
//    begin
//      Error(E.Message, 'TUsersService.InitAndRequestUsers');
//      FreeAndNil(ALoginNames2);
//    end;
//  end;
//  FreeAndNil(ALoginNames2);
//end;

{$ENDREGION}

function TUsersService.InitAndRequestUsers(
  AJo: ISuperObject;
  ARealICQClient: TRealICQClient;
  ARequestRealTime: Boolean = True;
  ANeedRequestUsers: TStringList = nil): TStringList;
var
  AjaUsers: TSuperArray;
  iLoop, jLoop, ALen: Integer;
  ALoginNames2: TStrings;
  AUsers: TStringList;
  IsDownloaded: Boolean;
  AUser: TRealICQUser;
begin
  Result := TStringList.Create();
  AjaUsers := AJo.AsArray;
  if AjaUsers.Length = 0 then
    Exit;
  try
    ALoginNames2 := TStringList.Create;
    for iLoop := 0 to AjaUsers.Length - 1 do
    begin
      AjaUsers[iLoop].S['l'] := GetLocalUID(AjaUsers[iLoop].S['l']);
      AUser := GetOrCreateUser(WideString(AjaUsers[iLoop].S['l']), ARealICQClient);
      Result.AddObject(AUser.LoginName, AUser);
      if (AUser.CurrentExInfoVersion = -1) or (AjaUsers[iLoop].I['v'] <> AUser.CurrentExInfoVersion) then
        ALoginNames2.Add(AUser.LoginName);
      AUser.IsComparedVer := True;
    end;

    if ALoginNames2.Count > 0 then
        RequestUserInformations(ALoginNames2, ARealICQClient);
  except
    on E: Exception do
    begin
      Error(E.Message, 'TUsersService.InitAndRequestUsers');
      FreeAndNil(ALoginNames2);
    end;
  end;
  FreeAndNil(ALoginNames2);
end;

function TUsersService.GetOrCreateUsers(ALoginNames: TStrings;
  ARealICQClient: TRealICQClient = nil): TStringList;
var
  iLoop, jLoop, ALen: Integer;
  AUser: TRealICQUser;
  AUsers: TKeyValues;
  ALoginNameArray: array of WideString;
  IsFound: Boolean;
begin
  if ARealICQClient = nil then
    ARealICQClient := Mainform.RealICQClient;
  

  Result := TStringList.Create;
  iLoop := 0;
  while iLoop < ALoginNames.Count do
  begin
    AUser := GetUser(ALoginNames[iLoop]);
    if AUser <> nil then
      ALoginNames.Delete(iLoop)
    else
    begin
      AUser := GetOrCreateUser(ALoginNames[iLoop], ARealICQClient);
      inc(iLoop)
    end;
    Result.AddObject(AUser.LoginName, AUser);
  end;

//  if ALoginNames.Count = 0 then
//    Exit;
//
//  SetLength(ALoginNameArray, ALoginNames.Count);
//  for iLoop := 0 to ALoginNames.Count - 1 do
//    ALoginNameArray[iLoop] := ALoginNames[iLoop];
//  AUsers := GetUsersHashProvider.Find(ALoginNameArray);
//
//  ALen := Length(AUsers);
//  for iLoop := 0 to ALen - 1 do
//    AUsers[iLoop][0] := FullLoginName(ARealICQClient.CenterServerID, ARealICQClient.ServerID, AUsers[iLoop][0]);
//
//  for iLoop := 0 to ALoginNames.Count - 1 do
//  begin
//    AUser := GetOrCreateUser(ALoginNames[iLoop], ARealICQClient);
//    for jLoop := 0 to ALen - 1 do
//      if SameText(ALoginNames[iLoop], AUsers[jLoop][0]) then
//      begin
//        InitUserObject(AUser, AUsers[jLoop][1]);
//        Break;
//      end;
//  end;
end;

function TUsersService.GetOrRequestUser(ALoginName: string;
  ARealICQClient: TRealICQClient = nil): TRealICQUser;
begin
  if ARealICQClient = nil then
    ARealICQClient := MainForm.RealICQClient;
  Result := GetOrCreateUser(ALoginName, ARealICQClient);
  if Result.IsComparedVer then
    Exit;
  Result.IsComparedVer := True;
  RequestUserInformation(ALoginName, ARealICQClient);
end;

function TUsersService.GetUser(ALoginName: string): TRealICQUser;
var
  iIndex: Integer;
begin
  Result := nil;
  ALoginName := GetLocalUID(ALoginName);
  iIndex := FUsers.IndexOf(ALoginName);
  if iIndex >= 0 then
    Result := FUsers.Objects[iIndex] as TRealICQUser;
end;

class function TUsersService.GetUsersService: TUsersService;
begin
  if AUsersService = nil then
    AUsersService := TUsersService.Create;

  Result := AUsersService;
end;

function TUsersService.GetWorkmatesAndFriends: TStringList;
var
  AUsers: TStringList;
begin
  Result := TFriendsService.GetService.GetFriends;
  AUsers := TWorkmatesService.GetService.GetWorkmates;
  try
    Result.Duplicates := dupIgnore;
    Result.AddStrings(AUsers);
  finally
    FreeAndNil(AUsers);
  end;
end;

function TUsersService.RequestAndGetTeamMembers(AMembers: TStrings;
  ARealICQClient: TRealICQClient): TStringList;
var
  AUserJos: TInterfaceList;
begin
  Result := GetOrCreateUsers(AMembers, ARealICQClient);
  AUserJos := GetSimpleUserJsons(Result);
  try
    RequestUserDetailByUserSimple(TEAM_USER_PROLOCOL, AUserJos, ARealICQClient);
  except
    on E: Exception do
      Error(E.Message, 'TUsersService.RequestAndGetTeamMembers');
  end;
end;

procedure TUsersService.RequestCompany(ARealICQClient: TRealICQClient);
begin
  PacketAndSend(COMPANY_USERS_PROLOCOL, nil, ARealICQClient);
end;

procedure TUsersService.RequestFriends(ARealICQClient: TRealICQClient);
begin
  PacketAndSend(FRIENDS_PROLOCOL, nil, ARealICQClient);
end;


//$D4 + len + $00 + jsonLen + ["user1", "user2", ... , "usern"]
procedure TUsersService.RequestUserInformations(ALoginNames: TStrings;
  ARealICQClient: TRealICQClient);
var
  AJos: TInterfaceList;
begin
  try
    AJos := GetLoginNamesJsons(ALoginNames);
    RequestUserDetailByLoginName(USERINFO_PROLOCOL, AJos, ARealICQClient);
  except
    on E: Exception do
    begin
      Error(E.Message, 'TUsersService.RequestUserInformations');
      FreeAndNil(AJos);
    end;
  end;
end;

procedure TUsersService.RequestWorkmatesInfos(ALoginNames: TStrings);
var
  AJos: TInterfaceList;
begin
  try
    AJos := GetLoginNamesJsons(ALoginNames);
    RequestUserDetailByLoginName(WORKMATEINFO_PROLOCOL, AJos, MainForm.RealICQClient);
  except
    on E: Exception do
    begin
      Error(E.Message, 'TUsersService.RequestWorkmatesInfos');
    end;
  end;
end;

procedure TUsersService.RequestUserInformation(ALoginName: string;
  ARealICQClient: TRealICQClient);
var
  ArrTmp: array[0..0] of string;
begin
  if ALoginName = '' then
    Exit;
  ArrTmp[0] := ALoginName;
  RequestUserInformations(ArrTmp, ARealICQClient);
end;

procedure TUsersService.RequestUsersByBranchID(AServerID: string; ABranchIDs: TStrings;
  ARealICQClient: TRealICQClient);
var
  iLoop, Alen: Integer;
  SendBuffer: TBytes;
  AJo: ISuperObject;
begin
  try
    if (ABranchIDs = nil) or (ABranchIDs.Count = 0) then
      Exit;
    AJo := SO();
    AJo.S['s'] := AServerID;

    for iLoop := 0 to ABranchIDs.Count - 1 do
      AJo.A['bs'].S[iLoop] := ABranchIDs[iLoop];
    PacketAndSend(BRANCH_USERS_PROLOCOL, AJo, ARealICQClient);
  except
    on E: Exception do
      Error(E.Message, 'TUsersService.RequestUsersByBranchID');
  end;
end;

procedure TUsersService.RequestUserStatus(AProtocol: Byte; AUsers: TStringList);
var
  AUserJos: TInterfaceList;
  ALen: Integer;
  AJoData, AJoData2: ISuperObject;
  AUserArray, AUserArray2: TSuperArray;
begin
  AUserJos := GetUserStatusJsons(AUsers);
  try
    while AUserJos.Count > 0 do
    begin
      AJoData := AUserJos[0] as ISuperObject;
      AUserJos.Delete(0);
      if not PacketAndSend(AProtocol, AJoData, Mainform.RealICQClient) then
      begin
        AJoData2 := SO();
        AJoData2.S['s'] := AJoData.S['s'];
        AJoData2.N['us'] := SO('[]');
        AUserArray := AJoData.A['us'];
        AUserArray2 := AJoData2.A['us'];

        ALen := AUserArray.Length div 2;
        while AUserArray.Length > ALen do
        begin
          AUserArray2.Add(AUserArray.O[0]);
          AUserArray.Delete(0);
        end;

        AUserJos.Add(AJoData2);
        AUserJos.Add(AJoData);
      end;
    end;
  except
    on E: Exception do
      Error(E.Message, 'TUsersService.RequestUserStatus');
  end;
end;

procedure TUsersService.UpdateListItem(AListItem: TRealICQContacterListItem; AUser: TRealICQUser; AShowNavBarNumeric: Boolean = True);
var
  GIFImage: TGIFImage;
  jo: IsuperObject;
  ARemarkTel,
  ARemarkMobile,
  ARemark: string;
  iIndex: Integer;
begin
  jo := TUserRemarkService.GetService.GetUserRemark(AUser.LoginName);
  if jo <> nil then
  begin
    ARemark := jo.S['Remark'];
    ARemarkTel := jo.S['Phone'];
    ARemarkMobile := jo.S['Mobile'];
  end;
  AListItem.HasCamera := AUser.InstalledCamera;
  AListItem.Watchword := AUser.Watchword;
  AListItem.LeaveMessage := AUser.LeaveMessage;
  AListItem.Branch:=AUser.Branch;
  iIndex := MainForm.ServerInfoList.IndexOf(GetServerID(AListItem.LoginName));
  if iIndex >= 0 then
    with MainForm.ServerInfoList.Objects[iIndex] as TServerInfo do
    begin
      AListItem.ServerName := ServerName;
    end;

  AListItem.HasTelephone := (Length(Trim(ARemarkTel)) > 0)
    or (Length(Trim(AUser.Tel)) > 0)
    or (Length(Trim(AUser.Mobile)) > 0);
  AListItem.TelephoneHint := '';
  if Length(Trim(ARemarkTel)) > 0 then
  begin
    AListItem.TelephoneHint := AListItem.TelephoneHint + '备注:' + Trim(ARemarkTel);
  end;

  if Length(Trim(AUser.Tel)) > 0 then
  begin
    if Length(Trim(AListItem.TelephoneHint)) > 0 then
      AListItem.TelephoneHint := AListItem.TelephoneHint + ' ';
    AListItem.TelephoneHint := AListItem.TelephoneHint + '电话:' + Trim(AUser.Tel);
  end;
    
  if Length(Trim(AUser.Mobile)) > 0 then
  begin
    if Length(Trim(AListItem.TelephoneHint)) > 0 then
      AListItem.TelephoneHint := AListItem.TelephoneHint + ' ';
    AListItem.TelephoneHint := AListItem.TelephoneHint + '手机:' + Trim(AUser.Mobile);
  end;

  AListItem.HasMobilePhone := (Length(Trim(AUser.Mobile)) > 0) or (Length(Trim(ARemarkMobile)) > 0);
  AListItem.HasEmail := (Length(Trim(AUser.Email)) > 0);
  AListItem.HasSMS := AListItem.HasMobilePhone;

  AListItem.HeadImageHint := '单击显示联系人卡片';

  if Length(Trim(ARemarkMobile)) > 0 then
    AListItem.MobilePhoneHint := Trim(ARemarkMobile)
  else
    AListItem.MobilePhoneHint := Trim(AUser.Mobile);

  AListItem.Mobile:=Trim(AUser.Mobile);
  AListItem.Tel := Trim(AUser.Tel);
  AListItem.HasMobilePhone := False;
  AListItem.MobilePhoneHint :=AListItem.MobilePhoneHint+ '(双击发送手机短信息)';
  AListItem.TelephoneHint :=AListItem.TelephoneHint;
  AListItem.EmailHint := Trim(AUser.Email) + '(双击发送邮件)';
  AListItem.SMSHint := AListItem.MobilePhoneHint;
  AListItem.CameraHint := '双击发送视频对话邀请';
  AListItem.Company := AUser.Company;
  AListItem.HasTelephone := AListItem.HasTelephone and AListItem.ListView.ShowTelButton;
  AListItem.HasMobilePhone := AListItem.HasMobilePhone and AListItem.ListView.ShowMobileButton;
  AListItem.HasEmail := AListItem.HasEmail and AListItem.ListView.ShowEmailButton;
  AListItem.HasSMS := AListItem.HasSMS and AListItem.ListView.ShowSMSButton;

  if FileExists(AUser.HeadImageFile) then
  begin
    try
      if (AUser.HeadImageFileType = htGIF) then
      begin
        GIFImage := TGIFImage.Create;
        GIFImage.Animate := False;
        try
          GIFImage.LoadFromFile(AUser.HeadImageFile);
          AListItem.HeadImagePicture.Bitmap.Assign(GIFImage);
        finally
          GIFImage.Free;
        end;
      end
      else
        AListItem.HeadImagePicture.LoadFromFile(AUser.HeadImageFile);
    except
      AListItem.HeadImagePicture.Graphic := nil;
    end;
  end
  else
    AListItem.HeadImagePicture.Graphic := nil;

  AListItem.DisplayName := AUser.DisplayName;
  AListItem.LoginState := AUser.LoginState;
  AListItem.Data := AUser;
end;

procedure TUsersService.UpdateTreeNode(Employee: TRealICQEmployee; RealICQUser: TRealICQUser; AShowNavBarNumeric: Boolean);
var
  GIFImage: TGIFImage;
  jo: IsuperObject;
  ARemarkTel,
  ARemarkMobile,
  ARemark: string;
begin
  jo := TUserRemarkService.GetService.GetUserRemark(RealICQUser.LoginName);
  if jo <> nil then
  begin
    ARemark := jo.S['Remark'];
    ARemarkTel := jo.S['Phone'];
    ARemarkMobile := jo.S['Mobile'];
  end;
  Employee.HasCamera := RealICQUser.InstalledCamera;
  Employee.Watchword := RealICQUser.Watchword;
  Employee.LeaveMessage := RealICQUser.LeaveMessage;

  Employee.HasNewSNS := ShowSNS and RealICQUser.HasNewSNSUpdate;
  Employee.NewSNSHint := '个人空间最近有更新，点击查看';

  Employee.HasTelephone := (Length(Trim(ARemarkTel)) > 0) or (Length(Trim(RealICQUser.Tel)) > 0) or (Length(Trim(RealICQUser.Mobile)) > 0);
  Employee.TelephoneHint := '';
  if Length(Trim(ARemarkTel)) > 0 then
  begin
    Employee.TelephoneHint := Employee.TelephoneHint + '备注:' + Trim(ARemarkTel);
  end;

  if Length(Trim(RealICQUser.Tel)) > 0 then
  begin
    if Length(Trim(Employee.TelephoneHint)) > 0 then
      Employee.TelephoneHint := Employee.TelephoneHint + ' ';
    Employee.TelephoneHint := Employee.TelephoneHint + '电话:' + Trim(RealICQUser.Tel);
  end;

  if Length(Trim(RealICQUser.Mobile)) > 0 then
  begin
    if Length(Trim( Employee.TelephoneHint)) > 0 then
      Employee.TelephoneHint := Employee.TelephoneHint + ' ';
    Employee.TelephoneHint := Employee.TelephoneHint + '手机:' + Trim(RealICQUser.Mobile);
  end;
       

  Employee.HasMobilePhone := False;
  Employee.HasSMS :=(Length(Trim(RealICQUser.Mobile)) > 0);

  Employee.Tel := Trim(RealICQUser.Tel);
  Employee.Mobile := Trim(RealICQUser.Mobile);


  if Length(Trim(ARemarkMobile)) > 0 then
     Employee.MobilePhoneHint := Trim(ARemarkMobile)
  else
     Employee.MobilePhoneHint :=Trim(RealICQUser.Mobile);

  Employee.HeadImageHint := '单击显示联系人卡片';
  Employee.TelephoneHint := Trim(Employee.TelephoneHint);

  Employee.AddFriendHint:='双击添加好友';

  Employee.EmailHint := Trim(RealICQUser.Email) + '(双击发送邮件)';
  Employee.SMSHint := Employee.MobilePhoneHint + '(双击发送手机短信息)';
  Employee.CameraHint := '双击发送视频对话邀请';

  if FileExists(RealICQUser.HeadImageFile) then
    begin
      try
        if (RealICQUser.HeadImageFileType = htGIF) then
        begin
          GIFImage := TGIFImage.Create;
          GIFImage.Animate := False;
          try
            GIFImage.LoadFromFile(RealICQUser.HeadImageFile);
            Employee.HeadImagePicture.Bitmap.Assign(GIFImage);
          finally
            GIFImage.Free;
          end;
        end
        else
          Employee.HeadImagePicture.LoadFromFile(RealICQUser.HeadImageFile);
      except
        Employee.HeadImagePicture.Graphic := nil;
      end;
    end
  else
      Employee.HeadImagePicture.Graphic := nil;

  Employee.DisplayName := RealICQUser.DisplayName;
  Employee.LoginState := RealICQUser.LoginState;
  Employee.Data := RealICQUser;
//    if AShowNavBarNumeric then Employee.Update;
//    if AShowNavBarNumeric then ShowNavBarNumeric;
end;

procedure TUsersService.UpdateUsersToTreeView(AUsers: TStringList;
  ATreeView: TRealICQContacterTreeView);
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQEmployee;
begin
  if ATreeView = nil then
    Exit;

  ATreeView.AdjustPosition :=False;
  ATreeView.HideSystemScrollBar;
  ATreeView.AutoChangeOnlineNumeric := True;
  ATreeView.OnItemOnline := nil;
  ATreeView.OnItemOffline := nil;

  ATreeView.BeginUpdate;
  try
    {$region '添加联系人'}
    for iLoop := AUsers.Count - 1  downto 0 do
    begin
      RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;
      ItemIndex := ATreeView.EmployeeItems.IndexOf(RealICQUser.LoginName);
      if ItemIndex >= 0 then
      begin
        Employee := ATreeView.EmployeeItems.Objects[ItemIndex] as TRealICQEmployee;
        UpdateTreeNode(Employee, RealICQUser, False);
      end;
    end;
    {$endregion}

    PostMessage(ATreeView.Handle, WM_SIZE, 0, 0);
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.UpdateTeamsMembers(AUsers: TStringList);
var
  iLoop: Integer;
begin
  for iLoop := 0 to AUsers.Count - 1 do
    TalkingFrm.UpdateTalkingForm(AUsers.Objects[iLoop] as TRealICQUser);
end;

procedure TUsersService.UpdateFriends(AUsers: TStringList);
var
  iLoop,iIndex: Integer;
  AUser: TRealICQUser;
  ATreeView: TRealICQContacterTreeView;
  AFriend: TRealICQEmployee;
begin
  iIndex:= MainForm.ContacterTreeViews.IndexOf(LvFriends);
  ATreeView := MainForm.ContacterTreeViews.Objects[iIndex] as TRealICQContacterTreeView;

  ATreeView.BeginUpdate;
  try
    for iLoop :=AUsers.Count - 1  downto 0 do
    begin
      AUser := AUsers.Objects[iLoop] as TRealICQUser;

      if AnsiSameText(AUser.LoginName, MainForm.RealICQClient.LoginName) then
         Continue;
      iIndex := ATreeView.EmployeeItems.IndexOf(AUser.LoginName);

      if (iIndex) < 0 then
        Continue;
      AFriend := ATreeView.EmployeeItems.Objects[iIndex] as TRealICQEmployee;
      UpdateTreeNode(AFriend, AUser, False);
    end;
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.UpdateOrAddFriend(AUser: TRealICQUser);
var
  iIndex: Integer;
  ATreeView: TRealICQContacterTreeView;
  AFriend: TRealICQEmployee;
begin
  iIndex:= MainForm.ContacterTreeViews.IndexOf(LvFriends);
  ATreeView := MainForm.ContacterTreeViews.Objects[iIndex] as TRealICQContacterTreeView;

  ATreeView.BeginUpdate;
  try
    if AnsiSameText(AUser.LoginName, MainForm.RealICQClient.LoginName) then
       Exit;
    iIndex := ATreeView.EmployeeItems.IndexOf(AUser.LoginName);
    if (iIndex) >= 0 then
      AFriend := ATreeView.EmployeeItems.Objects[iIndex] as TRealICQEmployee
    else
    begin
      AFriend := TRealICQEmployee.Create(AUser.LoginName);
      AFriend.BranchID :=LVFriends;
      ATreeView.AddEmployee(AFriend);
    end;

    UpdateTreeNode(AFriend, AUser, False);
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.UpdateOrAddFriends(AUsers: TStringList);
var
  iLoop,iIndex: Integer;
  AUser: TRealICQUser;
  ATreeView: TRealICQContacterTreeView;
  AFriend: TRealICQEmployee;
begin
  iIndex:= MainForm.ContacterTreeViews.IndexOf(LvFriends);
  ATreeView := MainForm.ContacterTreeViews.Objects[iIndex] as TRealICQContacterTreeView;

  ATreeView.BeginUpdate;
  try
    for iLoop :=AUsers.Count - 1  downto 0 do
    begin
      AUser := AUsers.Objects[iLoop] as TRealICQUser;

      if AnsiSameText(AUser.LoginName, MainForm.RealICQClient.LoginName) then
         Continue;
      iIndex := ATreeView.EmployeeItems.IndexOf(AUser.LoginName);
      if (iIndex) >= 0 then
        AFriend := ATreeView.EmployeeItems.Objects[iIndex] as TRealICQEmployee
      else
      begin
        AFriend := TRealICQEmployee.Create(AUser.LoginName);
        AFriend.BranchID :=LVFriends;
        ATreeView.AddEmployee(AFriend);
      end;

      UpdateTreeNode(AFriend, AUser, False);
    end;
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.UpdateOrAddUsersToListView(AListView: TRealICQContacterListView;
      AUsers: TStringList);
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQContacterListItem;
begin
  if AListView = nil then
    Exit;

  {$region '添加联系人'}
  for iLoop := AUsers.Count - 1  downto 0 do
  begin
    RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;
    ItemIndex := AListView.Items.IndexOf(RealICQUser.LoginName);
    if ItemIndex >= 0 then
    begin
      Employee := AListView.Items.Objects[ItemIndex] as TRealICQContacterListItem; 
    end
    else
    begin
      ItemIndex := AListView.Items.Add(RealICQUser.LoginName);
      Employee := AListView.Items.Objects[ItemIndex] as TRealICQContacterListItem;
    end;
    UpdateListItem(Employee, RealICQUser, False);
  end;
  {$endregion}

  PostMessage(AListView.Handle, WM_SIZE, 0, 0);
  AListView.ReDrawAll;
end;

procedure TUsersService.UpdateUserStateListView(
  AListView: TRealICQContacterListView; AUsers: TStringList);
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQContacterListItem;
begin
  if AListView = nil then
    Exit;

  for iLoop := AUsers.Count - 1  downto 0 do
  begin
    RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;
    ItemIndex := AListView.Items.IndexOf(RealICQUser.LoginName);
    if ItemIndex >= 0 then
    begin
      Employee := AListView.Items.Objects[ItemIndex] as TRealICQContacterListItem;
      Employee.LoginState := RealICQUser.LoginState;
    end;                       
  end;

  PostMessage(AListView.Handle, WM_SIZE, 0, 0);
  AListView.ReDrawAll;
end;

procedure TUsersService.UpdateUserStateToTreeView(AUsers: TStringList;
  ATreeView: TRealICQContacterTreeView);
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQEmployee;
begin
  if ATreeView = nil then
    Exit;

  ATreeView.AdjustPosition :=False;
  ATreeView.HideSystemScrollBar;
  ATreeView.AutoChangeOnlineNumeric := True;
  ATreeView.OnItemOnline := nil;
  ATreeView.OnItemOffline := nil;

  ATreeView.BeginUpdate;
  try
    {$region '添加联系人'}
    for iLoop := AUsers.Count - 1  downto 0 do
    begin
      RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;
      ItemIndex := ATreeView.EmployeeItems.IndexOf(RealICQUser.LoginName);
      if ItemIndex >= 0 then
      begin
        Employee := ATreeView.EmployeeItems.Objects[ItemIndex] as TRealICQEmployee;
        Employee.LoginState := RealICQUser.LoginState;
      end;
    end;
    {$endregion}

    PostMessage(ATreeView.Handle, WM_SIZE, 0, 0);
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.UpdateUsersToListView(AListView: TRealICQContacterListView;
      AUsers: TStringList);
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQContacterListItem;
begin
  if AListView = nil then
    Exit;

  {$region '添加联系人'}
  for iLoop := AUsers.Count - 1  downto 0 do
  begin
    RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;
    ItemIndex := AListView.Items.IndexOf(RealICQUser.LoginName);
    if ItemIndex >= 0 then
    begin
      Employee := AListView.Items.Objects[ItemIndex] as TRealICQContacterListItem; 
      UpdateListItem(Employee, RealICQUser, False);
    end;                       
  end;
  {$endregion}

  PostMessage(AListView.Handle, WM_SIZE, 0, 0);
  AListView.ReDrawAll;
end;

procedure TUsersService.UpdateOrAddUsersToTreeView(AUsers: TStringList;
  ATreeView: TRealICQContacterTreeView;
  ABranchID: string = '');
var
  iLoop,
  ItemIndex: Integer;
  RealICQUser: TRealICQUser;
  Employee: TRealICQEmployee;
  TmpBranch : TRealICQBranch;
  ParentNode: TTreeNode;
  BranchInfo: TRealICQBranchInfo;
  procedure CalculateEmployeeCount(AParentNode: TTreeNode; IsAddOnline: Boolean);
  begin
    while AParentNode <> nil do
    begin
      TmpBranch := AParentNode.Data;

      if IsAddOnline then
        TmpBranch.OnlineEmployee:=TmpBranch.OnlineEmployee + 1
      else
        TmpBranch.OnlineEmployee:=TmpBranch.OnlineEmployee - 1;
      AParentNode := AParentNode.Parent;
    end
  end;
begin
  if ATreeView = nil then
    Exit;
  if (ABranchID <> '') and (ATreeView.BranchItems.IndexOf(ABranchID) < 0) then
    Exit;

  ATreeView.AdjustPosition :=False;
  ATreeView.HideSystemScrollBar;
  ATreeView.AutoChangeOnlineNumeric := True;
  ATreeView.OnItemOnline := nil;
  ATreeView.OnItemOffline := nil;

  ATreeView.BeginUpdate;
  try
    {$region '添加联系人'}
    for iLoop := AUsers.Count - 1  downto 0 do
    begin
      RealICQUser := AUsers.Objects[iLoop] as TRealICQUser;

      ItemIndex := ATreeView.EmployeeItems.IndexOf(RealICQUser.LoginName);
      if ItemIndex >= 0 then
      begin
        Employee := ATreeView.EmployeeItems.Objects[ItemIndex] as TRealICQEmployee;
        CalculateEmployeeCount(Employee.Node.Parent,
          ((Employee.LoginState = stOffline) or (Employee.LoginState = stHidden)) and
          ((RealICQUser.LoginState <> stOffline) and (RealICQUser.LoginState <> stHidden)));
        UpdateTreeNode(Employee, RealICQUser, False);
        Continue;
      end;

      Employee := TRealICQEmployee.Create(RealICQUser.LoginName);
      if True then
      if ABranchID <> '' then
        Employee.BranchID := ABranchID
      else
        Employee.BranchID := RealICQUser.BranchID;
      Employee.HasAddFreindButton:=True;
      Employee.HasEmail := False;
      Employee.SeeInfoPermissions:=RealICQUser.SeeInfoPermissions;
      ATreeView.AddEmployee(Employee);
      ParentNode := Employee.Node.Parent;
//      if (RealICQUser.LoginState <> stOffline) and (RealICQUser.LoginState <> stHidden) then
//        CalculateEmployeeCount(Employee.Node.Parent, true);
      UpdateTreeNode(Employee, RealICQUser, False);
//      while ParentNode <> nil do
//      begin
//        TmpBranch :=ParentNode.Data;
//        TmpBranch.EmployeeCount:=TmpBranch.EmployeeCount-1;
//        if (Employee.LoginState <> stOffline) and (Employee.LoginState <> stHidden ) then
//          TmpBranch.OnlineEmployee:=TmpBranch.OnlineEmployee-1;
//        ParentNode := ParentNode.Parent;
//      end;

//      if Assigned(Employee.Node.Parent) then
//      begin
//        UpdateTreeNode(Employee, RealICQUser, False);
//        if (not Assigned(Employee.Node.Parent.Parent))
//           and (Employee.LoginState<>stOffline)
//           and  (Employee.LoginState<>stHidden ) then
//        begin
//          TmpBranch:=Employee.Node.Parent.data;
//          TmpBranch.OnlineEmployee:=TmpBranch.OnlineEmployee - 1;
//          TmpBranch.EmployeeCount:=TmpBranch.EmployeeCount - 1;
//          TmpBranch.Update;
//        end;
//      end
//      else
//      begin
//        ATreeView.EmployeeItems.Delete(ATreeView.EmployeeItems.IndexOf(RealICQUser.LoginName));
//        FreeAndNil(Employee);
//      end;
    end;
    {$endregion}

    PostMessage(ATreeView.Handle, WM_SIZE, 0, 0);
  finally
    ATreeView.EndUpdate;
  end;
end;

procedure TUsersService.HandleBranchUsers(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  joBranchs: ISuperObject;
  item: TSuperAvlEntry;
  AServerID: string;
  AUsers: TStringList;
begin
  joBranchs := AJo.O['bs'];
  AServerID := AJo.S['s'];
  for item in joBranchs.AsObject do
  begin
    try
      AUsers := InitAndRequestUsers(item.Value, ARealICQClient);
      DoGettedUsersByBranchID(AServerID, item.Name, AUsers);
    finally
      if AUsers <> nil then
        FreeAndNil(AUsers);
    end;
  end;
end;

procedure TUsersService.HandleCompanyUsers(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  AUsers: TStringList;
  IsCompleted: Boolean;
  AItem: TSuperAvlEntry;
  ABranchs: TSuperTableString;
  AEmployee: TRealICQEmployee;
  ATreeVeiw: TRealICQContacterTreeView;
  Branch: TRealICQBranch;
  ParentNode: TTreeNode;
//  AsynAction: TAsynRequestUserInfo;
begin
  IsCompleted := AJo.B['completed'];
  ABranchs := AJo.O['bs'].AsObject;
//  AsynAction := TAsynRequestUserInfo.Create;
  for AItem in ABranchs do
  begin
    try
      AUsers := InitAndRequestUsers(AItem.Value, ARealICQClient, False, TWorkmatesService.GetService.WorkmatesNeedUpdate);
      TWorkmatesService.GetService.AddWorkmates(AUsers);
      DoGettedCompanyUsers(AUsers, AItem.Name);
    except
      on E: Exception do
      begin
        Error(E.Message, 'TUsersService.HandleCompanyUsers');
        FreeAndNil(AUsers);
      end;
    end;
    FreeAndNil(AUsers);
  end;

  if IsCompleted then
  begin
    TWorkmatesService.GetService.RequstUserInfos;
    Sleep(100);

    ARealICQClient.SendDeviceChanged;
    Sleep(100);

    ARealICQClient.SendGetBlacklists;
    Sleep(100);

    ARealICQClient.SendGetWebTabs;
    Sleep(100);

    TWorkmatesService.GetService.RequestUserStatus;
    ARealICQClient.LoadPersonalConfigs;
    
    MainForm.RealICQClientGettedFriendList(nil);
    ATreeVeiw := GetTreeView(LVMyContacters);
    ATreeVeiw.OnHeadImageMouseEnter := Mainform.NodeOnHeadImageMouseEnter;
    ATreeVeiw.OnHeadImageMouseLeave := Mainform.NodeOnHeadImageMouseLeave;
    AEmployee := ATreeVeiw.GetEmployee(ARealICQClient.Me.LoginName);
    ParentNode := AEmployee.Node.Parent;
    while ParentNode <> nil do
    begin
      ParentNode.Expanded := True;
      Branch:=ParentNode.Data;
      Branch.IsGetUserList:=True;
      ParentNode := ParentNode.Parent;
    end;
    ATreeVeiw.MoveScrollBarToTop;
  end;

//  if AsynAction.Users.Count > 0 then
//    AsynAction.Resume
//  else
//    FreeAndNil(AsynAction);
end;

procedure TUsersService.HandleDetailWorkmates(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  AUsers: TStringList;
begin
  InitAndSaveUsers(AJo, ARealICQClient, uutCompany);
end;



procedure TUsersService.HandleDetailFriends(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  AUsers: TStringList;
begin
  InitAndSaveUsers(AJo, ARealICQClient, uutFriend);
//  AUsers := InitAndSaveUsers(AJo, ARealICQClient);

//  try
//    UpdateFriends(AUsers);
//  finally
//    FreeAndNil(AUsers);
//  end;
end;

procedure TUsersService.HandleFriends(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  AUserJos: TInterfaceList;
  AUsers: TStringList;
  AFriendsNeedRequest: TStrings;
begin
  AUsers := InitAndRequestUsers(AJo, ARealICQClient, False);

  try
    AUserJos := GetSimpleUserJsons(Ausers);
    RequestUserDetailByUserSimple(FRIENDS_DETAIL_PROLOCOL, AUserJos, ARealICQClient);
    DoGettedFriends(AUsers);
  finally
    FreeAndNil(AUsers);
  end;
end;

procedure TUsersService.HandleMessage(ASender: TObject; const AData: TBytes);
var
  AProtocol: Byte;
  ALen: SmallInt;
  AJson: string;
  AJo: ISuperObject;
begin
  AProtocol := AData[0];
  CopyMemory(@ALen, @AData[1], 2);
  SetLength(AJson, ALen);
  CopyMemory(PChar(AJson), @AData[3], ALen);
  if AJson = '' then
    Exit;
  try
    AJo := SO(AJson);
  except
    on E: Exception do
      Error('转化不了：'+AJson, 'TUsersService.HandleMessage');
  end;

  try
//    SUCCESS('协议：'+ IntToHex(AProtocol, 2), 'TUsersService.HandleMessage');
    case AProtocol of
      $00: HandleUserInformations(AJo, ASender as TRealICQClient);
      $01: HandleBranchUsers(AJo, ASender as TRealICQClient);
      $02: HandleCompanyUsers(AJo, ASender as TRealICQClient);
      $03: HandleFriends(AJo, ASender as TRealICQClient);
      $04: HandleTeamUsers(AJo, ASender as TRealICQClient);
      $05: HandleDetailFriends(AJo, ASender as TRealICQClient);
      $06: TWorkmatesService.GetService.HandleUsersStatus(AJo);
      $07: HandleDetailWorkmates(AJo, ASender as TRealICQClient);
      $08: TTeamsService.GetService.HandleTeamMemberssStatus(AJo);
      $09: TFriendsService.GetService.HandeFriendsState(AJo);
    end;
  except
    on E: Exception do
      Error('协议处理错误：'+ E.Message, IntToHex(AProtocol, 2));
  end;
end;

procedure TUsersService.HandleTeamUsers(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  AUsers: TStringList;
begin
  InitAndSaveUsers(AJo, ARealICQClient, uutTeam);
//  try
//    UpdateTeamsMembers(AUsers);
//  finally
//    FreeAndNil(AUsers);
//  end;
end;

function TUsersService.InitAndSaveUsers(AJo: ISuperObject;
  ARealICQClient: TRealICQClient; AUpdateType: TUpdateUIType = uutAll): TStringList;

var
  iLoop: Integer;
  joUser: ISuperObject;
  ja: TSuperArray;
  AServerid: string;
  AKeyValues: TKeyValues;
  AUser: TRealICQUser;
  AUSers: TStringList;
  ATreeView: TRealICQContacterTreeView;
  ATime: Cardinal;
  procedure UpdateDataAndUI;
  var
    jLoop: Integer;
  begin
  
    if (AUsers = nil) or (AUsers.Count = 0) then
      Exit;
    case AUpdateType of
      uutAll: ;
      uutTeam:
      begin
        AUsersService.UpdateTeamsMembers(AUsers);
        Exit;
      end;
      uutFriend:
      begin
        AUsersService.UpdateFriends(AUsers);
        Exit;
      end;
      uutCompany:
      begin
        if SameText(AServerID, MainForm.RealICQClient.ServerID) then
        begin
          ATreeView := AUsersService.GetTreeView(LVMyContacters);
          if ATreeView <> nil then
            AUsersService.UpdateUsersToTreeView(AUsers, ATreeView);
        end;
        Exit;
      end;
    end;
    
    if SameText(AServerID, MainForm.RealICQClient.ServerID) then
    begin
      ATreeView := GetTreeView(LVMyContacters);
      if ATreeView <> nil then
        UpdateUsersToTreeView(AUsers, ATreeView);
    end;

    if SameText(AServerID, MainForm.CurrentServerID) then
    begin
      ATreeView := GetTreeView(LVMoreUsers);
      if ATreeView <> nil then
        UpdateUsersToTreeView(AUsers, ATreeView);
    end;

    for jLoop := 0 to AUsers.Count - 1 do
    begin
      AUser := AUsers.Objects[jLoop] as TRealICQUser;

      UpdateSeeInformationForm(AUser.LoginName);
      UpdateTalkingForm(AUser);
      UpdateSMSForm(AUser);
      UpdateMemberInfoOfTeamOptionsForm(AUser);
      Mainform.UpdateAddrBookInfo(AUser);

      if (Length(AUser.HeadImageFile) > 0) and not FileExists(AUser.HeadImageFile) then
        MainForm.RealICQClient.SendDownloadHeadImageRequest(AUser.LoginName);
    end;

    UpdateUsersToListView(Mainform.FLVLatests, AUsers);

    UpdateTeamsMembers(AUsers);
    UpdateFriends(AUsers);
  end;
begin
  if AJo = nil then
    Exit;
  
  ja := AJo.A['us'];
  AServerid := AJo.S['s'];
  SetLength(AKeyValues, ja.Length);
  AUsers := TStringList.Create;
  for iLoop := 0 to ja.Length - 1 do
  begin
    joUser := ja[iLoop];
    if joUser.S['l'] = '' then
      Continue;
    joUser.S['l'] := TUsersService.FullLoginName(MainForm.RealICQClient.CenterServerID, AServerid, joUser.S['l']);
    AKeyValues[iLoop][0] := joUser.S['l'];
    AKeyValues[iLoop][1] := joUser.AsJSon();
    AKeyValues[iLoop][2] := IntToStr(joUser.I['v']);

    AUser := GetOrCreateUser(joUser.S['l'], MainForm.RealICQClient);
    AUser.IsComparedVer := True;
    InitUserObject(AUser, joUser);
    AUsers.AddObject(AUser.LoginName, AUser);
  end;

  try
//    ATime := GetTickCount;
    GetUsersHashProvider.Insert(AKeyValues);
//    Log(Format('SQLite插入数据耗时:%dms',[GetTickCount - ATime]), '数据库性能监控');
  except
    on E: Exception do
    begin
      Error(E.Message, 'TAsynResponseUserInfo.Execute');
      UpdateDataAndUI;
      FreeAndNil(AUsers);
    end;
  end;
//  ATime := GetTickCount;
  UpdateDataAndUI;
//  Log(Format('UI更新耗时:%dms',[GetTickCount - ATime]), 'UI性能监控');
  FreeAndNil(AUsers);
end;
//var
//  iLoop: Integer;
//  joUser: ISuperObject;
//  ja: TSuperArray;
//  AUser: TRealICQUser;
//  AKeyValues: TKeyValues;
//  AServerid: string;
//  AsynAction: TAsynResponseUserInfo;
//begin
//  ja := AJo.A['us'];
//  AServerid := AJo.S['s'];
//  if ja.Length > 5 then
//  begin
//    AsynAction := TAsynResponseUserInfo.Create;
//    AsynAction.JoUsers := AJo;
//    AsynAction.UpdateType := AUpdateType;
//    AsynAction.Resume;
//    Exit;
//  end;

//  Result := TStringList.Create;
//  SetLength(AKeyValues, ja.Length);
//  for iLoop := 0 to ja.Length - 1 do
//  begin
//    joUser := ja[iLoop];
//    if joUser.S['l'] = '' then
//      Continue;
//    joUser.S['l'] := FullLoginName(MainForm.RealICQClient.CenterServerID, AServerid, joUser.S['l']);
//    AKeyValues[iLoop][0] := joUser.S['l'];
//    AKeyValues[iLoop][1] := joUser.AsJSon();
//    AKeyValues[iLoop][2] := IntToStr(joUser.I['v']);
//    AUser := GetOrCreateUser(joUser.S['l'], ARealICQClient);
//    InitUserObject(AUser, joUser);
//    Result.AddObject(AUser.LoginName, AUser);
//  end;
//
//  GetUsersHashProvider.Insert(AKeyValues);
//end;

procedure TUsersService.HandleUserInformations(AJo: ISuperObject;
  ARealICQClient: TRealICQClient);
var
  ja: TSuperArray;
  AServerid: string;
  AUsers: TStringList;
  AsynAction: TAsynResponseUserInfo;
begin
  InitAndSaveUsers(AJo, ARealICQClient);
//  ja := AJo.A['us'];
//  AServerid := AJo.S['s'];
//  if ja.Length > 5 then
//  begin
//    AsynAction := TAsynResponseUserInfo.Create;
//    AsynAction.JoUsers := AJo;
//    AsynAction.Resume;
//    Exit;
//  end;
//  AUsers := InitAndSaveUsers(AJo, ARealICQClient);
//
//  try
//    DoReceivedUserInformations(AServerid, AUsers);
//  finally
//    FreeAndNil(AUsers);
//  end;
end;

//'{"uid":"lsyehui",
//"tel":"",
//"sex":2,
//"mob":"",
//"bid":837000001,
//"position":1,
//"secret":1,
//"v":1,
//"remark":{},  remark怎么是对象
//"showMob":true,不需要
//"uType":0,  不需要
//"Watchword":"",
//"address":null,  不需要
//"email":"",
//"branch":"",
//"sMob":"",
//"name":"\u53f6\u6167",
//"icon":"",
//"duty":"",
//"comp":"\u534f\u540c\u529e\u516c\u5c0f\u7ec4",
//"iconType":0,
//"officeID":""}'


procedure TUsersService.RequestUserDetailByLoginName(AProtocol: Byte;
  ALoginName: TInterfaceList; ARealICQClient: TRealICQClient);
var
  ALen: Integer;
  AJoData, AJoData2: ISuperObject;
  AUserArray, AUserArray2: TSuperArray;
  AUsers: TStringList;
begin
  if ALoginName = nil then
    Exit;

  while ALoginName.Count > 0 do
  begin
    AJoData := ALoginName[0] as ISuperObject;
    ALoginName.Delete(0);
    if not PacketAndSend(AProtocol, AJoData, ARealICQClient) then
    begin
      AJoData2 := SO();
      AJoData2.S['s'] := AJoData.S['s'];
      AJoData2.N['us'] := SO('[]');
      AUserArray := AJoData.A['us'];
      AUserArray2 := AJoData2.A['us'];

      ALen := AUserArray.Length div 2;
      while AUserArray.Length > ALen do
      begin
        AUserArray2.Add(AUserArray.S[0]);
        AUserArray.Delete(0);
      end;

      ALoginName.Add(AJoData2);
      ALoginName.Add(AJoData);
    end;
  end;
end;

procedure TUsersService.RequestUserDetailByUserSimple(AProtocol: Byte;
  AUserSimples: TInterfaceList; ARealICQClient: TRealICQClient);
var
  ALen: Integer;
  AJoData, AJoData2: ISuperObject;
  AUserArray, AUserArray2: TSuperArray;
  AUsers: TStringList;
begin
  if AUserSimples = nil then
    Exit;

  while AUserSimples.Count > 0 do
  begin
    AJoData := AUserSimples[0] as ISuperObject;
    AUserSimples.Delete(0);
    if not PacketAndSend(AProtocol, AJoData, ARealICQClient) then
    begin
      AJoData2 := SO();
      AJoData2.S['s'] := AJoData.S['s'];
      AJoData2.N['us'] := SO('[]');
      AUserArray := AJoData.A['us'];
      AUserArray2 := AJoData2.A['us'];

      ALen := AUserArray.Length div 2;
      while AUserArray.Length > ALen do
      begin
        AUserArray2.Add(AUserArray.O[0]);
        AUserArray.Delete(0);
      end;

      AUserSimples.Add(AJoData2);
      AUserSimples.Add(AJoData);
    end;
  end;
end;

procedure TUsersService.RequestUserInformations(ALoginNames: array of string;
  ARealICQClient: TRealICQClient);
var
  AJos: TInterfaceList;
begin
  try
    AJos := GetLoginNamesJsons(ALoginNames);
    RequestUserDetailByLoginName(USERINFO_PROLOCOL, AJos, ARealICQClient);
  except
    on E: Exception do
    begin
      Error(E.Message, 'TUsersService.RequestUserInformations');
      FreeAndNil(AJos);
    end;
  end;
end;
end.