stnet.pas

条码控件： 一维条码控件 二维条码控件 PDF417Barcode MaxiCodeBarcode

  Data    : TLMWideChar;
begin
  Data.Value := nil;
  try
    { allocate the unicode password }
    CvtToWideCharLM(Value, Data);

    ErrorD := StNetUserSetInfo(FServer, FName, 1003, @Data.Value, ParmErr);
    if ErrorD = NERR_SUCCESS then begin
      { no need to update internal data .. password is write-only}
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  finally
    StNetApiBufferFree(Data.Value);
  end;
end;

procedure TStNetUserItem.SetPassword(OldPassword, NewPassword: string);
var
  ErrorD : DWord;
  TempServer : string;
  S : TStNetServerItem;
begin
  { if the server is a BDC, we need to change it on the PDC }
  S := StNetwork.Server[FServer];
  if (nsvtDomainBackupCtrl in S.ServerType) then begin
    TempServer := S.PrimaryDC;
  end else begin
    TempServer := FServer;
  end;

  ErrorD := StNetUserChangePassword(TempServer, FName, OldPassword, NewPassword);
  if ErrorD = NERR_SUCCESS then begin
    { Nothing else to do }
  end else begin
    RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;

procedure TStNetUserItem.SetPasswordNeverExpires(Value: Boolean);
var
  Data    : DWord;
  ErrorD  : DWord;
  ParmErr : DWord;
begin
  if Value <> PasswordNeverExpires then begin
    Data := TUSER_INFO_3(FUserData^).usri3_flags;
    if Value then
      SetLongFlag(LongInt(Data), UF_DONT_EXPIRE_PASSWD)
    else
      ClearLongFlag(LongInt(Data), UF_DONT_EXPIRE_PASSWD);

    ErrorD := StNetUserSetInfo(FServer, FName, 1008, @Data, ParmErr);
    if ErrorD = NERR_SUCCESS then
      TUSER_INFO_3(FUserData^).usri3_flags := Data
    else
      RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;

procedure TStNetUserItem.SetPasswordExpired(Value: Boolean);
var
  Data    : DWord;
  ErrorD  : DWord;
  ParmErr : DWord;
begin
  if Value <> PasswordExpired then begin
    Data := TUSER_INFO_3(FUserData^).usri3_password_expired;
    if Value then
      TUSER_INFO_3(FUserData^).usri3_password_expired := DWord(-1)
    else
      TUSER_INFO_3(FUserData^).usri3_password_expired := 0;

    ErrorD := StNetUserSetInfo(FServer, FName, 3, FUserData, ParmErr);
    if ErrorD = NERR_SUCCESS then
      { The data was already updated }
    else begin
      TUSER_INFO_3(FUserData^).usri3_password_expired := Data;
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end;
end;

procedure TStNetUserItem.SetPasswordNotRequired(Value: Boolean);
var
  Data    : DWord;
  ErrorD  : DWord;
  ParmErr : DWord;
begin
  if Value <> PasswordNotRequired then begin
    Data := TUSER_INFO_3(FUserData^).usri3_flags;
    if Value then
      SetLongFlag(LongInt(Data), UF_PASSWD_NOTREQD)
    else
      ClearLongFlag(LongInt(Data), UF_PASSWD_NOTREQD);

    ErrorD := StNetUserSetInfo(FServer, FName, 1008, @Data, ParmErr);
    if ErrorD = NERR_SUCCESS then
      TUSER_INFO_3(FUserData^).usri3_flags := Data
    else
      RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;

procedure TStNetUserItem.SetPrimaryGroup(Value: TStNetItem);
var
  ErrorD  : DWord;
  ParmErr : DWord;
  Data    : DWord;
begin
  if TStNetGroupItem(Value).ID <> TStNetGroupItem(PrimaryGroup).ID then begin
    Data := TStNetGroupItem(Value).ID;
    ErrorD := StNetUserSetInfo(FServer, FName, 1051, @Data, ParmErr);
    if ErrorD = NERR_SUCCESS then begin
      TUSER_INFO_3(FUserData^).usri3_primary_group_id := Data
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end;
end;

procedure TStNetUserItem.SetProfilePath(Value: string);
var
  ErrorD  : DWord;
  ParmErr : DWord;
  Data    : TLMWideChar;
begin
  if Value <> ProfilePath then begin
    Data.Value := nil;
    try
      CvtToWideCharLM(Value, Data);
      ErrorD := StNetUserSetInfo(FServer, FName, 1052, @Data.Value, ParmErr);
      if ErrorD = NERR_SUCCESS then begin
        StNetApiBufferFree(TUSER_INFO_3(FUserData^).usri3_profile);
        TUSER_INFO_3(FUserData^).usri3_profile := Data.Value;
      end else begin
        RaiseStWin32Error(EStNetException, ErrorD);
      end;
    except
      StNetApiBufferFree(Data.Value);
      raise;
    end;
  end;
end;

procedure TStNetUserItem.SetScriptPath(Value: string);
var
  ErrorD  : DWord;
  ParmErr : DWord;
  Data    : TLMWideChar;
begin
  if Value <> ScriptPath then begin
    Data.Value := nil;
    try
      CvtToWideCharLM(Value, Data);
      ErrorD := StNetUserSetInfo(FServer, FName, 1009, @Data.Value, ParmErr);
      if ErrorD = NERR_SUCCESS then begin
        StNetApiBufferFree(TUSER_INFO_3(FUserData^).usri3_script_path);
        TUSER_INFO_3(FUserData^).usri3_script_path := Data.Value;
      end else begin
        RaiseStWin32Error(EStNetException, ErrorD);
      end;
    except
      StNetApiBufferFree(Data.Value);
      raise;
    end;
  end;
end;

procedure TStNetUserItem.SetUserComment(Value: string);
var
  ErrorD  : DWord;
  ParmErr : DWord;
  Data    : TLMWideChar;
begin
  if Value <> UserComment then begin
    Data.Value := nil;
    try
      CvtToWideCharLM(Value, Data);
      ErrorD := StNetUserSetInfo(FServer, FName, 1012, @Data.Value, ParmErr);
      if ErrorD = NERR_SUCCESS then begin
        StNetApiBufferFree(TUSER_INFO_3(FUserData^).usri3_usr_comment);
        TUSER_INFO_3(FUserData^).usri3_usr_comment := Data.Value;
      end else begin
        RaiseStWin32Error(EStNetException, ErrorD);
      end;
    except
      StNetApiBufferFree(Data.Value);
      raise;
    end;
  end;
end;

procedure TStNetUserItem.SetWorkstations(Value: TStrings);
var
  ErrorD  : DWord;
  ParmErr : DWord;
  Data    : TLMWideChar;
begin
  if Value.CommaText <> WorkStations.CommaText then begin
    Data.Value := nil;
    try
      CvtToWideCharLM(Value.CommaText, Data);
      ErrorD := StNetUserSetInfo(FServer, FName, 1014, @Data.Value, ParmErr);
      if ErrorD = NERR_SUCCESS then begin
        StNetApiBufferFree(TUSER_INFO_3(FUserData^).usri3_workstations);
        TUSER_INFO_3(FUserData^).usri3_workstations := Data.Value;
      end else begin
        RaiseStWin32Error(EStNetException, ErrorD);
      end;
    except
      StNetApiBufferFree(Data.Value);
      raise;
    end;
  end;
end;

procedure TStNetUserItem.GetLogonHours(var LogonHours: TStNetUserLogonTimes);
{$IFNDEF VERSION4}
const
  TIME_ZONE_ID_INVALID  = DWORD($FFFFFFFF);
  TIME_ZONE_ID_UNKNOWN  = 0;
  TIME_ZONE_ID_STANDARD = 1;
  TIME_ZONE_ID_DAYLIGHT = 2;
{$ENDIF}
type
  LHFlags = array[0..167] of Boolean;
  TLHData = array[TStDayType] of array[0..2] of Byte;
var
  Data        : TLHData;
  GMTOffset   : Integer;
  BitOffset   : Integer;
  DayOfWeek   : Integer;
  HourOfDay   : Integer;
  TZ          : TTimeZoneInformation;
const
  BitFlags : array[0..7] of byte = ($01, $02, $04, $08, $10, $20, $40, $80);
begin
  if (FUserData = nil) then
    Refresh;

  case GetTimeZoneInformation(TZ) of
    TIME_ZONE_ID_UNKNOWN :
      GMTOffset := TZ.Bias div MinutesInHour;
    TIME_ZONE_ID_STANDARD:
      GMTOffset := (TZ.Bias + TZ.StandardBias) div MinutesInHour;
    TIME_ZONE_ID_DAYLIGHT:
      GMTOffset := (TZ.Bias + TZ.DaylightBias) div MinutesInHour;
  else
    GMTOffset := 0;
  end;
  Data := TLHData(TUSER_INFO_3(FUserData^).usri3_logon_hours^);

  { Populate the logon hours array with correct information adjusted for GMT}
  for DayOfWeek := Ord(Sunday) to Ord(Saturday) do begin
    for HourOfDay := 0 to HoursInDay-1 do begin

      { Get the correct offset into the array of booleans }
      BitOffset := -(GMTOffset) + ((DayOfWeek * HoursInDay) + HourOfDay);
      if BitOffset > 168 then
        Dec(BitOffset, 168)
      else if BitOffset < 1 then
        Inc(BitOffset, 168);

      { set the correct True or False flag in the array  }
      LHFlags(LogonHours)[BitOffset-1] :=
        ByteFlagIsSet(Data[TStDayType(DayOfWeek)][HourOfDay div 8],
                      BitFlags[HourOfDay mod 8]);
    end;
  end;
end;

procedure TStNetUserItem.SetLogonHours(LogonHours: TStNetUserLogonTimes);
{$IFNDEF VERSION4}
const
  TIME_ZONE_ID_INVALID  = DWORD($FFFFFFFF);
  TIME_ZONE_ID_UNKNOWN  = 0;
  TIME_ZONE_ID_STANDARD = 1;
  TIME_ZONE_ID_DAYLIGHT = 2;
{$ENDIF}
type
  LHFlags = array[0..167] of Boolean;
  TLHData = array[TStDayType] of array[0..2] of Byte;
var
  Data      : TLHData;
  GMTOffset : Integer;
  BitOffset : Integer;
  DayOfWeek : Integer;
  HourOfDay : Integer;
  TZ        : TTimeZoneInformation;
  USER_INFO : TUSER_INFO_1020;
  ErrorD    : DWord;
  ParmErr   : DWord;
const
  BitFlags : array[0..7] of byte = ($01, $02, $04, $08, $10, $20, $40, $80);
begin
  if (FUserData = nil) then
    Refresh;

  case GetTimeZoneInformation(TZ) of
    TIME_ZONE_ID_UNKNOWN :
      GMTOffset := TZ.Bias div MinutesInHour;
    TIME_ZONE_ID_STANDARD:
      GMTOffset := (TZ.Bias + TZ.StandardBias) div MinutesInHour;
    TIME_ZONE_ID_DAYLIGHT:
      GMTOffset := (TZ.Bias + TZ.DaylightBias) div MinutesInHour;
  else
    GMTOffset := 0;
  end;

  { Default to ALL hours for logon }
  FillChar(Data, SizeOf(Data), 255);

  { Populate the logon hours structure with correct information }
  for DayOfWeek := Ord(Sunday) to Ord(Saturday) do begin
    for HourOfDay := 0 to HoursInDay-1 do begin

      { Get the correct offset into the array of booleans }
      BitOffset := -(GMTOffset) + ((DayOfWeek * HoursInDay) + HourOfDay);
      if BitOffset > 168 then
        Dec(BitOffset, 168)
      else if BitOffset < 1 then
        Inc(BitOffset, 168);

      { just set the True logon hours (already set to False) }
      if not LHFlags(LogonHours)[BitOffset-1] then
        ClearByteFlag(Data[TStDayType(DayOfWeek)][HourOfDay div 8],
                      BitFlags[HourOfDay mod 8]);
    end;
  end;

  { Update the server with the new logon hours }
  USER_INFO.usri1020_logon_hours    := @Data;
  USER_INFO.usri1020_units_per_week := UNITS_PER_WEEK;
  ErrorD := StNetUserSetInfo(FServer, FName, 1020, @USER_INFO, ParmErr);
  if ErrorD = NERR_SUCCESS then begin
    TUSER_INFO_3(FUserData^).usri3_logon_hours := @Data;
  end else begin
    RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;


{ --- TStNetGroupItem ------------------------------------------------------- }

constructor TStNetGroupItem.CreateEx(AName, AComment, AServer: string;
                                     AItemType: TStNetItemType);
var
  Buffer : Pointer;
  ErrorD : DWord;
begin
  inherited CreateEx(AName, AComment, AServer, AItemType);

  FItemList := TStringList.Create;
  FillChar(FSidRecord, SizeOf(TStSidRecord), 0);

  { need to find out what type of group this is }
  if (AItemType = nitUnknown) or ((AItemType = nitGlobalGroup) and (FID = 0)) then begin
    ErrorD := StNetGroupGetInfo(FServer, FName, 2, Buffer);
    if ErrorD = NERR_SUCCESS then begin
      try
        FItemType := nitGlobalGroup;
        FID       := TGROUP_INFO_2(Buffer^).grpi2_group_id;
        FComment  := TGROUP_INFO_2(Buffer^).grpi2_comment;
      finally
        StNetApiBufferFree(Buffer);
        Buffer := nil;
      end;
    end else begin
      { its not a global group ... try a local one }
      ErrorD := StNetLocalGroupGetInfo(FServer, FName, 1, Buffer);
      if ErrorD = NERR_SUCCESS then begin
        try
          FItemType := nitLocalGroup;
          FComment := TLOCALGROUP_INFO_1(Buffer^).lgrpi1_comment;
        finally
          StNetApiBufferFree(Buffer);
          Buffer := nil;
        end;
      end else begin
        RaiseStWin32Error(EStNetException, ErrorD);
      end;
    end;
  end;
end;

constructor TStNetGroupItem.CreateExEnum(AName, AComment, AServer: string;
                                         AID: Cardinal);
begin
  inherited CreateEx(AName, AComment, AServer, nitUnknown);
  FItemList := TStringList.Create;

  FID := AID;

  if AID > 0 then
    FItemType := nitGlobalGroup
  else
    FItemType := nitLocalGroup;
end;

destructor TStNetGroupItem.Destroy;
begin
  FItemList.Free;