RealICQClient/Client/Group/TeamsAdapter.pas

unit TeamsAdapter;

interface

uses
  StrUtils, Classes, SysUtils, Groups, Graphics, RealICQClient, DownloadFileFromWeb,
  RealICQModel, UploaderTask;

type  
  TTeamsAdapter = class
  private
    class procedure NewUpdateTeamMembers(ATeamID: String; AOldMembers, ANewMembers: TStringList);
    class procedure OldUpdateTeamMembers(ATeamID: String; AOldMembers, ANewMembers: TStringList);
    class procedure OnFacesUploaded(ASender: TObject);
  public
    class procedure Start(ACurrentLoginName: string);
    class procedure Stop;
    class procedure UpdateTeamMembers(ATeamID: String; AOldMembers, ANewMembers: TStringList);
    class procedure AddTeamMembers(ATeamID: String; AAddMembers: TStringList);
    class procedure UpdateTeamInfo(ATeamID, AIntro, ANotice, AName: string; AAuth: Integer);
    class procedure HandOverTeam(ATeamID, ALoginName: string); static;
    class procedure SendTeamMessage(ATeamID, ASender, AMsg: string; AFont: TFont; AFaces: TStringList; Attachs: String);
    class function RemoveManager(ATeamID, ALoginName: string): Boolean;
    class function AddManager(ATeamID, ALoginName: string): Boolean;
    class procedure Subscribe;
    class procedure UnSubscribe;
    class function  IsTeamManager(ATeamID, ALoginName: string): Boolean;
    class function  IsTeamCreater(ATeamID, ALoginName: string): Boolean;
    class procedure SearchTeam(AKey: string; ASearchType: TRealICQTeamSearchType; AMatchingType: TRealICQMatchingType; APage: Integer);
    class procedure QuitTeam(ATeamID: String);
    class procedure DisbandTeam(ATeamID: String);
    class procedure JoinTeam(ATeamID, ATag: string);
    class procedure JoinTeamResponse(ATeamID, ALoginName, ATag: string; Accepted: Boolean);
    class procedure SetAlias(ATeamID, ALoginName, Alias: String);
    class function GetAlias(ATeamID, ALoginName: string): string;
    class function GetTeam(ATeamID: string): TRealICQTeam;
    class function GetTeams: TStringList;
    class procedure CreateTeam(ATeamName, ATeamCallBoard, ATeamIntro: String;
      ATeamMembers: TStringList; AIsTempTeam: Boolean; ATeamValidateType: TRealICQTeamValidateType);
    class procedure MessageMiscMust(ATeamID: string);
  end;

implementation

uses
  MainFrm, Windows, xFonts, Dialogs, GroupConfig, GroupService, RealICQUtils,
  BaseService, MessagesHander, RealICQUtility;

{$DEFINE GroupV3.2+}

{ TTeamsAdapter }

class procedure TTeamsAdapter.DisbandTeam(ATeamID: String);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.DisbandTeam(ATeamID);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.RemoveTeam(ATeamID)
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.DisbandTeam(ATeamID);
end;

class procedure TTeamsAdapter.QuitTeam(ATeamID: String);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.QuitTeam(ATeamID);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.Leave(ATeamID)
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.QuitTeam(ATeamID);
end;

class procedure TTeamsAdapter.AddTeamMembers(ATeamID: String;
  AAddMembers: TStringList);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.AddTeamMembers(ATeamID, AAddMembers);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.AddTeamMembers(ATeamID, AAddMembers);
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.ModifyTeamMembers(ATeamID, AAddMembers);
end;

class function TTeamsAdapter.IsTeamCreater(ATeamID, ALoginName: string): Boolean;
begin
  Result := False;
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    Result := TGroupService.GetService.IsTeamCreater(ATeamID, ALoginName);
  end;
end;

class procedure TTeamsAdapter.HandOverTeam(ATeamID, ALoginName: string); 
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
     TGroupService.GetService.HandOverTeam(ATeamID, ALoginName)
  else
    ShowMessage('集成版群组不支持该功能');
end;

class function TTeamsAdapter.IsTeamManager(ATeamID, ALoginName: string): Boolean;
var
  iIndex: Integer;
  RealICQTeam: TRealICQTeam;
  Team: TRealICQTeam;
begin
  Result := False;
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    Result := TGroupService.GetService.IsTeamManager(ATeamID, ALoginName);
    {$ELSE}
    if Group = nil then
      Exit;
    iIndex := group.Teams.IndexOf(ATeamID);
    RealICQTeam := group.Teams.Objects[iIndex] as TRealICQTeam;
    if (AnsiPos(Chr(10) + ALoginName + Chr(10), Chr(10) + RealICQTeam.TeamManagers + Chr(10)) > 0) or
               (AnsiSameText(ALoginName, RealICQTeam.TeamCreater))  then
      Result := True
    else
      Result := False;
    {$ENDIF}
  end
  else
  begin
    iIndex := MainForm.RealICQClient.Teams.IndexOf(ATeamID);
    if iIndex = -1 then Exit;
    Team := MainForm.RealICQClient.Teams.Objects[iIndex] as TRealICQTeam;
    if (AnsiPos(Chr(10) + ALoginName + Chr(10), Chr(10) + Team.TeamManagers + Chr(10)) <= 0) then
      Result := False
    else
      Result := True;
  end;
end;

class procedure TTeamsAdapter.JoinTeam(ATeamID, ATag: string);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.JoinTeam(ATeamID, ATag);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.JoinTeam(ATeamID, ATag)
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.JoinTeam(ATeamID, ATag);
end;

class procedure TTeamsAdapter.JoinTeamResponse(ATeamID, ALoginName, ATag: string; Accepted: Boolean);
var
  ret: Integer;
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.JoinTeamResponse(ATeamID, ALoginName, ATag, Accepted);
    {$ELSE}
    if Group = nil then
      Exit;
    if Accepted then
      ret := 0
    else
      ret := 1;
    Group.JoinTeamResponse(ATeamID, ALoginName, ATag, ret);
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.JoinTeamResponse(ATeamID, ALoginName, ATag, Accepted);
end;

class procedure TTeamsAdapter.MessageMiscMust(ATeamID: string);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
    TGroupService.GetService.MessageMiscMust(ATeamID);
end;

class procedure TTeamsAdapter.NewUpdateTeamMembers(ATeamID: String; AOldMembers,
  ANewMembers: TStringList);
var
  iLoop: Integer;
  ATeamAddMembers,
  ATeamRemoveMembers: TStringList;
  MemberListChanged: Boolean;
begin
  ATeamAddMembers := TStringList.Create;
  ATeamRemoveMembers := TStringList.Create;
  MemberListChanged := False;
  for iLoop := 0 to ANewMembers.Count - 1 do
  begin
    if AOldMembers.IndexOf(ANewMembers[iLoop]) = -1 then
    begin
      MemberListChanged := True;
      ATeamAddMembers.Add(ANewMembers[iLoop]);
    end;
  end;
  if MemberListChanged then
    Group.AddTeamMembers(ATeamID,ATeamAddMembers);

  MemberListChanged := False;
  for iLoop := 0 to AOldMembers.Count - 1 do
  begin
    if Length(Trim(AOldMembers[iLoop])) = 0 then Continue;
    if ANewMembers.IndexOf(AOldMembers[iLoop]) = -1 then
    begin
      MemberListChanged := True;
      ATeamRemoveMembers.Add(AOldMembers[iLoop]);
    end;
  end;
  if MemberListChanged then
    Group.RemoveTeamMembers(ATeamID, ATeamRemoveMembers);
  ATeamAddMembers.Free;
  ATeamRemoveMembers.Free;
end;

class procedure TTeamsAdapter.OldUpdateTeamMembers(ATeamID: String; AOldMembers,
  ANewMembers: TStringList);
var
  iLoop: Integer;
  MemberListChanged: Boolean;
  MembersStr: string;
begin
  MemberListChanged := AOldMembers.Count <> ANewMembers.Count;
  if not MemberListChanged then
    for iLoop := 0 to ANewMembers.Count - 1 do
    begin
      if AOldMembers.IndexOf(ANewMembers[iLoop]) = -1 then
      begin
        MemberListChanged := True;
        Break;
      end;
    end;

  if not MemberListChanged then
    for iLoop := 0 to AOldMembers.Count - 1 do
    begin
      if Length(Trim(AOldMembers[iLoop])) = 0 then Continue;
      if ANewMembers.IndexOf(AOldMembers[iLoop]) = -1 then
      begin
        MemberListChanged := True;
        Break;
      end;
    end;
    
  if MemberListChanged then
    MainForm.RealICQClient.ModifyTeamMembers(ATeamID, ANewMembers);
end;

class procedure TTeamsAdapter.OnFacesUploaded(ASender: TObject);
var
  msg: TRealICQTeamMessage;
begin
  if not (ASender is TFacesUploaderTask) then
    Exit;

  msg := (ASender as TFacesUploaderTask).Data as TRealICQTeamMessage;

  with msg do
  begin
    MainForm.RealICQClient.SendTeamMessage(False, TeamID, FontStr, MessageStr);
  end;              
end;

class function TTeamsAdapter.RemoveManager(ATeamID, ALoginName: string): Boolean;
var
  ATeam: TRealICQTeam;
  iIndex, iLoop: Integer;
  ANewManagers: string;
  ANewManagerList: TStringList;
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.RemoveManager(ATeamID, ALoginName);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.RemoveManager(ATeamID, ALoginName);
    {$ENDIF}
  end
  else
  begin
    iIndex := MainForm.RealICQClient.Teams.IndexOf(ATeamID);
    if iIndex < 0 then
      Exit;
    ATeam := MainForm.RealICQClient.Teams.Objects[iIndex] as TRealICQTeam;
    if ATeam.TeamManagers = '' then
      Exit;
    ANewManagerList := SplitString(ATeam.TeamManagers, Chr(10));
    try
      iLoop := 0;
      while iLoop < ANewManagerList.Count do
      begin
        if ANewManagerList[iLoop] = '' then
          ANewManagerList.Delete(iLoop);
          Inc(iLoop);
      end;
      ALoginName := TBaseService.FullLoginName(MainForm.RealICQClient.CenterServerID, MainForm.RealICQClient.ServerID, ALoginName);
      for iLoop := 0 to ANewManagerList.Count - 1 do
        if SameText(TBaseService.FullLoginName(MainForm.RealICQClient.CenterServerID, MainForm.RealICQClient.ServerID, ANewManagerList[iLoop]), ALoginName) then
        begin
          ANewManagerList.Delete(iLoop);
          MainForm.RealICQClient.ModifyTeamManagers(ATeam.TeamID, ANewManagerList);
          Break;
        end;
    finally
      FreeAndNil(ANewManagerList);
    end;
  end;
end;

class function TTeamsAdapter.AddManager(ATeamID, ALoginName: string): Boolean;
var
  ATeam: TRealICQTeam;
  iIndex, iLoop: Integer;
  ANewManagers: string;
  ANewManagerList: TStringList;
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.AddManager(ATeamID, ALoginName);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.AddManager(ATeamID, ALoginName);
    {$ENDIF}
  end
  else
  begin
    iIndex := MainForm.RealICQClient.Teams.IndexOf(ATeamID);
    if iIndex < 0 then
      Exit;
    ATeam := MainForm.RealICQClient.Teams.Objects[iIndex] as TRealICQTeam;
    if ATeam.TeamManagers = '' then
      ANewManagerList := TStringList.Create
    else
      ANewManagerList := SplitString(ATeam.TeamManagers, Chr(10));
    try
      iLoop := 0;
      while iLoop < ANewManagerList.Count do
      begin
        if ANewManagerList[iLoop] = '' then
          ANewManagerList.Delete(iLoop);
          Inc(iLoop);
      end;
      ALoginName := TBaseService.FullLoginName(MainForm.RealICQClient.CenterServerID, MainForm.RealICQClient.ServerID, ALoginName);
      for iLoop := 0 to ANewManagerList.Count - 1 do
        if SameText(TBaseService.FullLoginName(MainForm.RealICQClient.CenterServerID, MainForm.RealICQClient.ServerID, ANewManagerList[iLoop]), ALoginName) then
        begin
          ANewManagerList.Delete(iLoop);
          FreeAndNil(ANewManagerList);
          Exit;
        end;
      ANewManagerList.Add(ALoginName);
      MainForm.RealICQClient.ModifyTeamManagers(ATeam.TeamID, ANewManagerList);
    finally
      FreeAndNil(ANewManagerList);
    end;
  end;
end;

class procedure TTeamsAdapter.UpdateTeamMembers(ATeamID: String; AOldMembers,
  ANewMembers: TStringList);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.UpdateTeamMembers(ATeamID, AOldMembers, ANewMembers);
    {$ELSE}
    if Group = nil then
      Exit;
    NewUpdateTeamMembers(ATeamID, AOldMembers, ANewMembers)
    {$ENDIF}
  end
  else
    OldUpdateTeamMembers(ATeamID, AOldMembers, ANewMembers)
end;

class procedure TTeamsAdapter.UnSubscribe;
begin
  if (TGroupConfig.GetConfig.GroupVersion = gvIndependent) and (Group <> nil) then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.Uninstall;
    {$ELSE}
    if Group = nil then
      Exit;
    Group.UnSubscribe;
    {$ENDIF}
  end;
end;

class procedure TTeamsAdapter.UpdateTeamInfo(ATeamID, AIntro, ANotice, AName: string; AAuth: Integer);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    if AAuth = 2 then
      AAuth := 4;
    TGroupService.GetService.UpdateTeam(ATeamID, AIntro, ANotice, AName, AAuth);
    {$ELSE}
    if Group = nil then
      Exit;

    if AAuth = 2 then
      AAuth := 4;
    Group.UpdateTeamInfo(ATeamID, AIntro, ANotice, AName, AAuth);
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.ModifyTeamBaseInfo(ATeamID, AName, ANotice, AName, TRealICQTeamValidateType(AAuth));
end;

class procedure TTeamsAdapter.SearchTeam(AKey: string; ASearchType: TRealICQTeamSearchType; AMatchingType: TRealICQMatchingType;
  APage: Integer);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.SearchTeam(AKey, ASearchType, AMatchingType, APage);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.Search(AKey, '', '', '');
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.SearchTeam(ASearchType, AKey, AMatchingType, APage);
end;

class procedure TTeamsAdapter.SendTeamMessage(ATeamID, ASender, AMsg: string; AFont: TFont; AFaces: TStringList; Attachs: String);
var
  RealICQTeamMessage: TRealICQTeamMessage;
  aDateTime: TDateTime;
  AFontStr: string;
  ATask: TFacesUploaderTask;
  AMessage: TRealICQTeamMessage;
begin
  AFontStr := FontToString(AFont);
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.SendTeamMessage(ATeamID, ASender, AMsg, AFont, AFaces, Attachs);
    RealICQTeamMessage:= TRealICQTeamMessage.Create(ATeamID,ASender,AFontStr,AMsg,False);
    RealICQTeamMessage.MessageID := GetTickCount();
    RealICQTeamMessage.SendDateTime := Now();
//    TGroupService.GetService.MessageMiscMust(ATeamID);
    MainForm.ShowRealICQTeamMessage(RealICQTeamMessage, False);
    {$ELSE}
    if Group = nil then
       Exit;
    Group.SendTeamMessage(ATeamID, ASender, AMsg, AFont, AFaces, Attachs);
    RealICQTeamMessage:= TRealICQTeamMessage.Create(ATeamID,ASender,AFontStr,AMsg,False);
    RealICQTeamMessage.MessageID := GetTickCount();
    RealICQTeamMessage.SendDateTime := Now();
    MainForm.ShowRealICQTeamMessage(RealICQTeamMessage, False);
    {$ENDIF}
  end;
//  else
//  begin
//    try
//      if AFaces.Count > 0 then
//      begin
//        AMessage := TRealICQTeamMessage.Create(ATeamID, '', AFontStr, AMsg, False);
//        ATask := TFacesUploaderTask.Create(TGroupConfig.GetConfig.ImageHost, AFaces, AThreadPool.AcquireYarn);
//        ATask.Data := AMessage;
//        ATask.OnCompleted := OnFacesUploaded;
//        AThreadPool.StartYarn(ATask.Yarn, ATask);
//      end
//      else
//      begin
//        MainForm.RealICQClient.SendTeamMessage(False, ATeamID, AFontStr, AMsg);
//      end;
//    finally
//      TRealICQUtility.FreeStringList(AFaces as TStringList);
//    end;
//  end;
end;
class procedure TTeamsAdapter.SetAlias(ATeamID, ALoginName, Alias: String);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.SetAlias(ATeamID, ALoginName, Alias);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.SetAlias(ATeamID, ALoginName, Alias)
    {$ENDIF}
  end
  else
    Dialogs.ShowMessage('集成群组版本不支持群成员别名!');
end;

class procedure TTeamsAdapter.Start(ACurrentLoginName: string);
var
  AConfig: TGroupConfig;
begin
  AConfig := TGroupConfig.Load;
  if AConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.Init(ACurrentLoginName);
    {$ELSE}
    if ACurrentLoginName = '' then
      Exit;
    if Group <> nil then
    begin
      Group.Close;
      FreeAndNil(Group);
    end;
    Group := TGroup.Create;
    Group.IP := AConfig.IP;
    Group.Port := AConfig.Port;
    Group.ImageIP := AConfig.ImageIP;
    Group.ImagePort := AConfig.ImagePort;
    Group.LoginName := ACurrentLoginName;
    Group.Start;
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.SendGetTeamList;
end;

class procedure TTeamsAdapter.Stop;
var
  AConfig: TGroupConfig;
begin
  AConfig := TGroupConfig.GetConfig;
  if AConfig <> nil then
  begin
    if AConfig.GroupVersion = gvIndependent then
    begin
      {$IFDEF GroupV3.2+}
      TGroupService.GetService.Uninstall;
      {$ELSE}
      if Group <> nil then
      begin
        Group.UnSubscribe;
        Group.Close;
        FreeAndNil(Group);
      end;
      {$ENDIF}
    end;
  end;
end;

class function TTeamsAdapter.GetAlias(ATeamID, ALoginName: string): string;
begin
  Result := '';
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.GetAlias(ATeamID, ALoginName);
    {$ELSE}
    if Group = nil then
      Exit;
    Result := Group.GetAlias(ATeamID, ALoginName)
    {$ENDIF}
  end;
end;

class function TTeamsAdapter.GetTeam(ATeamID: string): TRealICQTeam;
var
  iIndex: Integer;
begin
  Result := nil;
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    Result := TGroupService.GetService.GetTeam(ATeamID);
    {$ELSE}
    if Group = nil then
      Exit;
    iIndex := Group.Teams.IndexOf(ATeamID);
    if iIndex  >= 0 then
      Result := Group.Teams.Objects[iIndex] as TRealICQTeam;
    {$ENDIF}
  end
  else
  begin
    iIndex := MainForm.RealICQClient.Teams.IndexOf(ATeamID);
    if iIndex  >= 0 then
      Result := MainForm.RealICQClient.Teams.Objects[iIndex] as TRealICQTeam;
  end;
end;

class function TTeamsAdapter.GetTeams: TStringList;
begin
  Result := nil;
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    Result := TGroupService.GetService.GetTeams;
    {$ELSE}
    if Group = nil then
      Exit;
    Result := Group.Teams;
    {$ENDIF}
  end
  else
    Result := MainForm.RealICQClient.Teams;
end;

class procedure TTeamsAdapter.CreateTeam(ATeamName, ATeamCallBoard, ATeamIntro: String;
  ATeamMembers: TStringList; AIsTempTeam: Boolean; ATeamValidateType: TRealICQTeamValidateType);
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}
    TGroupService.GetService.CreateTeam(ATeamName, ATeamCallBoard, ATeamIntro, ATeamMembers, AIsTempTeam, ATeamValidateType);
    {$ELSE}
    if Group = nil then
      Exit;
    Group.CreateTeam(ATeamName, ATeamCallBoard, ATeamIntro, ATeamMembers, AIsTempTeam);
    {$ENDIF}
  end
  else
    MainForm.RealICQClient.CreateTeam(ATeamName, ATeamCallBoard, ATeamIntro, ATeamMembers, AIsTempTeam, ATeamValidateType);
end;

class procedure TTeamsAdapter.Subscribe;
begin
  if TGroupConfig.GetConfig.GroupVersion = gvIndependent then
  begin
    {$IFDEF GroupV3.2+}

    {$ELSE}
    if Group = nil then
      Exit;
    Group.Subscribe;
    {$ENDIF}
  end;
end;

end.