public void SetUp()
 {
     main = new MainBase();
     activity = NewMock<IActivity>();
     Stub.On(activity).GetProperty("Start").Will(Return.Value(DateTime.Parse("7:00:00")));
     Stub.On(activity).GetProperty("Duration").Will(Return.Value(TimeSpan.Parse("0:30:00")));
 }

        public static void OnBeforeInsertStep1( IActivity activity,  ISession session)
        {
            //System.Diagnostics.EventLog appLog = new System.Diagnostics.EventLog() ;
            //appLog.Source = "SalesLogix Web Client";
            //appLog.WriteEntry("Current ActivityId: " + activity.ActivityId);

            //Update the activity id's
            if(String.IsNullOrEmpty(activity.ActivityId) == false) {
                //update the activityid for each activityAttendee record
                foreach(IActivityAttendee aa in activity.ActivityAttendees) {
                    if(String.IsNullOrEmpty(aa.ActivityId) == true || aa.ActivityId.ToString().Trim() == ""
                        || aa.ActivityId == "0") {
                        aa.ActivityId = activity.ActivityId;
                    }
                }

                //update the activityid for each expense record
                foreach(IActivityExpense ae in activity.ActivityExpenses) {
                    if(String.IsNullOrEmpty(ae.ActivityId) == true || ae.ActivityId.ToString().Trim() == ""
                        ||ae.ActivityId == "0") {
                        ae.ActivityId = activity.ActivityId;
                    }
                }
            }
        }

 public void Insert(IActivity activity)
 {
     if (activity == null)
         return;
     activity.Queue(NextActivity);
     NextActivity = activity;
 }

 public void SwitchActivities(IActivity newActivity)
 {
     currentActivity.Unload();
     currentActivity = newActivity;
     currentActivity.Initalize();
     currentActivity.LoadContent();
 }

        public static Dictionary<string, List<ITrailResult>> GetTrailsResultsForActivity(IActivity activity)
        {
            object[] parameters = new object[1];
            parameters[0] = activity;

            Dictionary<string, List<ITrailResult>> list = null;

            try
            {
                Version version;
                Type type = GetType("TrailsPlugin.Export.Integration", "TrailsPlugin", out version);
                if ((type != null)) //&& (version.CompareTo(this.minVersion) >= 0))
                {
                    list = (Dictionary<string, List<ITrailResult>>)type.GetMethod("GetTrailsResultsForActivity").Invoke(null, parameters);
                    //throw new Exception(list.Count.ToString() + "fero");
                }
            }
            catch (Exception e)
            {
                string error = e.Message;
                if (e.InnerException != null)
                {
                    error += "\n\n" + e.InnerException.Message;
                }
                throw new Exception(error);
            }

            return list;
        }

 public void Queue( IActivity activity )
 {
     if( NextActivity != null )
         NextActivity.Queue( activity );
     else
         NextActivity = activity;
 }

        public static IList<IActivity> GetUniqueRoutesForActivity(IActivity activity, System.Windows.Forms.ProgressBar progressBar)
        {
            IList<IActivity> results = null;

            try
            {
                if (progressBar == null)
                    progressBar = new System.Windows.Forms.ProgressBar();

                if (GetUniqueRoutes != null)
                {
                    MethodInfo methodInfo = GetUniqueRoutes.GetMethod(findSimilarRoutes);
                    object resultFromURPlugIn = methodInfo.Invoke(activity, new object[] { activity, progressBar });
                    results = (IList<IActivity>)resultFromURPlugIn;
                }
            }
            catch (Exception e)
            {
                // Log error?
                throw new Exception(string.Format(IntegrationUtility.OtherPluginExceptionText,
            UniquePlugin + ".dll", UniqueRoutesPluginName) + Environment.NewLine, e);
            }

            if (GetUniqueRoutes == null)
            {
                throw new Exception(string.Format(IntegrationUtility.OtherPluginExceptionText,
        UniquePlugin + ".dll", UniqueRoutesPluginName) + Environment.NewLine);
            }

            return results;
        }

 public IntervalResult(IActivity activity, IntervalResultCache resultCache, double distance)
 {
     this.activity = activity;
     this.resultCache = resultCache;
     this.Distance = distance;
     this.factor = 1000.0 / distance;
 }

 public static IList<IActivity> findSimilarRoutes(IActivity refActivity, IList<IActivity> activities, bool activityCompare, bool catCheck, System.Windows.Forms.ProgressBar progressBar)
 {
     if (refActivity == null ||
         refActivity.GPSRoute == null ||
         activityCompare && (false/*catCheck && !isAllowedActivity(refActivity)*/))
         return new List<IActivity>();
     return findSimilarRoutes(refActivity.GPSRoute, refActivity.ReferenceId, activities, activityCompare, progressBar);
 }

 public TemperatureResult(IActivity activity, float temperature, float actual, TimeSpan time, double dist)
 {
     this.activity = activity;
     double f = getTemperatureFactor(temperature) / getTemperatureFactor(actual);
     this.EstimatedTime = Predict.scaleTime(time, f);
     this.Distance = dist;
     this.Temperature = temperature;
 }

		/// <summary>
		/// Inserts an element into the ActivityCollection at the specified index
		/// </summary>
		/// <param name="index">
		/// The index at which the IActivity is to be inserted.
		/// </param>
		/// <param name="value">
		/// The IActivity to insert.
		/// </param>
		public virtual void Insert(int index, IActivity value)
		{
			CheckParent();

			mList.Insert(index, value);

			value.Parent = mParentActivity;
		}

 public ActivityModel(IActivity activity)
 {
     Properties = activity.Properties;
     Type = activity.Type.ToString();            
     Message = activity.Message;
     Id = activity.Id;
     
 }

 public static void Calculate(IActivity activity, double vdot, TimeSpan time, double distance, double maxHr)
 {
     Predict.SetAgeSexFromActivity(activity);
     m_zones = getZones();
     m_percentages = getPercentages(vdot);
     m_hrs = getHeartRates(maxHr, m_percentages);
     m_paces = getSpeeds(vdot, time, distance, m_percentages);
 }

 public TrainingResult(IActivity activity, string ZoneDistance, double PercentOfMax, double TrainRaceHR, double Speed)
 {
     this.activity = activity;
     this.ZoneDistance = ZoneDistance;
     this.PercentOfMax = PercentOfMax;
     this.TrainRaceHR = TrainRaceHR;
     this.Speed = Speed;
 }

        public AgeResult(IActivity activity, float predAge, float currAge, TimeSpan time, double dist)
        {
            this.activity = activity;
            this.Age = predAge;
            this.EstimatedTime = TimeSpan.FromSeconds(PredictWavaTime.WavaPredict(dist, dist, time, predAge, currAge));

            this.EstimatedSpeed = dist / EstimatedTime.TotalSeconds;
        }

 public TimePredictionSource(IActivity activity, double UsedDistance, TimeSpan UsedTime, double StartDistance, double offsetTime)
 {
     this.Activity = activity;
     //this.Distance = Distance;
     this.UsedDistance = UsedDistance;
     this.UsedTime = UsedTime;
     this.StartDistance = StartDistance;
     this.offsetTime = offsetTime;
 }

 public ActivityDetailsControl(IActivity activity)
 {
     InitializeComponent();
     //InitialisedActivities = new Collection<IActivity>();
     this.Activity = activity;
     fitnessDataHandler = Plugin.dataHandler;
     RefreshInfo();
     this.PanelChoiceActionBanner.Text = "User Input";
 }

 public ASynchTask(IActivity activity, Action<IActivity> action)
 {
     Activity = activity;
     this.action = action;
     backgroundWorker = new BackgroundWorker();
     backgroundWorker.DoWork += BackgroundWorkerDoWork;
     backgroundWorker.WorkerSupportsCancellation = true;
     backgroundWorker.RunWorkerCompleted += BackgroundWorkerRunWorkerCompleted;
 }

        public ActivityModel(IActivity activity)
        {
            Properties = activity.Properties;
            Type = activity.Type.ToString();            
            Message = activity.Message;
            Id = activity.Id;

            Hint = activity.Hint.ToString();
            Source = activity.Source;
        }

 private HashSet<IActivitySchedulingEvent<IResource>> GetOrAddActivity(IActivity activity)
 {
     HashSet<IActivitySchedulingEvent<IResource>> schedules;
     if (!_activitySchedulingEvents.TryGetValue(activity, out schedules))
     {
         schedules = new HashSet<IActivitySchedulingEvent<IResource>>();
         _activitySchedulingEvents.Add(activity, schedules);
     }
     return schedules;
 }