public PackageTracker(IWebPoster webPoster, IGeocodeDb geocodeDb)
{
//Todo: This is a bad place to load these:
var uspsUserName = WebConfigurationManager.AppSettings["UspsUserName"];
var uspsPassword = WebConfigurationManager.AppSettings["UspsPassword"];
var fedexKey = WebConfigurationManager.AppSettings["FedexKey"];
var fedexPassword = WebConfigurationManager.AppSettings["FedexPassword"];
var fedexAccountNumber = WebConfigurationManager.AppSettings["FedexAccountNumber"];
var fedexMeterNumber = WebConfigurationManager.AppSettings["FedexMeterNumber"];
var coreTrackers = new List<ITracker>();
coreTrackers.Add(new Tracking.Simulation.SimulationTracker());
coreTrackers.Add(new UpsTracker());
coreTrackers.Add(new UspsTracker(new PostUtility(), uspsUserName, uspsPassword, true));
coreTrackers.Add(new FedexTracker(new TrackService(), fedexKey, fedexPassword, fedexAccountNumber, fedexMeterNumber, false));
//coreTrackers.Add(new DhlTracker(new PostUtility(), "", "");
var multiTracker = new MultiTracker(coreTrackers);
var cacheTracker = new CacheTracker(multiTracker);
var emptyTracker = new EmptyTrackingNumberTracker(cacheTracker);
var loggingTracker = new LoggingTracker(emptyTracker);
var sanitizerTracker = new TrackingNumberStandardizerTracker(loggingTracker);
var geocodingTracker = new GeocodingTracker(sanitizerTracker, geocodeDb);
var errorHandlerTracker = new ErrorHandlerTracker(geocodingTracker);
_defaultTracker = errorHandlerTracker;
}
async Task <bool> Announce(TorrentEvent clientEvent, ITracker tracker)
{
var trackerTier = Tiers.First(t => t.Trackers.Contains(tracker));
try {
// If we have not announced to this Tracker tier yet then we should replace the ClientEvent.
// But if we end up announcing to a different Tracker tier we may want to send the
// original/unmodified args.
AnnounceParameters actualArgs = RequestFactory.CreateAnnounce(clientEvent);
if (!trackerTier.SentStartedEvent)
{
actualArgs = actualArgs.WithClientEvent(TorrentEvent.Started);
}
List <Peer> peers = await tracker.AnnounceAsync(actualArgs);
trackerTier.LastAnnounceSucceeded = true;
trackerTier.ActiveTrackerIndex = trackerTier.Trackers.IndexOf(tracker);
trackerTier.SentStartedEvent |= actualArgs.ClientEvent == TorrentEvent.Started;
trackerTier.LastAnnounce = ValueStopwatch.StartNew();
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(tracker, true, peers.AsReadOnly()));
return(true);
} catch {
}
trackerTier.LastAnnounceSucceeded = false;
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(tracker, false));
return(false);
}
public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
{
// Override point for customization after application launch.
// If not required for your application you can safely delete this method
// create a new window instance based on the screen size
Window = new UIWindow(UIScreen.MainScreen.Bounds);
// If you have defined a root view controller, set it here:
Window.RootViewController = new RootViewController();
var keys = new object[] { "UserAgent" };
var objects = new object[] { "Mozilla/5.0 (iPhone; CPU iPhone OS 9_3 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Mobile/13E233" };
var dictionnary = NSDictionary.FromObjectsAndKeys(objects, keys);
NSUserDefaults.StandardUserDefaults.RegisterDefaults(dictionnary);
// make the window visible
Window.MakeKeyAndVisible();
Setup.EnableCrashReporting(() =>
{
var crashlytics = Crashlytics.SharedInstance;
crashlytics.DebugMode = true;
Crashlytics.StartWithAPIKey("bc21b872cc8e1a687fe564093d1618a4e165179d");
Fabric.With(new NSObject[] { crashlytics });
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
Setup.CaptureManagedInfo(e.ExceptionObject);
Setup.CaptureStackFrames(e.ExceptionObject);
Setup.ThrowExceptionAsNative(e.ExceptionObject);
};
TaskScheduler.UnobservedTaskException += (sender, e) =>
{
Setup.CaptureManagedInfo(e.Exception);
Setup.CaptureStackFrames(e.Exception);
Setup.ThrowExceptionAsNative(e.Exception);
};
}, Path.GetFileNameWithoutExtension(typeof(AppDelegate).Module.Name));
// We use NSUserDefaults to store a bool value if we are tracking the user or not
var optionsDict = NSDictionary.FromObjectAndKey(new NSString("YES"), new NSString(AllowTrackingKey));
NSUserDefaults.StandardUserDefaults.RegisterDefaults(optionsDict);
// User must be able to opt out of tracking
Gai.SharedInstance.OptOut = !NSUserDefaults.StandardUserDefaults.BoolForKey(AllowTrackingKey);
// Initialize Google Analytics with a 5-second dispatch interval (Use a higher value when in production). There is a
// tradeoff between battery usage and timely dispatch.
Gai.SharedInstance.DispatchInterval = 5;
Gai.SharedInstance.TrackUncaughtExceptions = true;
Tracker = Gai.SharedInstance.GetTracker("AdeccoNL", TrackingId);
return(true);
}
public void SwitchControllers()
{
//get list of trackers
List <ITracker> trackers = ControllerHandler.GetTrackers();
ITracker newTracker = null;
//find the first on after the current tracker
int currentIndex = -1;
for (int i = 0; i < trackers.Count; i++)
{
if (Controller.GetRealPositionTracker() == trackers[i])
{
currentIndex = i;
break;
}
}
newTracker = trackers[(currentIndex + 1) % trackers.Count];
if (newTracker != null)
{
//show message
MessageSystem.Line.Main.AddMessage(new MessageSystem.Message("" + Controller.name + " set to " + newTracker.name, 0.5f));
//set new tracker
Controller.SetRealPositionTracker(newTracker);
}
}
public void LoadProfiles_SettingsIsEmpty_ShouldReturnExistentProfilesEnumerable([Content] Item item, CurrentInteraction currentInteraction, ITracker tracker, Profile profile)
{
var profileSettingItem = item.Add("profileSetting", new TemplateID(Templates.ProfilingSettings.ID));
var profileItem = item.Add("profile", new TemplateID(ProfileItem.TemplateID));
var provider = new ProfileProvider();
var fakeSiteContext = new FakeSiteContext(new StringDictionary
{
{
"rootPath", "/sitecore"
},
{
"startItem", profileSettingItem.Paths.FullPath.Remove(0, "/sitecore".Length)
}
});
fakeSiteContext.Database = item.Database;
using (new SiteContextSwitcher(fakeSiteContext))
{
provider.GetSiteProfiles().Count().Should().Be(0);
}
}
//
// This method is invoked when the application has loaded and is ready to run. In this
// method you should instantiate the window, load the UI into it and then make the window
// visible.
//
// You have 17 seconds to return from this method, or iOS will terminate your application.
//
public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
window = new UIWindow(UIScreen.MainScreen.Bounds);
// We use NSUserDefaults to store a bool value if we are tracking the user or not
var optionsDict = NSDictionary.FromObjectAndKey(new NSString("YES"), new NSString(AllowTrackingKey));
NSUserDefaults.StandardUserDefaults.RegisterDefaults(optionsDict);
// User must be able to opt out of tracking
Gai.SharedInstance.OptOut = !NSUserDefaults.StandardUserDefaults.BoolForKey(AllowTrackingKey);
// Initialize Google Analytics with a 5-second dispatch interval (Use a higher value when in production). There is a
// tradeoff between battery usage and timely dispatch.
Gai.SharedInstance.DispatchInterval = 5;
Gai.SharedInstance.TrackUncaughtExceptions = true;
Tracker = Gai.SharedInstance.GetTracker("CuteAnimals", TrackingId);
viewController = new DVCMenu();
navController = new UINavigationController(viewController);
window.RootViewController = navController;
window.MakeKeyAndVisible();
return(true);
}
protected override void TrackEvent(ITracker tracker, TrackEventPipelineArgs args, Identity parsedEvent)
{
if (tracker == null)
{
}
//args.Success = false;
}
public CorpseTrackerGUI(ITracker <TrackedCorpse> tracker, HudList hudList)
{
try
{
this.tracker = tracker;
this.hudList = hudList;
hudList.ClearColumnsAndRows();
hudList.AddColumn(typeof(HudStaticText), 53, null);
hudList.AddColumn(typeof(HudStaticText), 162, null);
hudList.AddColumn(typeof(HudStaticText), 100, null);
hudList.AddColumn(typeof(HudStaticText), 0, null);
HudList.HudListRowAccessor newRow = hudList.AddRow();
((HudStaticText)newRow[0]).Text = "Time";
((HudStaticText)newRow[1]).Text = "Name";
((HudStaticText)newRow[2]).Text = "Coords";
((HudStaticText)newRow[3]).Text = "Id";
tracker.ItemAdded += new Action <TrackedCorpse>(corpseTracker_ItemAdded);
tracker.ItemChanged += new Action <TrackedCorpse>(corpseTracker_ItemChanged);
tracker.ItemRemoved += new Action <TrackedCorpse>(corpseTracker_ItemRemoved);
hudList.Click += new HudList.delClickedControl(hudList_Click);
}
catch (Exception ex) { Debug.LogException(ex); }
}
void createController()
{
//create the keyboard controller
GameObject go;
{
//Create GameObject
go = init();
//Add specific components
//Register Tracker
ITracker newTracker = null;
try {
newTracker = adaptController(go);
}
catch
{
newTracker = null;
}
if (newTracker != null)
{
ControllerHandler.AddTracker(newTracker);
}
else
{
errorMsg.Add(trackerName + " not initialized");
Object.Destroy(go);
}
status = false;
}
}
public static async Task <bool> SendAsync(ITracker tracker, string userTimeingCatagory, string userTimeingVariableName, int userTimingTime)
{
var hit = new TimingHit(userTimeingCatagory, userTimeingVariableName, userTimingTime)
{
DataSource = "app"
};
// create the hit request.
var request = (HitRequestBase)tracker.CreateHitRequest(hit);
// Run a debug check to ensure its valid.
var debugResponse = await request.ExecuteDebugAsync();
if (!((DebugResult)debugResponse).IsValid())
{
return(false);
}
// Send hit.
var collectRequest = await request.ExecuteCollectAsync();
Console.Write(collectRequest.RawResponse);
return(true);
}
public PackageTracker(IWebPoster webPoster, IGeocodeDb geocodeDb)
{
//Todo: This is a bad place to load these:
var uspsUserName = WebConfigurationManager.AppSettings["UspsUserName"];
var uspsPassword = WebConfigurationManager.AppSettings["UspsPassword"];
var fedexKey = WebConfigurationManager.AppSettings["FedexKey"];
var fedexPassword = WebConfigurationManager.AppSettings["FedexPassword"];
var fedexAccountNumber = WebConfigurationManager.AppSettings["FedexAccountNumber"];
var fedexMeterNumber = WebConfigurationManager.AppSettings["FedexMeterNumber"];
var coreTrackers = new List <ITracker>();
coreTrackers.Add(new Tracking.Simulation.SimulationTracker());
coreTrackers.Add(new UpsTracker());
coreTrackers.Add(new UspsTracker(new PostUtility(), uspsUserName, uspsPassword, true));
coreTrackers.Add(new FedexTracker(new TrackService(), fedexKey, fedexPassword, fedexAccountNumber, fedexMeterNumber, false));
//coreTrackers.Add(new DhlTracker(new PostUtility(), "", "");
var multiTracker = new MultiTracker(coreTrackers);
var cacheTracker = new CacheTracker(multiTracker);
var emptyTracker = new EmptyTrackingNumberTracker(cacheTracker);
var loggingTracker = new LoggingTracker(emptyTracker);
var sanitizerTracker = new TrackingNumberStandardizerTracker(loggingTracker);
var geocodingTracker = new GeocodingTracker(sanitizerTracker, geocodeDb);
var errorHandlerTracker = new ErrorHandlerTracker(geocodingTracker);
_defaultTracker = errorHandlerTracker;
}
public void SetTrackerFromSettings()
{
switch (Settings.Default.Tracker)
{
case TrackingSettings.SETTING_TRACKER_VALUE_KINECT_DEPTH:
tracker = trackerKinectDepth;
break;
case TrackingSettings.SETTING_TRACKER_VALUE_KINECT_AUDIO:
tracker = trackerKinectAudio;
break;
case TrackingSettings.SETTING_TRACKER_VALUE_UBISENSE:
tracker = trackerUbisense;
break;
default:
tracker = null;
break;
}
FloatingWindow trackerWindow = FindWindow(tracker as IDisplayable);
if (trackerWindow != null)
{
trackerWindow.RestoreWindow();
trackerWindow.BringIntoView(); //TODO: does this work if a zoomable container is used?
}
}
public void UpdateContactFacets_ShouldUpdateTracker(ITracker tracker, Contact contact, Sitecore.XConnect.Contact xdbContact, IXdbContextFactory xdbContextFactory, IXdbContext xdbContext, IContactManagerService contactManager, IContactFacetUpdater facetUpdater, string source, string identifier)
{
// Arrange
contact.Identifiers.Returns(new List <ContactIdentifier>
{
new ContactIdentifier(source, identifier, ContactIdentificationLevel.Known)
}.AsReadOnly());
tracker.Contact.Returns(contact);
xdbContext.GetAsync <Sitecore.XConnect.Contact>(Arg.Any <IdentifiedContactReference>(), Arg.Any <ContactExpandOptions>()).Returns(Task.FromResult(xdbContact));
xdbContextFactory.CreateContext().Returns(xdbContext);
var userProfile = Substitute.For <Sitecore.Security.UserProfile>();
facetUpdater.SetFacets(userProfile, xdbContact, xdbContext).Returns(true);
var facetsService = new UpdateContactFacetsService(xdbContextFactory, contactManager, new List <IContactFacetUpdater> {
facetUpdater
});
// Act
using (new TrackerSwitcher(tracker))
{
facetsService.UpdateContactFacets(userProfile);
}
// Assert
contactManager.Received(1).SaveContact();
contactManager.Received(1).ReloadContact();
}
public void ExperienceData_NullInteraction_ReturnNull(ITracker tracker, [Greedy] DemoController demoController)
{
using (new TrackerSwitcher(tracker))
{
demoController.ExperienceData().Should().BeNull();
}
}
public void UpdateChange(int clientId, int entityId, int trackableDataIndex, ITracker tracker)
{
_writer.Write((byte)12);
_writer.Write(entityId);
_writer.Write((byte)trackableDataIndex);
ProtobufStreamHelper.WriteObject(_writer, tracker, TypeTable, TypeModel);
}
public QueueProcessor(Logger log, IDataStore dataStore, IHubContext<IMatchmakingClient> hub, ITracker tracker, IMatchEvaluator matchBuilder, CircularBuffer<TimeSpan> timeToMatch)
{
_log = log;
_dataStore = dataStore;
_hub = hub;
_tracker = tracker;
_matchBuilder = matchBuilder;
_timeToMatch = timeToMatch;
_queueSleepMin = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMin") );
_queueSleepMax = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMax") );
_queueSleepLength = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepLength") );
Task.Run( async () =>
{
_log.Info("Running QueueProcessor...");
while( true )
{
var sleepTime = _queueSleepMax;
try
{
await processQueue();
sleepTime = _queueSleepMax - (_dataStore.DocumentDbPopulation * (_queueSleepMax/_queueSleepLength));
}
catch(Exception ex)
{
_log.Error(ex);
}
Thread.Sleep(sleepTime < _queueSleepMin ? _queueSleepMin : sleepTime);
}
});
}
public void LoadProfiles_NoSetProfiles_ShouldReturnEmptyProfilesEnumerable(Database db, [Content] Item item, ITracker tracker, IProfileProvider provider)
{
//arrange
tracker.IsActive.Returns(true);
var fakeSiteContext = new FakeSiteContext(new StringDictionary
{
{
"rootPath", "/sitecore"
},
{
"startItem", item.Paths.FullPath.Remove(0, "/sitecore".Length)
}
});
fakeSiteContext.Database = db;
using (new SiteContextSwitcher(fakeSiteContext))
{
using (new TrackerSwitcher(tracker))
{
var model = new VisitInformation(provider);
model.LoadProfiles().Count().Should().Be(0);
}
}
}
public void SetUp()
{
_mocks = new MockRepository();
_mockTracker = _mocks.CreateMock<ITracker>();
CacheTracker.ClearCache();
}
public async Task Scrape(ITracker tracker)
{
if (!tracker.CanScrape)
{
throw new TorrentException("This tracker does not support scraping");
}
// If the user initiates a Scrape we need to go to the correct thread to process it.
await ClientEngine.MainLoop;
var trackerTier = Tiers.First(t => t.Trackers.Contains(tracker));
trackerTier.LastScrape = ValueStopwatch.StartNew();
try {
ScrapeParameters parameters = RequestFactory.CreateScrape();
await tracker.ScrapeAsync(parameters);
trackerTier.LastScrapSucceeded = true;
ScrapeComplete?.InvokeAsync(this, new ScrapeResponseEventArgs(tracker, true));
} catch {
trackerTier.LastScrapSucceeded = false;
ScrapeComplete?.InvokeAsync(this, new ScrapeResponseEventArgs(tracker, false));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="logger">
/// The logger to use.
/// </param>
/// <param name="httpClient">
/// The <see cref="HttpClient"/> to use when sending request data.
/// </param>
/// <param name="sharePercentage">
/// The approximate proportion of requests to share.
/// 1 = 100%, 0.5 = 50%, etc.
/// </param>
/// <param name="minimumEntriesPerMessage">
/// The minimum number of request entries per message sent to 51Degrees.
/// </param>
/// <param name="maximumQueueSize">
/// The maximum number of items to hold in the queue at one time. This
/// must be larger than minimum entries.
/// </param>
/// <param name="addTimeout">
/// The timeout in milliseconds to allow when attempting to add an
/// item to the queue. If this timeout is exceeded then usage sharing
/// will be disabled.
/// </param>
/// <param name="takeTimeout">
/// The timeout in milliseconds to allow when attempting to take an
/// item to the queue.
/// </param>
/// <param name="repeatEvidenceIntervalMinutes">
/// The interval (in minutes) which is used to decide if repeat
/// evidence is old enough to consider a new session.
/// </param>
/// <param name="trackSession">
/// Set if the tracker should consider sessions in share usage.
/// </param>
/// <param name="shareUsageUrl">
/// The URL to send data to
/// </param>
/// <param name="blockedHttpHeaders">
/// A list of the names of the HTTP headers that share usage should
/// not send to 51Degrees.
/// </param>
/// <param name="includedQueryStringParameters">
/// A list of the names of query string parameters that share
/// usage should send to 51Degrees.
/// </param>
/// <param name="ignoreDataEvidenceFilter"></param>
/// <param name="aspSessionCookieName">
/// The name of the cookie that contains the asp.net session id.
/// </param>
/// <param name="tracker"></param>
internal ShareUsageElement(
ILogger <ShareUsageElement> logger,
HttpClient httpClient,
double sharePercentage,
int minimumEntriesPerMessage,
int maximumQueueSize,
int addTimeout,
int takeTimeout,
int repeatEvidenceIntervalMinutes,
bool trackSession,
string shareUsageUrl,
List <string> blockedHttpHeaders,
List <string> includedQueryStringParameters,
List <KeyValuePair <string, string> > ignoreDataEvidenceFilter,
string aspSessionCookieName,
ITracker tracker)
: base(logger,
httpClient,
sharePercentage,
minimumEntriesPerMessage,
maximumQueueSize,
addTimeout,
takeTimeout,
repeatEvidenceIntervalMinutes,
trackSession,
shareUsageUrl,
blockedHttpHeaders,
includedQueryStringParameters,
ignoreDataEvidenceFilter,
aspSessionCookieName,
tracker)
{
}
public static async Task <bool> SendAsync(ITracker tracker, string screenName)
{
var hit = new ScreenViewHit(screenName)
{
DataSource = "app",
UserAgentOverride = @"Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19"
};
// create the hit request.
var request = (HitRequestBase)tracker.CreateHitRequest(hit);
// Run a debug check to ensure its valid.
var debugResponse = await request.ExecuteDebugAsync();
if (!((DebugResult)debugResponse).IsValid())
{
return(false);
}
// Send hit.
var collectRequest = await request.ExecuteCollectAsync();
Console.Write(collectRequest.RawResponse);
return(true);
}
public void Attach(ITracker view)
{
view.TrackerDown += new NsNodeTrackerEventHandler(view_TrackerDown);
view.TrackerDrag += new NsNodeTrackerEventHandler(view_TrackerDrag);
view.TrackerUp += new NsNodeTrackerEventHandler(view_TrackerUp);
view.TrackerDetach += new NsNodeTrackerEventHandler(view_TrackerDetach);
}
/// <summary>
/// Initializes a new instance of the <see cref="Mapper{TSource, TResult}"/> class.
/// </summary>
public Mapper(ITracker <TSource> source, Func <TSource, TResult> selector)
{
Ensure.NotNull(source, nameof(source));
Ensure.NotNull(selector, nameof(selector));
this.subscription = source.ObservePropertyChangedSlim(nameof(source.Value))
.Subscribe(_ => { this.Value = selector(source.Value); });
}
public MoveViewModel(DomaConnection source, DomaConnection target, ITracker tracker)
{
_tracker = tracker;
Source = source;
Target = target;
}
public void DeleteDeck(Deck deck)
{
ITracker tracker = trackerFactory.GetTracker();
if (tracker.Decks.Contains(deck))
{
tracker.Decks.Remove(deck);
}
foreach (Game g in tracker.Games.Where(g => g.DeckId == deck.DeckId).ToList())
{
tracker.Games.Remove(g);
}
foreach (Reward r in tracker.Rewards.Where(r => r.ArenaDeckId == deck.DeckId))
{
r.ArenaDeck = null;
r.ArenaDeckId = null;
}
if (tracker.ActiveDeck?.DeckId == deck.DeckId)
{
tracker.ActiveDeck = null;
}
}
public void LoadProfiles_SettingWithProfiles_ShouldReturnExistentProfilesEnumerable(Db db, CurrentInteraction currentInteraction, ITracker tracker, Analytics.Tracking.Profile profile)
{
var profileItem = new DbItem("profile", ID.NewID, new TemplateID(ProfileItem.TemplateID));
db.Add(profileItem);
var profileSettingItem = new DbItem("profileSetting", ID.NewID, new TemplateID(Templates.ProfilingSettings.ID))
{
{Templates.ProfilingSettings.Fields.SiteProfiles, profileItem.ID.ToString()}
};
db.Add(profileSettingItem);
var provider = new ProfileProvider();
var fakeSiteContext = new FakeSiteContext(new StringDictionary
{
{"rootPath", "/sitecore"},
{"startItem", profileSettingItem.FullPath.Remove(0, "/sitecore".Length)}
})
{
Database = db.Database
};
using (new SiteContextSwitcher(fakeSiteContext))
{
var siteProfiles = provider.GetSiteProfiles();
siteProfiles.Count().Should().Be(1);
}
}
protected override void OnStartup(object sender, StartupEventArgs e)
{
base.OnStartup(sender, e);
_settingsStorage = new ConnectionSettingsStorage();
_sourceSettings = _settingsStorage.Load(Role.Source);
_targetSettings = _settingsStorage.Load(Role.Target);
var domaClientFactory = new DomaClientFactory();
var imageDownloader = new ImageDownloader();
var source = new DomaConnection(domaClientFactory, imageDownloader, _sourceSettings);
var target = new DomaConnection(domaClientFactory, imageDownloader, _targetSettings);
_tracker = new Tracker();
if (ConfigurationManager.AppSettings.AllKeys.Any(x => x == "skiptracking") && ConfigurationManager.AppSettings["skiptracking"] == "true")
_tracker = new NullTracker();
if (ConfigurationManager.AppSettings.AllKeys.Any(x => x == "messageboxerrors") &&
ConfigurationManager.AppSettings["messageboxerrors"] == "true")
_messageboxOnError = true;
var transferViewModel = new MoveViewModel(source, target, _tracker);
var windowManager = (WindowManager)GetInstance(typeof(WindowManager), null);
windowManager.ShowWindow(transferViewModel);
}
protected override ConstructToken TokenizeConstruct(ITracker tracker)
{
int temp = tracker.Index;
var tokens = new List <Token>();
if (!TryTokenize(tracker, roundBrackets, tokens, "parameters"))
{
return(null);
}
whitespaces.Tokenize(tracker);
if (!TryTokenize(tracker, arrowString, tokens))
{
return(null);
}
whitespaces.Tokenize(tracker);
if (!TryTokenize(tracker, curlyBrackets, tokens, "codeBlock"))
{
return(null);
}
return(new ConstructToken(new TextRegion(temp, tracker.Index), tokens, "lambda"));
}
public void ChangeTracker(Trackers t)
{
try
{
switch (t)
{
case Trackers.FreeTrack:
{
Debug.Log("KerbTrack: Using FreeTrack");
tracker = new FreeTrackTracker();
break;
}
case Trackers.TrackIR:
{
Debug.Log("KerbTrack: Using TrackIR");
tracker = new TrackIRTracker();
break;
}
case Trackers.OculusRift:
{
Debug.Log("KerbTrack: Using Oculus Rift");
tracker = new OVRTracker();
break;
}
}
}
catch (Exception)
{
trackerEnabled = false;
throw;
}
}
async Task Announce(TorrentEvent clientEvent, ITracker referenceTracker)
{
// If the user initiates an Announce we need to go to the correct thread to process it.
await ClientEngine.MainLoop;
LastAnnounce.Restart();
LastUpdated = DateTime.UtcNow;
AnnounceParameters p = RequestFactory.CreateAnnounce(clientEvent);
foreach ((TrackerTier trackerTier, ITracker tracker) in GetNextTracker(referenceTracker))
{
try {
// If we have not announced to this Tracker tier yet then we should replace the ClientEvent.
// But if we end up announcing to a different Tracker tier we may want to send the
// original/unmodified args.
AnnounceParameters actualArgs = p;
if (!trackerTier.SentStartedEvent)
{
actualArgs = actualArgs.WithClientEvent(TorrentEvent.Started);
}
List <Peer> peers = await tracker.AnnounceAsync(actualArgs);
LastAnnounceSucceeded = true;
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(tracker, true, peers.AsReadOnly()));
return;
} catch {
}
}
LastAnnounceSucceeded = false;
AnnounceComplete?.InvokeAsync(this, new AnnounceResponseEventArgs(null, false));
}
public CorpseTrackerGUI(ITracker<TrackedCorpse> tracker, HudList hudList)
{
try
{
this.tracker = tracker;
this.hudList = hudList;
hudList.ClearColumnsAndRows();
hudList.AddColumn(typeof(HudStaticText), 53, null);
hudList.AddColumn(typeof(HudStaticText), 162, null);
hudList.AddColumn(typeof(HudStaticText), 100, null);
hudList.AddColumn(typeof(HudStaticText), 0, null);
HudList.HudListRowAccessor newRow = hudList.AddRow();
((HudStaticText)newRow[0]).Text = "Time";
((HudStaticText)newRow[1]).Text = "Name";
((HudStaticText)newRow[2]).Text = "Coords";
((HudStaticText)newRow[3]).Text = "Id";
tracker.ItemAdded += new Action<TrackedCorpse>(corpseTracker_ItemAdded);
tracker.ItemChanged += new Action<TrackedCorpse>(corpseTracker_ItemChanged);
tracker.ItemRemoved += new Action<TrackedCorpse>(corpseTracker_ItemRemoved);
hudList.Click += new HudList.delClickedControl(hudList_Click);
}
catch (Exception ex) { Debug.LogException(ex); }
}
public string FuehreAus(IScorecard scorecard, ITracker tracker)
{
var hilfstexte = Konfiguration.Befehle.ConvertAll(HilfstextFuer);
return("Ich helfe dir beim Fuehren der Scorecard. Ich reagiere auf folgende Befehle: " + Environment.NewLine +
string.Join(Environment.NewLine, hilfstexte));
}
public static async Task <bool> SendAsync(ITracker tracker, string socialNetwork, string socialAction, string socialActionTarget)
{
var hit = new SocialHit(socialNetwork, socialAction, socialActionTarget)
{
DataSource = "app"
};
// create the hit request.
var request = (HitRequestBase)tracker.CreateHitRequest(hit);
// Run a debug check to ensure its valid.
var debugResponse = await request.ExecuteDebugAsync();
if (!((DebugResult)debugResponse).IsValid())
{
return(false);
}
// Send hit.
var collectRequest = await request.ExecuteCollectAsync();
Console.Write(collectRequest.RawResponse);
return(true);
}
/// <summary>
/// The main job for it here is to Register the Observer in the tracker object
/// </summary>
/// <param name="languageTracker">The tracker object that will register the observer on it</param>
public LanguageObserver(ITracker languageTracker)
{
_observersCount++;
_observerId = _observersCount;
languageTracker.RegisterObserver(this);
Console.WriteLine("New Observer Created ..");
}
private async Task <object> CommandSaveExecute(object obj)
{
if (pack.Cards.Any(c => c.Card == null || c.Card == Card.Unknown))
{
ErrorMessage = "Please select 6 cards";
return(null);
}
ButtonSaveLabel = "Saving...";
ButtonSaveEnabled = false;
ErrorMessage = null;
if (settings.Packs_ScreenshotAfterAdded)
{
ButtonSaveLabel = "Taking screenshot...";
await Task.Factory.StartNew(() => TakePackScreenshot());
}
ButtonSaveLabel = "Saving pack...";
ITracker tracker = trackerFactory.GetTracker();
Pack.DateOpened = trackerFactory.GetDateTimeNow();
tracker.Packs.Add(Pack);
await Task.Factory.StartNew(() => trackerFactory.GetFileManager().SaveDatabase());
settings.Packs_LastOpenedPackSetId = Pack.CardSet.Id;
settings.Save();
InitNewPack();
ButtonSaveLabel = "Save";
ButtonSaveEnabled = true;
return(null);
}
public static void Init(int verbosity, string trackingId, int localDispatchPeriod = 120, bool trackUncaughtExceptions = true, int userIdDimensionIndex = 0)
{
Verbosity = (VerbosityLevel)verbosity;
Gai.SharedInstance.DispatchInterval = localDispatchPeriod;
Gai.SharedInstance.TrackUncaughtExceptions = false;
Tracker = Gai.SharedInstance.GetTracker(trackingId);
if (trackUncaughtExceptions)
{
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
var ex = (Exception)e.ExceptionObject;
TrackUnhandledException(ex);
};
TaskScheduler.UnobservedTaskException += (sender, e) =>
{
var ex = e.Exception;
TrackUnhandledException(ex);
};
}
UserIdDimensionIndex = userIdDimensionIndex;
}
public async void CreateTrackerAsync_CorrectParametersAreProvided_TrackerMustBeCreated(bool temporary)
{
//prepare
var trackername = "trackername";
var subscriber1 = "subscriber1";
var subscriber2 = "subscriber2";
var retrycount = 10;
var prefetchcount = 5;
var targetSubscriberNames = new List <string>()
{
subscriber1, subscriber2
};
var trackingRoutingKeys = new List <string>
{
string.Concat("ok.", subscriber1),
string.Concat("ok.", subscriber2),
string.Concat("deadletter.", subscriber1),
string.Concat("deadletter.", subscriber2)
};
_trackerNamingConvensionController.Setup(x => x.GetTrackerQueueName(trackername))
.Returns((string queueName) => string.Concat("tracking.", trackername));
_trackerNamingConvensionController
.Setup(x => x.GetTrackerQueueRoutingKeys(new List <string> {
subscriber1, subscriber2
}))
.Returns((IEnumerable <string> subscribersNames) => new List <string>(trackingRoutingKeys));
var mockSubscriber = new Mock <ISubscriber>();
var subscriberFactoryHasBeenCalledWithCorrectParameters = false;
_subscriberFactory.Setup(x => x.CreateSubscriberAsync(string.Concat("tracking.", trackername), temporary,
trackingRoutingKeys, retrycount,
prefetchcount, It.IsAny <TrackingEventsSubscriptionSelector>()))
.Returns((string name, bool temp, IEnumerable <string> routings, int retry, int prefetch,
ISubscriptionSelector subscriptionSelector) =>
{
subscriberFactoryHasBeenCalledWithCorrectParameters = true;
return(Task.FromResult(mockSubscriber.Object));
});
//act
ITracker tracker =
await _createDefaultTrackerFactoryFunc()
.CreateTrackerAsync(trackername, temporary, targetSubscriberNames, retrycount, prefetchcount);
//check
subscriberFactoryHasBeenCalledWithCorrectParameters.Should().BeTrue();
DefaultTracker actualTracker = (DefaultTracker)tracker;
actualTracker.Should().NotBeNull();
}
public StandardDeployer(ILogger logger, IEngine engine, ITracker tracker,
IEnumerable <IScriptHandle> scriptHandles)
{
_logger = logger;
_engine = engine;
_tracker = tracker;
_scriptHandles = scriptHandles;
}
public void TrackPageEvent_InActiveTracker_ShouldNotTrack(Database db, [Content] Item item, ITracker tracker, AccountTrackerService accountTrackerService)
{
using (new TrackerSwitcher(tracker))
{
accountTrackerService.TrackPageEvent(item.ID);
tracker.CurrentPage.DidNotReceive().Register(Arg.Is<PageEventItem>(x => x.ID == item.ID));
}
}
/// <summary>
/// Standard constructor
/// </summary>
/// <param name="connectionString"></param>
/// <param name="databaseName"></param>
/// <param name="databaseRepository"></param>
/// <param name="commandTimeout"></param>
/// <param name="tracker"></param>
public SqlServerDatabaseProfile(string connectionString, string databaseName, string databaseRepository, int commandTimeout, ITracker tracker)
{
_connectionString = connectionString;
_commandTimeout = commandTimeout;
_databaseName = databaseName;
_databaseRepository = databaseRepository;
_tracker = tracker;
}
public void TrackPageEventShouldTrackById(Database db, [Content] Item item, ITracker tracker, AccountTrackerService accountTrackerService)
{
using (new TrackerSwitcher(tracker))
{
accountTrackerService.TrackPageEvent(item.ID);
tracker.CurrentPage.Received(1).Register(Arg.Is<PageEventItem>(x => x.ID == item.ID));
}
}
public Val Execute(ITracker caller, string _funcName, IContext c, Val[] p)
{
return(F(c
, ValParamContract.Convert <T1>(caller, _funcName, 1, p[0])
, ValParamContract.Convert <T2>(caller, _funcName, 2, p[1])
, ValParamContract.Convert <T3>(caller, _funcName, 3, p[2])
));
}
public WorkflowEngine(IServiceProvider serviceProvider, ITracker tracker, IDeferredTarget deferredTarget)
{
_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
_workflowStorage = _serviceProvider.GetService <IWorkflowStorage>() ?? throw new NullReferenceException("IWorkflowStorage");
_instanceStorage = _serviceProvider.GetService <IInstanceStorage>() ?? throw new NullReferenceException("IInstanceStorage");
_deferredTarget = deferredTarget ?? throw new NullReferenceException("IDeferredTarget");
_tracker = tracker;
}
public void TrackOutcome_NullOutcomeId_ThrowException([NoAutoProperties] TrackerService trackerService, ITracker tracker)
{
tracker.IsActive.Returns(true);
using (new TrackerSwitcher(tracker))
{
trackerService.Invoking(x => x.TrackOutcome(null)).ShouldThrow<ArgumentNullException>();
}
}
public LoanController(ILoan db, IMapLoan map, ILoanProvides pd, ITracker tracker, ISubscribed subscribed)
{
this.db = db;
this.maps = map;
_pd = pd;
_tracker = tracker;
_subscribed = subscribed;
}
public GpsTracking(ITracker tracker)
{
_tracker = tracker;
IsBestAccuracy = true;
MinInterval = 60;
MinDistance = 0;
DistanceFilter = 3;
SendInterval = 30;
}
public void VisitDetails_TrackerInteractionNotInitialized_ShouldReturnNull(IContactProfileProvider contact, IProfileProvider profile, ITracker tracker)
{
//arrange
var controller = new DemoController(contact, profile);
using (new TrackerSwitcher(tracker))
{
controller.VisitDetails().Should().Be(null);
}
}
public void ContactDetails_ContactInitialized_ShouldReturnContactInformation(IContactProfileProvider contact, IProfileProvider profile, ITracker tracker)
{
//arrange
var controller = new DemoController(contact, profile);
using (new TrackerSwitcher(tracker))
{
controller.ContactDetails().As<ViewResult>().Model.Should().BeOfType<ContactInformation>();
}
}
public void TrackPageEvent_ValidID_ShouldTrackById(Database db, [Content] Item item, ITracker tracker, TrackerService trackerService)
{
tracker.IsActive.Returns(true);
using (new TrackerSwitcher(tracker))
{
trackerService.TrackPageEvent(item.ID);
tracker.CurrentPage.Received(1).Register(Arg.Is<PageEventItem>(x => x.ID == item.ID));
}
}
public void Contact_ContactInitialized_ShouldReturnContact([NoAutoProperties] ContactProfileProvider provider, ITracker tracker, Contact contact)
{
tracker.IsActive.Returns(true);
tracker.Contact.Returns(contact);
using (new TrackerSwitcher(tracker))
{
tracker.Contact.Should().NotBeNull();
provider.Contact.ShouldBeEquivalentTo(tracker.Contact);
}
}
public void IdentifyContact_ValidIdentifier_ShouldIdentifyContact([NoAutoProperties] TrackerService trackerService, string contactIdentifier, ITracker tracker, [Substitute] Session session)
{
tracker.IsActive.Returns(true);
tracker.Session.Returns(session);
using (new TrackerSwitcher(tracker))
{
trackerService.IdentifyContact(contactIdentifier);
tracker.Session.Received().Identify(contactIdentifier);
}
}
public void VisitDetails_TrackerInitialized_ShouldReturnVisitInformation(IContactProfileProvider contact, IProfileProvider profile, ITracker tracker, CurrentInteraction interaction)
{
tracker.Interaction.Returns(interaction);
//arrange
var controller = new DemoController(contact, profile);
using (new TrackerSwitcher(tracker))
{
controller.VisitDetails().As<ViewResult>().Model.Should().BeOfType<VisitInformation>();
}
}
public void ContactDetails_ContactNotInitialized_ShouldReturnNull(IContactProfileProvider contact, IProfileProvider profile, ITracker tracker)
{
tracker.Contact.Returns((Contact)null);
//arrange
var controller = new DemoController(contact, profile);
using (new TrackerSwitcher(tracker))
{
controller.ContactDetails().Should().BeNull();
}
}
public void TrackRegisterShouldTrack(Db db, ITracker tracker, AccountTrackerService accountTrackerService)
{
db.Add(new DbItem("Item", ConfigSettings.RegisterGoalId));
using (db)
using (new TrackerSwitcher(tracker))
{
accountTrackerService.TrackRegister();
tracker.CurrentPage.Received(1).Register(Arg.Is<PageEventItem>(x => x.ID == ConfigSettings.RegisterGoalId));
}
}
public ContourNode(NsNode parent, string label, ITracker tracker)
: base(label, parent)
{
Attributes.Add(new ContourAttribute(this, null, null));
if (tracker != null)
{
Attach(tracker);
if (tracker is INodeView)
Attach(tracker as INodeView);
}
}
public void BehaviorProfiles_FacetExists_ShouldReturnContactBehaviorProfiles([NoAutoProperties] ContactProfileProvider provider, IContactBehaviorProfilesContext facet, ITracker tracker, [Substitute] Contact contact)
{
tracker.IsActive.Returns(true);
tracker.Contact.Returns(contact);
contact.BehaviorProfiles.Returns(facet);
using (new TrackerSwitcher(tracker))
{
provider.BehaviorProfiles.Should().NotBeNull();
provider.BehaviorProfiles.ShouldBeEquivalentTo(facet.Profiles);
}
}
public void TrackLogin_Call_ShouldTrackLoginGoal(string identifier, Db db, ITracker tracker, AccountTrackerService accountTrackerService, [Substitute] Session session)
{
tracker.IsActive.Returns(true);
tracker.Session.Returns(session);
db.Add(new DbItem("Item", ConfigSettings.LoginGoalId));
using (new TrackerSwitcher(tracker))
{
accountTrackerService.TrackLogin(identifier);
tracker.CurrentPage.Received(1).Register(Arg.Is<PageEventItem>(x => x.ID == ConfigSettings.LoginGoalId));
}
}
/// <summary>
/// Handler of connection to the ETServer
/// Reads data from the stream, and answers accordingly.
/// Deals with the tracker aswell using the ITracker interface.
/// </summary>
/// <param name="name"></param>
/// <param name="tracker_type"></param>
/// <param name="clientId"></param>
/// <param name="stream"></param>
/// <param name="description"></param>
public ConnectionHandler(byte name, string tracker_type, string clientId, NetworkStream stream, string description)
{
this.name = name;
logger = LogManager.GetLogger(this.GetType());
log4net.ThreadContext.Properties["id"] = "Id: " + clientId;
this.stream = stream;
readerWriter = new EriverStreamReaderWriter(stream);
this.stop = new ManualResetEvent(false);
tracker = TrackerFactory.GetTracker(tracker_type, name);
Description = description;
}
public void OnActionExecuting_TrackerNotInitialized_ShouldDoNothing(SkipAnalyticsTrackingAttribute trackingAttribute, ActionExecutingContext ctx, ITracker tracker)
{
//arrange
InitializeActionFilterContext(ctx);
using (new TrackerSwitcher(tracker))
{
//act
trackingAttribute.OnActionExecuting(ctx);
//assert
tracker.CurrentPage.DidNotReceive().Cancel();
}
}
public void LoadProfiles_TrackerInactive_ShouldReturnEmptyEnumerable(ITracker tracker)
{
//arrange
tracker.IsActive.Returns(false);
using (new TrackerSwitcher(tracker))
{
var model = new VisitInformation(null);
//act
var profiles = model.LoadProfiles();
//assert
profiles.Count().Should().Be(0);
}
}
