private UserActivityState CheckMaster(IUser user, UserActivityState result)
{
var usrvb = user as IUserServiceBound;
var usersrv = UserService;
if (null != usrvb)
{
usersrv = usrvb.UserService ?? usersrv;
}
if (null == usersrv)
{
result |= UserActivityState.MasterNotChecked;
}
else
{
var grp = usersrv.GetUser(user.Domain + "@groups");
if (null == grp)
{
result |= UserActivityState.InvalidMaster;
}
else
{
if (!grp.Active)
{
result |= UserActivityState.MasterBaned;
}
if (grp.Expire < DateTime.Now)
{
result |= UserActivityState.MasterExpired;
}
}
}
return(result);
}
/// <summary>
/// Disables the activity timer and associated events
/// </summary>
public void Disable()
{
// Ignore if already disabled
if (this._timerEnabled)
{
this.activityCheckerTimer.Change(Timeout.Infinite, Timeout.Infinite);
this._timerEnabled = false;
this._userActiveState = UserActivityState.Unknown;
this.activityStopWatch.Stop();
}
}
/// <summary>
/// Resets the elapsed activity time to zero and continues measuring.
/// </summary>
public void Reset()
{
_activityStopWatch.Reset();
UserActiveState = UserActivityState.Unknown;
LastResetTime = DateTime.Now;
if (Enabled && !Started)
{
_activityStopWatch.Start();
}
}
/// <summary>
/// Resets the elapsed activity time to zero and continues measuring.
/// </summary>
public void Reset()
{
activityStopWatch.Reset();
this._userActiveState = UserActivityState.Unknown;
this._lastResetTime = DateTime.Now;
if (this._timerEnabled)
{
activityStopWatch.Start();
}
}
private static UserActivityState CheckSelf(IUser user, UserActivityState result)
{
if (!user.Active)
{
result |= UserActivityState.Baned;
}
if (user.Expire < DateTime.Now)
{
result |= UserActivityState.Expired;
}
return(result);
}
/// <summary>
/// Starts the activity timer
/// </summary>
public override void Start()
{
if (Enabled && !Started)
{
Started = true;
_activityCheckerTimer.Change(0, 1000);
_activityStopWatch.Start();
UserActiveState = UserActivityState.Active;
OnMonitorStarted(new MonitorEventArgs {
MonitorType = GetType(), Reason = Resources.UserActivityMonitorStartedEventReason, Details = Resources.UserActivityMonitorDetails
});
}
}
/// <summary>
/// Stops the activity timer
/// </summary>
public override void Stop()
{
if (Started)
{
Started = false;
_activityCheckerTimer.Change(Timeout.Infinite, Timeout.Infinite);
UserActiveState = UserActivityState.Unknown;
_activityStopWatch.Stop();
OnMonitorStopped(new MonitorEventArgs {
MonitorType = GetType(), Reason = Resources.UserActivityMonitorStoppedEventReason, Details = Resources.UserActivityMonitorDetails
});
}
}
private void _sampler(CancellationToken c)
{
var was_called = false;
_state = UserActivityState.Active;
while (true)
{
if (c.IsCancellationRequested)
{
break;
}
Thread.Sleep(_frequency);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (c.IsCancellationRequested) //might change after a delay.
{
break;
}
if (GetLastInputTime() >= _timeout) //timedout. 1533 >= 500
{
if (was_called)
{
continue; //has already called b4?
}
was_called = true; //was -> set called now.
_state = UserActivityState.Idle;
if (Idled != null) //call
{
Idled();
}
}
else //didn't timeout, set not called.
{
_state = UserActivityState.Active;
if (was_called) //moved from idle to active
{
was_called = false;
if (Returned != null)
{
Returned();
}
}
}
}
}
/// <summary>
/// Checks to see the last activity timestamp and compares is to the idle threshold.
/// Will trigger appropriate events if state changes.
/// </summary>
/// <param name="userState">Ignored - required for ThreadStart delegate</param>
private void GetLastInput(object userState)
{
GetLastInputInfo(ref this.lastInput);
this._lastActivity = this.lastInput.dwTime;
if ((Environment.TickCount - this.lastInput.dwTime) > this._idleThreshold)
{
if (this._userActiveState != UserActivityState.Inactive)
{
this._userActiveState = UserActivityState.Inactive;
this.activityStopWatch.Stop();
this.RaiseUserIdleEvent();
}
}
else if (this._userActiveState != UserActivityState.Active)
{
this._userActiveState = UserActivityState.Active;
this.activityStopWatch.Start();
this.RaiseUserActiveEvent();
}
}
public static string GetInfo(this UserActivityState state)
{
switch (state)
{
case UserActivityState.Ok:
return("OK");
case UserActivityState.Baned:
return("Учетная запись отключена");
case UserActivityState.Expired:
return("Лицензия пользователя завершена");
case UserActivityState.InvalidLogonInfo:
return("Неверное имя пользователя или пароль");
case UserActivityState.InvalidMaster:
return("Неверная настройка домена");
case UserActivityState.MasterBaned:
return("Учетная запись домена отключена");
case UserActivityState.MasterExpired:
return("Лицензия домена завершена");
case UserActivityState.MasterNotChecked:
return("Технические проблемы проверки домена");
case UserActivityState.None:
return("Неопределенный статус");
case UserActivityState.Error:
return("Ошибка обработки");
default:
throw new Exception("Неизвестный статус " + state);
}
}
/// <summary>
/// Checks to see the last activity timestamp and compares is to the idle threshold.
/// Will trigger appropriate events if state changes.
/// </summary>
/// <param name="userState">Ignored - required for ThreadStart delegate</param>
private void GetLastInput(object userState)
{
SafeNativeMethods.GetLastInputInfo(ref _lastInput);
if ((Environment.TickCount - _lastInput.dwTime) > IdleThreshold)
{
if (UserActiveState == UserActivityState.Active)
{
UserActiveState = UserActivityState.Inactive;
_activityStopWatch.Stop();
OnMonitorTriggered(new MonitorEventArgs {
MonitorType = GetType(), Reason = string.Format(CultureInfo.CurrentCulture, Resources.UserActivityMonitorTriggeredEventIdleReason, IdleThreshold / 1000), Details = Resources.UserActivityMonitorDetails
});
}
}
else if (UserActiveState == UserActivityState.Inactive)
{
UserActiveState = UserActivityState.Active;
_activityStopWatch.Start();
OnMonitorTriggered(new MonitorEventArgs {
MonitorType = GetType(), Reason = Resources.UserActivityMonitorTriggeredEventActiveReason, Details = Resources.UserActivityMonitorDetails
});
}
}
private void GenerateComments()
{
UserActivityState New()
{
var ret = new UserActivityState {
Type = (UserActivityType)RandomGenerationData.Random.Next(3),
User = Users.ElementAt(RandomGenerationData.Random.Next(Users.Count)).Summarize(),
CreationDate = DateTime.Now.AddHours(-RandomGenerationData.Random.Next(1000))
};
switch (ret.Type)
{
case UserActivityType.Commented:
ret.Comment = RandomGenerationData.CommentList[RandomGenerationData.Random.Next(RandomGenerationData.CommentList.Count)];
break;
}
return(ret);
}
for (var i = 0; i < ActivitiesNumber; i++)
{
Activities.AddLast(New());
}
}
public void Reset() {
_sampler_canceller.Cancel();
_state = UserActivityState.Unknown;
_start();
}
private void _sampler(CancellationToken c) {
var was_called = false;
_state = UserActivityState.Active;
while (true) {
if (c.IsCancellationRequested)
break;
Thread.Sleep(_frequency);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (c.IsCancellationRequested) //might change after a delay.
break;
if (GetLastInputTime() >= _timeout) { //timedout. 1533 >= 500
if (was_called) continue; //has already called b4?
was_called = true; //was -> set called now.
_state = UserActivityState.Idle;
if (Idled != null) //call
Idled();
} else { //didn't timeout, set not called.
_state = UserActivityState.Active;
if (was_called) { //moved from idle to active
was_called = false;
if (Returned != null)
Returned();
}
}
}
}
/// <summary>
/// Checks to see the last activity timestamp and compares is to the idle threshold.
/// Will trigger appropriate events if state changes.
/// </summary>
/// <param name="userState">Ignored - required for ThreadStart delegate</param>
private void GetLastInput(object userState)
{
GetLastInputInfo(ref this.lastInput);
this._lastActivity = this.lastInput.dwTime;
if ((Environment.TickCount - this.lastInput.dwTime) > this._idleThreshold)
{
if (this._userActiveState != UserActivityState.Inactive)
{
this._userActiveState = UserActivityState.Inactive;
this.activityStopWatch.Stop();
this.RaiseUserIdleEvent();
}
}
else if (this._userActiveState != UserActivityState.Active)
{
this._userActiveState = UserActivityState.Active;
this.activityStopWatch.Start();
this.RaiseUserActiveEvent();
}
}
/// <summary>
/// Resets the elapsed activity time to zero and continues measuring.
/// </summary>
public void Reset()
{
activityStopWatch.Reset();
this._userActiveState = UserActivityState.Unknown;
this._lastResetTime = DateTime.Now;
if (this._timerEnabled)
{
activityStopWatch.Start();
}
}
/// <summary>
/// Disables the activity timer and associated events
/// </summary>
public void Disable()
{
// Ignore if already disabled
if (this._timerEnabled)
{
this.activityCheckerTimer.Change(Timeout.Infinite, Timeout.Infinite);
this._timerEnabled = false;
this._userActiveState = UserActivityState.Unknown;
this.activityStopWatch.Stop();
}
}
public void Reset()
{
_sampler_canceller.Cancel();
_state = UserActivityState.Unknown;
_start();
}
