public virtual void Handle(
LogUi ui,
AccessLevel newLevel,
string name)
{
var r = this.runner;
r?.Run <SettingsHolder, UiReaderWriter>(
(settings, uiRW) =>
{
var akv = newLevel >= settings.EditLevel;
var ckv = newLevel >= settings.ClearLevel;
uiRW.Write(
ui,
() =>
{
if (ui == null)
{
return;
}
ui.AddKeyVisible = akv;
ui.ClearKeyVisible = ckv;
});
},
name);
}
public LogPresenter(
LogUi ui,
ShellUi shell,
MethodRunner runner)
: base(ui, shell)
{
this.ui = ui;
this.runner = runner;
}
public virtual void Handle(
Do <string> presentStats,
LogUi ui,
string name)
{
var r = this.runner;
presentStats?.Invoke(name);
}
public virtual void Handle(
LogUi ui,
string name,
LogEntry entry)
{
const byte one = 1;
var r = this.runner;
r?.Run <FieldHolder, UiReaderWriter, FilterChecker>(
(holder, uiRW, checker) =>
{
var today = DateTime.Today;
r.Run <TimeProvider>(provider =>
{
today = provider.Now().Date;
});
if (uiRW.Read(ui, () => ui?.EndDate) < today)
{
return;
}
if (Interlocked.Read(ref holder.startedIf1) != one)
{
if (Interlocked.Read(ref holder.startedFirstTimeIf1) ==
one && checker.PassesFilters(ui, entry))
{
r.Run <ICollection <LogEntry> >(
refreshEntries =>
{
refreshEntries.Add(entry);
},
name);
}
return;
}
if (checker.PassesFilters(ui, entry))
{
r.Run <EntryConverter>(converter =>
{
var xt = converter.Convert(entry, name);
uiRW.Write(
ui,
() =>
{
ui?.AddToTop(xt);
});
});
}
},
name);
}
public SetupLogCommand(
LogUi ui,
ShellUi shell,
SettingsHolder settings,
MethodWeb web)
{
this.ui = ui;
this.shell = shell;
settings = settings
?? new SettingsHolder();
settings.StatisticsEnabled = falsity;
this.settings = settings;
this.web = web;
}
public virtual void Handle(
LogUi ui,
string name)
{
var r = this.runner;
r?.Run <FieldHolder>(fields =>
{
Interlocked.Exchange(
ref fields.startedIf1,
0);
},
name);
}
public SetupLogCommand(
LogUi ui,
ShellUi shell,
LogEditorUi editUi,
LogStatisticsUi statsUi,
SettingsHolder settings,
MethodWeb web)
{
this.ui = ui;
this.editUi = editUi;
this.shell = shell;
this.statsUi = statsUi;
settings = settings
?? new SettingsHolder();
settings.StatisticsEnabled = truth;
this.settings = settings;
this.web = web;
}
public virtual void Handle(
LogUi ui,
string name)
{
var r = this.runner;
r?.Run <FieldHolder>(fields =>
{
if (Interlocked.Read(ref fields.startedIf1) == 1)
{
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
return;
}
Interlocked.Exchange(
ref fields.refreshOnStartIf1,
1);
},
name);
}
public virtual void Handle(
LogUi ui,
string name)
{
var r = this.runner;
r?.Run <SettingsHolder, UiReaderWriter>(
(settings, uiRW) =>
{
const AccessLevel zeroAccess = AccessLevel.None;
var addKeyVisible = settings.EditLevel == zeroAccess;
var clearKeyVisible = settings.ClearLevel == zeroAccess;
var statisticsKeyVisible = settings.StatisticsEnabled;
const string emptyString = @"";
uiRW.WriteSync(ui, () =>
{
if (ui == null)
{
return;
}
ui.AddKeyVisible = addKeyVisible;
ui.ClearKeyVisible = clearKeyVisible;
ui.StatisticsKeyVisible = statisticsKeyVisible;
ui.FilterType = emptyString;
ui.FilterContent = emptyString;
});
r.Run <TimeProvider>(provider =>
{
var today = provider.Now().Date;
var lastWeek = today.AddDays(-6).Date;
uiRW.WriteSync(
ui,
() =>
{
if (ui == null)
{
return;
}
ui.EndDate = today;
ui.StartDate = lastWeek;
});
});
},
name);
if (ui is LogUiV2 v2)
{
r?.Run <LabelApplier>(applier =>
{
applier.Apply(v2);
});
}
if (ui is LogUiV3 v3)
{
r?.Run <CurrentWeekKeyTappedHandler>(handler =>
{
handler.Handle(
v3,
name,
null,
null);
});
}
}
public virtual bool PassesFilters(
LogUi ui,
LogEntry entry)
{
if (entry == null)
{
return(false);
}
var r = this.runner;
var passed = false;
r?.Run <UiReaderWriter>(uiRW =>
{
var start = uiRW.Read(
ui,
() => ui?.StartDate);
var end = uiRW.Read(
ui,
() => ui?.EndDate);
if (entry.Timestamp < start)
{
return;
}
if (entry.Timestamp > end?.AddDays(1))
{
return;
}
var filterType = uiRW.Read(
ui,
() => ui?.FilterType);
filterType = filterType?.ToLowerInvariant();
var entryType = entry?.Type;
if (filterType != null)
{
if (!entryType
?.ToLowerInvariant()
.Contains(filterType
?.ToLowerInvariant()) ?? true)
{
return;
}
}
var filterContent = uiRW.Read(
ui,
() => ui?.FilterContent);
filterContent = filterContent?.ToLowerInvariant();
var entryContent = entry?.Content;
if (filterContent != null)
{
if (EnumerableHelpers.All(
entryContent,
s => !s
?.ToLowerInvariant()
?.Contains(filterContent
?.ToLowerInvariant()) ?? true))
{
return;
}
}
passed = true;
});
return(passed);
}
public virtual void Handle(
LogUi ui,
string name)
{
var r = this.runner;
var response = Response.No;
Gen <string> computeBackupLocation = null;
r?.Run <
SettingsHolder,
Messenger,
Labels,
UiReaderWriter>(
(settings, m, labels, uiRW) =>
{
computeBackupLocation = settings.ComputeBackupLocation;
if (computeBackupLocation == null)
{
response = uiRW.Read(
m.Subscriber,
() => m.Question(
labels.ClearNoBackupQuestion));
return;
}
response = uiRW.Read(
m.Subscriber,
() => m.Question(
labels.ClearWithBackupQuestion));
},
name);
if (response != Response.Yes)
{
return;
}
r?.Run <
SettingsHolder,
LogEditor,
Labels>((settings, le, labels) =>
{
if (computeBackupLocation != null)
{
var bl = computeBackupLocation();
try
{
le.Clear(bl);
}
catch
{
return;
}
le.AddEntry(
DefaultEntryTypes.Information,
new[]
{
labels.ClearedWithBackup(bl)
});
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
return;
}
try
{
le.Clear();
}
catch
{
return;
}
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
le.AddEntry(
DefaultEntryTypes.Information,
new[]
{
labels.ClearedNoBackup
});
},
name,
name);
}
public virtual void Reload(
LogUi ui,
string name)
{
var r = this.runner;
r?.Run <Log, UiReaderWriter, EntryConverter>(
(log, uiRW, converter) =>
{
var start = uiRW.Read(ui, () => ui?.StartDate);
var end = uiRW.Read(ui, () => ui?.EndDate);
var filterContent = uiRW.Read(
ui,
() => ui?.FilterContent);
var filterType = uiRW.Read(
ui,
() => ui?.FilterType);
const string emptyString = @"";
// first, begin reading all entries
var matchingEntries = log.ReadEntries();
// second, get all the entries in the date range
matchingEntries = EnumerableHelpers.Where(
matchingEntries,
e => e.Timestamp >= start &&
e.Timestamp < end?.AddDays(1));
// third, match on content
if (!StringHelpers.NullOrWhiteSpace(filterContent))
{
matchingEntries = EnumerableHelpers.Where(
matchingEntries,
e => EnumerableHelpers.Any(
e.Content,
s => s
?.ToLowerInvariant()
?.Contains(
filterContent?.ToLowerInvariant()
?? emptyString) ??
false));
}
// fourth, match on type
if (!StringHelpers.NullOrWhiteSpace(filterType))
{
matchingEntries = EnumerableHelpers.Where(
matchingEntries,
e => e
?.Type
?.ToLowerInvariant()
?.Contains(
filterType?.ToLowerInvariant()
?? emptyString) ??
false);
}
// finally, order them by newest first
matchingEntries = EnumerableHelpers.OrderByDescending(
matchingEntries,
e => e.Timestamp);
ICollection <XTuple <string, string, string> > uiEntries
= new LinkedList <XTuple <string, string, string> >(
EnumerableHelpers.Select(
matchingEntries,
entry => converter.Convert(
entry,
name)));
uiRW.WriteSync(
ui,
() =>
{
if (ui == null)
{
return;
}
ui.Entries = uiEntries;
});
r.Run <ICollection <LogEntry> >(
refreshEntries =>
{
refreshEntries.Clear();
},
name);
},
name);
}
public virtual void Handle(
LogUi ui,
Do unsubscribe,
Do subscribe,
string name)
{
var r = this.runner;
r?.Run <FieldHolder, Log, SettingsHolder>(
(fields, log, settings) =>
{
Interlocked.Exchange(
ref fields.startedIf1,
1);
if (Interlocked.Exchange(
ref fields.startedFirstTimeIf1,
1) != 1)
{
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
return;
}
if (Interlocked.Exchange(
ref fields.refreshOnStartIf1,
0) == 1)
{
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
return;
}
if (settings.ResetOnStart)
{
r.Run <DateAndFilterResetter>(resetter =>
{
resetter.Reset(
ui,
unsubscribe,
subscribe,
name);
});
return;
}
r.Run <
ICollection <LogEntry>,
UiReaderWriter,
EntryConverter>(
(refreshEntries, uiRW, converter) =>
{
foreach (var entry in refreshEntries)
{
var xt = converter.Convert(entry, name);
uiRW.WriteSync(
ui,
() =>
{
ui?.AddToTop(xt);
});
}
},
name);
},
name,
name,
name);
}
public virtual void Reset(
LogUi ui,
Do unsubscribe,
Do subscribe,
string name)
{
const byte zero = 0;
const byte one = 1;
const byte six = 6;
var r = this.runner;
r?.Run <FieldHolder, Delayer, UiReaderWriter>(
(fields, delayer, uiRW) =>
{
while (Interlocked.Exchange(
ref fields.resettingIf1,
one) == one)
{
delayer.Delay(zero);
}
var today = System.DateTime.Today;
r.Run <TimeProvider>(provider =>
{
today = provider.Now().Date;
});
var lastWeek = today.Subtract(System.TimeSpan.FromDays(six));
var needsReload = true;
var started = Interlocked.Read(ref fields.startedIf1) == one;
if (uiRW.Read(ui, () => ui?.StartDate) == lastWeek &&
uiRW.Read(ui, () => ui?.EndDate) == today &&
uiRW.Read(ui, () => ui?.FilterContent) == string.Empty &&
uiRW.Read(ui, () => ui?.FilterType) == string.Empty)
{
if (started && Interlocked.Read(
ref fields.startedFirstTimeIf1) == one)
{
needsReload = false;
}
}
Interlocked.Exchange(
ref fields.refreshOnStartIf1,
zero);
if (started && needsReload)
{
unsubscribe?.Invoke();
uiRW.WriteSync(ui, () =>
{
if (ui == null)
{
return;
}
ui.StartDate = lastWeek;
ui.EndDate = today;
ui.FilterType = string.Empty;
ui.FilterContent = string.Empty;
});
r.Run <EntryReloader>(reloader =>
{
reloader.Reload(ui, name);
});
subscribe?.Invoke();
}
Interlocked.Exchange(
ref fields.resettingIf1,
zero);
},
name);
}
