internal Page(int number, DictionaryToken dictionary, MediaBox mediaBox, CropBox cropBox, PageRotationDegrees rotation, PageContent content,
AnnotationProvider annotationProvider,
IPdfTokenScanner pdfScanner)
{
if (number <= 0)
{
throw new ArgumentOutOfRangeException(nameof(number), "Page number cannot be 0 or negative.");
}
Dictionary = dictionary ?? throw new ArgumentNullException(nameof(dictionary));
Number = number;
MediaBox = mediaBox;
CropBox = cropBox;
Rotation = rotation;
Content = content;
textLazy = new Lazy <string>(() => GetText(Content));
Width = mediaBox.Bounds.Width;
Height = mediaBox.Bounds.Height;
Size = mediaBox.Bounds.GetPageSize();
ExperimentalAccess = new Experimental(this, annotationProvider);
this.annotationProvider = annotationProvider;
this.pdfScanner = pdfScanner ?? throw new ArgumentNullException(nameof(pdfScanner));
}
public void SaveSuccsefulExperimentalSession(Experimental newSession)
{
if (null == PacientsData[CurrentPacient.ID].lastExperimentalSessions)
{
PacientsData[CurrentPacient.ID].lastExperimentalSessions = new List <Experimental>();
}
bool alreadyExists = false;
int existsIndex = -1;
for (int i = 0; i < PacientsData[CurrentPacient.ID].lastExperimentalSessions.Count && !alreadyExists; i++)
{
if (PacientsData[CurrentPacient.ID].lastExperimentalSessions[i].tone.FrequencyIndex == newSession.tone.FrequencyIndex)
{
if (PacientsData[CurrentPacient.ID].lastExperimentalSessions[i].tone.Ear == newSession.tone.Ear)
{
alreadyExists = true;
existsIndex = i;
}
}
}
if (alreadyExists)
{
PacientsData[CurrentPacient.ID].lastExperimentalSessions[existsIndex] = newSession;
}
else
{
PacientsData[CurrentPacient.ID].lastExperimentalSessions.Add(newSession);
}
PacientsData[CurrentPacient.ID].lastTestDate = DateTime.Now.ToString("dd/MM/yyyy");
SavePacientData();
}
public override void SessionEnd(bool sessionSucceeded)
{
OngoingTest = false;
if (sessionSucceeded)
{
DataManager.Instance.SaveSuccsefulExperimentalSession(currentSession as Experimental);
if (toneManager.currentDB > ToneSettingsManager.dbMin)
{
toneManager.DecreaseDB();
heardFreq = true;
}
else
{
NextFrequency();
}
if (null == onLimitSucceedSession)
{
onLimitSucceedSession = currentSession as Experimental;
preOnPostText[1].text = frequencies[currentSession.tone.FrequencyIndex] + " Hz\n" + currentSession.tone.dB + " dB";
}
else
{
postLimitSucceedSession = onLimitSucceedSession;
onLimitSucceedSession = currentSession as Experimental;
preOnPostText[1].text = frequencies[currentSession.tone.FrequencyIndex] + " Hz\n" + currentSession.tone.dB + " dB";
preOnPostText[2].text = frequencies[postLimitSucceedSession.tone.FrequencyIndex] + " Hz\n" + postLimitSucceedSession.tone.dB + " dB";
}
}
else
{
if (!heardFreq || toneManager.currentDB == ToneSettingsManager.dbMax)
{
toneManager.IncreaseVolume();
toneManager.IncreaseVolume();
}
else
{
NextFrequency();
}
preLimitFailedSession = currentSession as Experimental;
preOnPostText[0].text = frequencies[currentSession.tone.FrequencyIndex] + " Hz\n" + currentSession.tone.dB + " dB";
}
//ledLight.SetTrigger("Off");
currentSession = null;
}
public async Task <MyChatsAndTeams?> GetUpdatedChatsAndTeamsAsync(TeamsDataContext ctx)
{
logger.Debug("[{TenantName}] {Method}: Starting to update chats", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync));
var toBeUpdatedChatsAndTeams = await GetAllChatsAndTeamsAsync(ctx);
if (toBeUpdatedChatsAndTeams == null)
{
logger.Debug("[{TenantName}] {Method}: Initial list of chats is null; leaving", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync));
// error while retrieving all data? cannot retrieve update either
return(null);
}
if (string.IsNullOrWhiteSpace(toBeUpdatedChatsAndTeams.metadata?.syncToken))
{
logger.Debug("[{TenantName}] {Method}: Initial list of chats contains no sync token but we need one to update; leaving", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync));
// cannot get update if there is no sync token
return(toBeUpdatedChatsAndTeams);
}
var deltaChatsAndTeams = await teamsTenantApiAccessor.GetMyChatsAndTeamsAsync(ctx, toBeUpdatedChatsAndTeams.metadata.syncToken);
if (deltaChatsAndTeams == null)
{
logger.Debug("[{TenantName}] {Method}: Got null as delta result; leaving", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync));
return(toBeUpdatedChatsAndTeams);
}
logger.Debug("[{TenantName}] {Method}: {ChatCount} chats are new or updated with old sync token {SyncToken}", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync), toBeUpdatedChatsAndTeams.chats.Count, toBeUpdatedChatsAndTeams.metadata.syncToken.FromBase64String());
Experimental.CheckForActiveMeeting(logger, ctx, deltaChatsAndTeams);
var oldChatsToReplace = toBeUpdatedChatsAndTeams.chats.Where(oldValue => deltaChatsAndTeams.chats.FirstOrDefault(updatedValue => updatedValue?.id == oldValue?.id) != default);
logger.Debug("[{TenantName}] {Method}: {ChatCount} old chats need an update", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync), oldChatsToReplace.Count());
foreach (var oldChat in oldChatsToReplace.ToList())
{
toBeUpdatedChatsAndTeams.chats.Remove(oldChat);
}
toBeUpdatedChatsAndTeams.chats.AddRange(deltaChatsAndTeams.chats);
teamsTenantApiAccessor.SortChats(toBeUpdatedChatsAndTeams);
logger.Debug("[{TenantName}] {Method}: Updating sync token to {SyncToken}", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync), deltaChatsAndTeams.metadata.syncToken.FromBase64String());
toBeUpdatedChatsAndTeams.metadata.syncToken = deltaChatsAndTeams.metadata.syncToken;
await BlobCache.UserAccount.InsertObject($"ts.{ctx.Tenant.UserId}.chatsAndTeams", toBeUpdatedChatsAndTeams, DateTimeOffset.Now + TimeSpan.FromDays(ChatsAndTeamsCacheLifetimeDays));
logger.Debug("[{TenantName}] {Method}: Done", ctx.Tenant.TenantName, nameof(GetUpdatedChatsAndTeamsAsync));
return(toBeUpdatedChatsAndTeams);
}
/// <summary>
/// Two DnsResourceDataKey are equal iff their authentication prohibited, confidentiality prohibited, experimental, user associated, IPSec, email,
/// name type, signatory, protocol, algorithm, flags extension and public key fields are equal.
/// </summary>
public bool Equals(DnsResourceDataKey other)
{
return(other != null &&
AuthenticationProhibited.Equals(other.AuthenticationProhibited) &&
ConfidentialityProhibited.Equals(other.ConfidentialityProhibited) &&
Experimental.Equals(other.Experimental) &&
UserAssociated.Equals(other.UserAssociated) &&
IpSec.Equals(other.IpSec) &&
Email.Equals(other.Email) &&
NameType.Equals(other.NameType) &&
Signatory.Equals(other.Signatory) &&
Protocol.Equals(other.Protocol) &&
Algorithm.Equals(other.Algorithm) &&
(FlagsExtension.HasValue
? other.FlagsExtension.HasValue && FlagsExtension.Value.Equals(other.FlagsExtension.Value)
: !other.FlagsExtension.HasValue) &&
PublicKey.Equals(other.PublicKey));
}
internal Page(int number, MediaBox mediaBox, CropBox cropBox, PageContent content)
{
if (number <= 0)
{
throw new ArgumentOutOfRangeException(nameof(number), "Page number cannot be 0 or negative.");
}
Number = number;
MediaBox = mediaBox;
CropBox = cropBox;
Content = content;
Text = GetText(content);
Width = mediaBox.Bounds.Width;
Height = mediaBox.Bounds.Height;
Size = mediaBox.Bounds.GetPageSize();
ExperimentalAccess = new Experimental(this);
}
private IEnumerator ExperimentalRoutine()
{
int numberOfTones = 0;
StartTest();
while (!IsExperimentalComplete())
{
currentSession = new Experimental(toneManager.freqIndex, toneManager.currentDB, this, ear);
pacientButton.onButtonDown.AddListener(currentSession.PacientButtonDown);
pacientButton.onButtonUp.AddListener(currentSession.PacientButtonUp);
pacientButton.onButtonDown.AddListener(LedOn);
pacientButton.onButtonUp.AddListener(LedOff);
numberOfTones = Random.Range(1, 3);
for (int i = 0; i < numberOfTones; i++)
{
(currentSession as Experimental).StartTone();
if (Random.value >= .5f) // Long
{
yield return(new WaitForSecondsRealtime(longToneDuration));
}
else // Short
{
yield return(new WaitForSecondsRealtime(shortToneDuration));
}
(currentSession as Experimental).StopTone();
yield return(new WaitForSecondsRealtime(deadTimeDuration));
}
pacientButton.onButtonDown.RemoveListener(currentSession.PacientButtonDown);
pacientButton.onButtonUp.RemoveListener(currentSession.PacientButtonUp);
pacientButton.onButtonDown.RemoveListener(LedOn);
pacientButton.onButtonUp.RemoveListener(LedOff);
currentSession.EndSession();
yield return(new WaitUntil(() => null == currentSession));
}
StopTest();
}
internal Page(int number, DictionaryToken dictionary, MediaBox mediaBox, CropBox cropBox, PageContent content,
AnnotationProvider annotationProvider)
{
if (number <= 0)
{
throw new ArgumentOutOfRangeException(nameof(number), "Page number cannot be 0 or negative.");
}
Dictionary = dictionary ?? throw new ArgumentNullException(nameof(dictionary));
Number = number;
MediaBox = mediaBox;
CropBox = cropBox;
Content = content;
Text = GetText(content);
Width = mediaBox.Bounds.Width;
Height = mediaBox.Bounds.Height;
Size = mediaBox.Bounds.GetPageSize();
ExperimentalAccess = new Experimental(this, annotationProvider);
}
public async Task <MyChatsAndTeams?> GetAllChatsAndTeamsAsync(TeamsDataContext ctx)
{
var cacheKey = $"ts.{ctx.Tenant.UserId}.chatsAndTeams";
var cachedChats = await BlobCache.UserAccount
.GetObject <MyChatsAndTeams?>(cacheKey)
.Catch(Observable.Return <MyChatsAndTeams?>(null));
// only return cached values if there are any
if (cachedChats != null && cachedChats.chats.Count > 0)
{
logger.Debug("[{TenantName}] Got list of chats and teams from cache", ctx.Tenant.TenantName);
return(cachedChats);
}
// otherwise: retrieve
var chatsAndTeams = await teamsTenantApiAccessor.GetMyChatsAndTeamsAsync(ctx);
if (chatsAndTeams != null)
{
await BlobCache.UserAccount.InsertObject(cacheKey, chatsAndTeams, DateTimeOffset.Now + TimeSpan.FromDays(ChatsAndTeamsCacheLifetimeDays));
}
Experimental.CheckForActiveMeeting(logger, ctx, chatsAndTeams);
return(chatsAndTeams);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType,
DeviceGroupType devGroupType, bool def = false)
{
if (!def & ConfigurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = MinerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
if (File.Exists(path.Path))
{
return(path.Path);
}
Helpers.ConsolePrint("PATHS", $"Path {path.Path} not found, using defaults");
}
}
// Temp workaround
if (minerBaseType == MinerBaseType.XmrStak && algoType == AlgorithmType.CryptoNightHeavy)
{
return(Data.XmrStakHeavy);
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NvidiaGroups.Ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AmdGroup.SgminerPath(algoType));
case MinerBaseType.nheqminer:
return(Data.NhEqMiner);
case MinerBaseType.ethminer:
return(Data.Ethminer);
case MinerBaseType.Claymore:
return(AmdGroup.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
//case MinerBaseType.excavator:
// return Data.Excavator;
case MinerBaseType.XmrStak:
return(Data.XmrStak);
case MinerBaseType.ccminer_alexis:
return(NvidiaGroups.CcminerUnstablePath(algoType, devGroupType));
case MinerBaseType.experimental:
return(Experimental.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.Ewbf);
case MinerBaseType.Prospector:
return(Data.Prospector);
case MinerBaseType.Xmrig:
return(Data.Xmrig);
case MinerBaseType.dtsm:
return(Data.Dtsm);
case MinerBaseType.cpuminer:
return(Data.CpuMiner);
}
return(Data.None);
}
// NEW START
////////////////////////////////////////////
// Pure functions
//public static bool IsMinerAlgorithmAvaliable(List<Algorithm> algos, MinerBaseType minerBaseType, AlgorithmType algorithmType) {
// return algos.FindIndex((a) => a.MinerBaseType == minerBaseType && a.NiceHashID == algorithmType) > -1;
//}
public static string GetPathFor(MinerBaseType minerBaseType, AlgorithmType algoType,
DeviceGroupType devGroupType, bool def = false)
{
if (!def & ConfigurableMiners.Contains(minerBaseType))
{
// Override with internals
var path = MinerPathPackages.Find(p => p.DeviceType == devGroupType)
.MinerTypes.Find(p => p.Type == minerBaseType)
.Algorithms.Find(p => p.Algorithm == algoType);
if (path != null)
{
if (File.Exists(path.Path))
{
return(path.Path);
}
Helpers.ConsolePrint("PATHS", $"Path {path.Path} not found, using defaults");
}
}
// Temp workaround
if (minerBaseType == MinerBaseType.XmrStak && algoType == AlgorithmType.CryptoNightHeavy)
{
return(Data.XmrStakHeavy);
}
if (minerBaseType == MinerBaseType.CryptoDredge && algoType == AlgorithmType.CryptoNightV8)
{
// return NvidiaGroups.CryptoDredgeV8(algoType, devGroupType);
return(Data.CryptoDredge);
}
switch (minerBaseType)
{
case MinerBaseType.ccminer:
return(NvidiaGroups.Ccminer_path(algoType, devGroupType));
case MinerBaseType.sgminer:
return(AmdGroup.SgminerPath(algoType));
case MinerBaseType.nheqminer:
return(Data.NhEqMiner);
case MinerBaseType.ethminer:
return(Data.Ethminer);
case MinerBaseType.Claymore:
return(AmdGroup.ClaymorePath(algoType));
case MinerBaseType.OptiminerAMD:
return(Data.OptiminerZcashMiner);
//case MinerBaseType.excavator:
// return Data.Excavator;
case MinerBaseType.XmrStak:
return(Data.XmrStak);
case MinerBaseType.ccminer_alexis:
return(NvidiaGroups.CcminerUnstablePath(algoType, devGroupType));
case MinerBaseType.experimental:
return(Experimental.GetPath(algoType, devGroupType));
case MinerBaseType.EWBF:
return(Data.Ewbf);
case MinerBaseType.Prospector:
return(Data.Prospector);
case MinerBaseType.Xmrig:
return(Data.Xmrig);
case MinerBaseType.XmrigAMD:
return(Data.XmrigAMD);
case MinerBaseType.SRBMiner:
return(Data.SRBMiner);
case MinerBaseType.dstm:
return(Data.Dstm);
case MinerBaseType.cpuminer:
return(Data.CpuMiner);
case MinerBaseType.CastXMR:
return(Data.CastXMR);
case MinerBaseType.lyclMiner:
return(Data.lyclMiner);
case MinerBaseType.hsrneoscrypt:
return(NvidiaGroups.hsrneoscrypt_path(algoType, devGroupType));
case MinerBaseType.CryptoDredge:
return(NvidiaGroups.CryptoDredge(algoType, devGroupType));
case MinerBaseType.ZEnemy:
return(NvidiaGroups.ZEnemy(algoType, devGroupType));
case MinerBaseType.trex:
return(NvidiaGroups.trex(algoType, devGroupType));
case MinerBaseType.mkxminer:
return(Data.mkxminer);
case MinerBaseType.teamredminer:
return(Data.teamredminer);
case MinerBaseType.Phoenix:
return(Data.Phoenix);
case MinerBaseType.GMiner:
return(Data.GMiner);
case MinerBaseType.lolMiner:
return(Data.lolMiner);
case MinerBaseType.WildRig:
return(Data.WildRig);
case MinerBaseType.lolMinerBEAM:
return(Data.lolMinerBEAM);
case MinerBaseType.Bminer:
return(Data.Bminer);
case MinerBaseType.TTMiner:
return(Data.TTMiner);
case MinerBaseType.XmrigNVIDIA:
return(Data.XmrigNVIDIA);
case MinerBaseType.NBMiner:
return(Data.NBMiner);
case MinerBaseType.miniZ:
return(Data.miniZ);
}
return(Data.None);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Experimental obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
