RealICQClient/Client/Group/GroupProcess.pas

unit GroupProcess;

interface

uses
  superobject, GroupUtility, GroupClient, RealICQModel, Classes, SysUtils;

type
  TBaseProcess = class
  private
    FClient: TGroupClient;
  public
    constructor Create(AClient: TGroupClient);
    procedure Excute(AData: ISuperObject); virtual;
    procedure Send(AData: string);
    property Client: TGroupClient read FClient;
  end;

  TGetMyGroupsResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TGroupCreateResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TGroupDeleteResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TGroupUpdateResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TGroupSearchResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TGroupAsynResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TMemberAddResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TMemberDelResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  /// <summary>
  /// 群管理员收到加入群的申请
  /// </summary>
  TMemberApplyP = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TMemberReplyP = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TMessageBroadcast = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TFileDownloadBroadcast = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TOfflineMessageResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TNewOfflineMessageResponse = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

  TMessageMiscBroadcast = class(TBaseProcess)
  public
    procedure Excute(AData: ISuperObject); override;
  end;

function ManagersConvertToStr(AManagers: TSuperArray): string;

function MembersConvertToStr(AJoUser: ISuperObject): string;

implementation

uses
  LoggerImport, GroupService, DataProviderImport, DateUtils,
  InterfaceDataProvider, GroupConfig;

function ManagersConvertToStr(AManagers: TSuperArray): string;
var
  iLoop: Integer;
begin
  iLoop := 0;
  Result := '';
  while iLoop < AManagers.Length - 1 do
  begin
    Result := Result + AManagers[iLoop].AsString + Chr(10);
    Inc(iLoop);
  end;
  Result := Result + AManagers[iLoop].AsString
end;

function MembersConvertToStr(AJoUser: ISuperObject): string;
var
  AItem: TSuperAvlEntry;
begin
  Result := '';
  for AItem in AJoUser.AsObject do
    Result := Result + AItem.Value['id'].AsString + Chr(10);
  Result := Copy(Result, 0, Length(Result) - 1);
end;

function ToTeam(AJo: ISuperObject): TRealICQTeam;
begin
  try
    Result := nil;
    if AJo = nil then
      Exit;
    Result := TRealICQTeam.Create;
    Result.TeamID := AJo.S['id'];
    Result.TeamCaption := AJo.S['name'];
    Result.TeamCreater := AJo.S['creator'];
    Result.TeamIntro := AJo.S['intro'];
    Result.TeamCallBoard := AJo.S['notice'];
    Result.TeamValidate := TRealICQTeamValidateType(AJo.I['auth']);
    Result.TeamManagers := ManagersConvertToStr(AJo.A['managers']);
    Result.TeamMembers := MembersConvertToStr(AJo.O['members']);
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'ToTeam');
      Result.Free;
    end;
  end;
end;

function GetWaitingTeam(ATeamID: string): TRealICQTeam;
begin
  Result := TRealICQTeam.Create;
  Result.TeamID := ATeamID;
  Result.TeamCaption := '群信息正在努力加载中...';
  Result.TeamIntro := '加载中...';
  Result.TeamCallBoard := '加载中...';
end;

{ TNoProcess }


constructor TBaseProcess.Create(AClient: TGroupClient);
begin
  FClient := AClient;
end;

procedure TBaseProcess.Excute(AData: ISuperObject);
begin
  Warning(AData.AsJSon(), 'TBaseProcess.Excute');
end;

procedure TBaseProcess.Send(AData: string);
begin
  if FClient <> nil then
    FClient.Send(AData);
end;

{ TGroupCreateResponse }


procedure TGroupCreateResponse.Excute(AData: ISuperObject);
var
  ATeam: TRealICQTeam;
begin
  try
    ATeam := ToTeam(AData.O['group']);
    if ATeam = nil then
      Exit;
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TGroupCreateResponse.Excute');
      ATeam.Free;
    end;
  end;
  TGroupService.GetService.OnAddedTeam(ATeam);
  GetMapTeamUsersProvider.Insert(AData.S['group.id'], AData.O['group'].AsJSon(), AData.I['group.ver']);
end;

{ TGroupDeleteResponse }


procedure TGroupDeleteResponse.Excute(AData: ISuperObject);
var
  ATeamID: string;
begin
  try
    ATeamID := AData.S['group.id'];
    TGroupService.GetService.OnDeletedTeam(ATeamID);
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TGroupDeleteResponse.Excute');
    end;
  end;
end;

{ TGroupUpdateResponse }


procedure TGroupUpdateResponse.Excute(AData: ISuperObject);
var
  ATeam: TRealICQTeam;
begin
  try
    ATeam := TRealICQTeam.Create;
    ATeam.TeamID := AData.S['group.id'];
    ATeam.TeamCaption := AData.S['group.name'];
    ATeam.TeamIntro := AData.S['group.intro'];
    ATeam.TeamCallBoard := AData.S['group.notice'];
    ATeam.TeamValidate := TRealICQTeamValidateType(AData.I['group.auth']);
    TGroupService.GetService.OnTeamInfoChange(ATeam);
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TGroupCreateResponse.Excute');
      ATeam.Free;
    end;
  end;
  ATeam.Free;
//  GetMapTeamUsersProvider.Insert(AData.S['group.id'], AData.O['group'].AsJSon(), AData.I['group.ver']);


end;

{ TGroupSearchResponse }


procedure TGroupSearchResponse.Excute(AData: ISuperObject);
var
  ARecord: TSearchTeamResultRecord;
  ARecords: TStringList;
  iLoop: Integer;
  jaGroups: TSuperArray;
begin
  ARecords := TStringList.Create;
  try
    jaGroups := AData.A['groups'];
    for iLoop := 0 to jaGroups.Length - 1 do
    begin
      ARecord := TSearchTeamResultRecord.Create;
      ARecord.TeamID := jaGroups[iLoop]['id'].AsString;
      ARecord.TeamCaption := jaGroups[iLoop]['name'].AsString;
      ARecord.TeamCreater := jaGroups[iLoop]['creator'].AsString;

      ARecords.AddObject(IntToStr(iLoop), ARecord);
    end;

    TGroupService.GetService.OnSearched(ARecords, AData.I['skip'], AData.I['limit']);
  finally
    ARecords.Free;
  end;
end;

{ TGroupAsynResponse }


procedure TGroupAsynResponse.Excute(AData: ISuperObject);
var
  ATeam: TRealICQTeam;
  AJo: ISuperObject;
  AMessageRep: TMessageBroadcast;
begin
  try
    {$IFDEF OldGroup}
    AJo := AData.O['groups'];
    {$ELSE}
    AJo := AData.O['group'];
    {$ENDIF}
    ATeam := ToTeam(AJo);
    if ATeam = nil then
      Exit;
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TGroupCreateResponse.Excute');
      ATeam.Free;
    end;
  end;
  TGroupService.GetService.OnAddedTeam(ATeam);
  GetMapTeamUsersProvider.Insert(AJo.S['id'], AJo.AsJSon(), AJo.I['ver']);
end;

{ TBaseProcess }
//42["m.add.b",{"id":"","group":{"id":"0fde0aa744384f2e8b4973e17ca9b79a","members":["1000+002682BECE10-lqq"],"managers":[]},"operator":"1000+002682BECE10-test02"}]
procedure TMemberAddResponse.Excute(AData: ISuperObject);
var
  ATeamID: string;
  AMembers, AManagers: TStringList;
  jaMembers, jaManagers: TSuperArray;
  iLoop: Integer;
begin
  try
    ATeamID := AData.S['group.id'];
    if Trim(ATeamID) = '' then
      Exit;

    AMembers := TStringList.Create;
    AManagers := TStringList.Create;
    jaMembers := AData.A['group.members'];
    jaManagers := AData.A['group.managers'];

    if jaMembers <> nil then
      for iLoop := 0 to jaMembers.Length - 1 do
        AMembers.Add(jaMembers.S[iLoop]);
    if jaManagers <> nil then
      for iLoop := 0 to jaManagers.Length - 1 do
        AManagers.Add(jaManagers.S[iLoop]);

    if (AMembers.Count > 0) then
      TGroupService.GetService.OnAddedMembers(ATeamID, AMembers);
    if (AManagers.Count > 0) then
      TGroupService.GetService.OnAddedManagers(ATeamID, AManagers);
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TMemberAddResponse.Excute');
      FreeAndNil(AMembers);
      FreeAndNil(AManagers);
    end;
  end;
  FreeAndNil(AMembers);
  FreeAndNil(AManagers);
end;

{ TMemberDelResponse }


procedure TMemberDelResponse.Excute(AData: ISuperObject);
var
  ATeamID: string;
  AMembers, AManagers: TStringList;
  jaMembers, jaManagers: TSuperArray;
  iLoop: Integer;
begin
  try
    ATeamID := AData.S['group.id'];
    if Trim(ATeamID) = '' then
      Exit;

    AMembers := TStringList.Create;
    AManagers := TStringList.Create;
    jaMembers := AData.A['group.members'];
    jaManagers := AData.A['group.managers'];

    if jaMembers <> nil then
      for iLoop := 0 to jaMembers.Length - 1 do
        AMembers.Add(jaMembers.S[iLoop]);
    if jaManagers <> nil then
      for iLoop := 0 to jaManagers.Length - 1 do
        AManagers.Add(jaManagers.S[iLoop]);

    if (AMembers.Count > 0) then
      TGroupService.GetService.OnDeletedMembers(ATeamID, AMembers);
    if (AManagers.Count > 0) then
      TGroupService.GetService.OnDeletedManagers(ATeamID, AManagers);
  except
    on Ex: Exception do
    begin
      Error(Ex.Message, 'TMemberAddResponse.Excute');
      FreeAndNil(AMembers);
      FreeAndNil(AManagers);
    end;
  end;
  FreeAndNil(AMembers);
  FreeAndNil(AManagers);
end;

{ TMemberApplyP }


procedure TMemberApplyP.Excute(AData: ISuperObject);
var
  ATeamID: string;
  joApply: ISuperObject;
begin
  ATeamID := AData.S['group.id'];
  joApply := AData.O['group.apply'];
  TGroupService.GetService.OnReceivedApplyBoardcast(ATeamID, joApply.S['uid'], joApply.S['msg']);
end;

{ TMemberReplyP }
//42["m.reply.p",
//{"group":
    {"id":"5ebbdeeed099442e88980a4512227656",
     "apply":{"uid":"0578+0-lslinlh","msg":"","id":"a1e782d74bfd45e785dcb9ce85750a24"}
//     },
//     "id":"6d773f668b8d4811b990254396f0eb7e",
//"reply":{"id":"6d773f668b8d4811b990254396f0eb7e","ret":1}}]
procedure TMemberReplyP.Excute(AData: ISuperObject);
var
  ATeamID, ALoginName, AMsg: string;
  ARet: Integer;
begin
  ATeamID := AData.S['group.id'];
  ALoginName := AData.S['group.apply.uid'];
  AMsg := AData.S['group.reply.msg'];
  ARet := AData.I['group.reply.ret'];
  TGroupService.GetService.OnReceivedReplyBoardcast(ATeamID, ALoginName, AMsg, ARet);
end;

{ TMessageBroadcast }
//{id:'', group:{id:[id...]}, message:{message}}


procedure TMessageBroadcast.Excute(AData: ISuperObject);
var
  ATeamID: string;
  ASender: string;
  AStyle: string;
  AContent: string;
  TimesTamp: Int64;
  ASendTime: TDateTime;
  jaImgs: TSuperArray;
  iLoop: Integer;
begin
  ATeamID := AData.S['group.id'];
  if TGroupService.GetService.GetTeam(ATeamID) = nil then
  begin
    FClient.AsynTeam(ATeamID);
  end;
  if AData.S['content'] <> '' then
    AContent := AData.S['content']
  else
    AContent := AData.S['txt'];
  if AData.I['msgType'] <> 4 then
  begin
    AContent := StringReplace(AContent, '\r\n', #13#10, [rfReplaceAll]);
    AContent := StringReplace(AContent, '[\r][\n]', '\r\n', [rfReplaceAll]);
  end
  else
    AContent := StringReplace(AContent, #$A, '\n', [rfReplaceAll]);
  ASender := AData.S['sender'];
  ASendTime := UnixToDateTime(Round(AData.I['ts'] / 1000) + 8 * 60 * 60);
  AStyle := JsonToFont(AData.O['style']);

  TGroupService.GetService.OnMessage(ATeamID, ASender, AContent, AStyle, ASendTime, AData.I['msgType'], AData.I['length']);
  Client.MessageMisc(ATeamID);
end;

{ TGetMyGroupsResponse }


procedure TGetMyGroupsResponse.Excute(AData: ISuperObject);
var
  AJa: TSuperArray;
  iLoop, ARemoteVer, ALocalVer: Integer;
  AJson, ATeamID: string;
  AKeyValue: TKeyValue;
  ATeam: TRealICQTeam;
begin
  AJa := AData.A['user.groups'];
  if AJa = nil then
    Exit;
  for iLoop := 0 to AJa.Length - 1 do
  begin
    ATeamID := AJa.O[iLoop].S['id'];

    ARemoteVer := AJa.O[iLoop].I['ver'];
    AKeyValue := GetMapTeamUsersProvider.FindKeyValue(ATeamID);
    ALocalVer := StrToIntDef(AKeyValue[2], -1);
    AJson := AKeyValue[1];
    try
      if (ALocalVer < 0) or (ALocalVer <> ARemoteVer) or (AJson = '') then
      begin
        ATeam := GetWaitingTeam(ATeamID);
        FClient.AsynTeam(ATeamID)
      end
      else
        ATeam := ToTeam(SO(AJson));
      if ATeam <> nil then
        TGroupService.GetService.OnAddedTeam(ATeam, AJa.O[iLoop].I['as']);
    except
      on Ex: Exception do
      begin
        Error(AJson, 'TGetMyGroupsResponse.Excute');
        FreeAndNil(ATeam);
      end;
    end;
    FreeAndNil(ATeam);
  end;
//  FClient.GetOffineMessage;
end;


{ TOfflineMessageResponse }


procedure TOfflineMessageResponse.Excute(AData: ISuperObject);
var
  ATeamID: string;
  ASender: string;
  AStyle: string;
  AContent, AURL: string;
  TimesTamp: Int64;
  ASendTime: TDateTime;
  jaImgs, jaMsgs: TSuperArray;
  iLoop, jLoop, iCount: Integer;
  AItem: ISuperObject;
  config: TGroupConfig;
  service: TGroupService;
begin
  jaMsgs := AData.AsArray;
  iCount := jaMsgs.Length;
  config := TGroupConfig.GetConfig;
  service := TGroupService.GetService;
  for iLoop := 0 to iCount - 1 do
  begin
    try
      AItem := jaMsgs.O[iLoop];
      ATeamID := AItem.S['group.id'];
      if AItem.S['content'] <> '' then
        AContent := AItem.S['content']
      else
        AContent := AItem.S['txt'];
      AContent := StringReplace(AContent, '\r\n', #13#10, [rfReplaceAll]);
      AContent := StringReplace(AContent, '[\r][\n]', '\r\n', [rfReplaceAll]);
      ASender := AItem.S['sender'];
      ASendTime := UnixToDateTime(Round(AItem.I['ts'] / 1000) + 8 * 60 * 60);
      AStyle := JsonToFont(AItem.O['style']);
      TGroupService.GetService.OnMessage(ATeamID, ASender, AContent, AStyle, ASendTime, AItem.I['msgType'], AItem.I['length']);
    finally
      Client.MessageMisc(ATeamID);
    end;
  end;
end;

{ TFileDownloadBroadcast }


procedure TFileDownloadBroadcast.Excute(AData: ISuperObject);
var
  AURL: string;
  jaFiles: TSuperArray;
  iLoop: Integer;
  joFile: ISuperObject;
  config: TGroupConfig;
  service: TGroupService;
begin
  jaFiles := AData.A['hashs'];
  config := TGroupConfig.GetConfig;
  service := TGroupService.GetService;
  for iLoop := 0 to jaFiles.Length - 1 do
  begin
    joFile := jaFiles.O[iLoop];
    AURL := Format(DOWNLOAD_URL, [config.ImageIP, config.ImagePort, joFile.S['hash']]);
    service.OnUploaded(AURL, joFile.S['file']);
  end;
end;

{ TNewOfflineMessageResponse }

procedure TNewOfflineMessageResponse.Excute(AData: ISuperObject);
var
  ATeamID: string;
  ASender: string;
  AStyle: string;
  AContent, AURL: string;
  TimesTamp: Int64;
  ASendTime: TDateTime;
  jaImgs, jaMsgs: TSuperArray;
  iLoop, jLoop, iCount: Integer;
  AItem: ISuperObject;
  config: TGroupConfig;
  service: TGroupService;
begin
  jaMsgs := AData.A['data'];
  iCount := jaMsgs.Length;
  config := TGroupConfig.GetConfig;
  service := TGroupService.GetService;
  for iLoop := 0 to iCount - 1 do
  begin
    try
      AItem := jaMsgs.O[iLoop];
      ATeamID := AItem.S['group.id'];
      if AItem.S['content'] <> '' then
        AContent := AItem.S['content']
      else
        AContent := AItem.S['txt'];
      AContent := StringReplace(AContent, '\r\n', #13#10, [rfReplaceAll]);
      AContent := StringReplace(AContent, '[\r][\n]', '\r\n', [rfReplaceAll]);
      ASender := AItem.S['sender'];
      ASendTime := UnixToDateTime(Round(AItem.I['ts'] / 1000) + 8 * 60 * 60);
      AStyle := JsonToFont(AItem.O['style']);
      TGroupService.GetService.OnMessage(ATeamID, ASender, AContent, AStyle, ASendTime, AItem.I['msgType'], AItem.I['length']);
    finally
      Client.MessageMisc(ATeamID);
    end;
  end;
end;

{ TMessageMiscBroadcast }

procedure TMessageMiscBroadcast.Excute(AData: ISuperObject);
var
  ja: TSuperArray;
  jo: ISuperObject;
  i: Integer;
begin
  ja := AData.A['group'];
  if ja <> nil then
    for I := 0 to ja.Length - 1 do
      TGroupService.GetService.OnMessageReaded(ja[i].S['id'], ja[i].I['ts'])
  else
  begin
    jo := AData.O['group'];
    if jo = nil then
      Exit;
    TGroupService.GetService.OnMessageReaded(jo.S['id'], jo.I['ts']);
  end;
end;

end.