void OnEnable()
 {
     story = (Story)target;
     if (story.Forest == null) {
         story.Forest = new Forest();
     }
 }

        public StoryViewModel(Story story)
        {
            Story = story;

            StartVM = new LocationScenarioViewModel(Story.StartingScenario, Story.StartingLocation, "Start");
            EndVM = new LocationScenarioViewModel(Story.EndingScenario, Story.EndingLocation, "End");
        }

        public void verify_receive_appropriate_error_message_when_user_provides_a_bad_user_name_or_password()
        {
            AuthenticationStatus authStatus = null;
            Story authenticateUserStory = new Story("Authenticate User");

            authenticateUserStory.AsA("Unauthenticated user")
                .IWant("supply my user name and password to the login form")
                .SoThat("I can  authenticate to the application");

            authenticateUserStory
                .WithScenario("User provides an invalid user name")
                .Given("My user name and password are ", "Big Daddy", "Gobldegook", delegate(string userName, string password) { UserRepositoryFactory factory = _mock.DynamicMock<UserRepositoryFactory>();

                                                                                                                                 using (_mock.Record())
                                                                                                                                 {
                                                                                                                                    Expect.Call(factory.Create(userName, password))
                                                                                                                                        .Return(_mock.DynamicMock<IUserRepository>());
                                                                                                                                 }

                                                                                                                                 _user = factory.Create(userName, password); })
                .When("I authenticate the user", delegate {_service = _mock.DynamicMock<IAuthenticationService>();
                                                            using (_mock.Record())
                                                            {
                                                                Expect.Call(_service.Authenticate(_user))
                                                                    .Return(new AuthenticationStatus(new Exception("Bad Username or Password")));
                                                            }
                                                           authStatus = _service.Authenticate(_user);})
                .Then("I should receive an Authentication status of", Status.Failed, delegate(Status expectedStatus) {Assert.AreEqual(expectedStatus, authStatus.Status);});
        }

        public void verify_receive_appropriate_success_message_when_user_provides_a_good_user_name_and_password()
        {
            Story authenticateUserStory = new Story("Authenticate User");

            authenticateUserStory.AsA("USer with a valid user name and password")
                .IWant("supply my user name and password to the login form")
                .SoThat("I can authenticate to the application");

            authenticateUserStory
                .WithScenario("User provides a valid user name and password")
                .Given("My user name and password are ", "mmann", "validpassword_1", delegate(string userName, string password) { UserRepositoryFactory factory = _mock.DynamicMock<UserRepositoryFactory>();

                                                                                                                                 using (_mock.Record())
                                                                                                                                 {
                                                                                                                                    Expect.Call(factory.Create(userName, password))
                                                                                                                                        .Return(_mock.DynamicMock<IUserRepository>());
                                                                                                                                 }

                                                                                                                                 _user = factory.Create(userName, password); })
                .When("I authenticate the user", delegate {_service = _mock.DynamicMock<IAuthenticationService>();
                                                            using (_mock.Record())
                                                            {
                                                                Expect.Call(_service.Authenticate(_user))
                                                                    .Return(new AuthenticationStatus());
                                                            }
                                                           _authStatus = _service.Authenticate(_user);})
                .Then("I should receive an Authentication status of", Status.Success, delegate(Status expectedStatus) {Assert.AreEqual(expectedStatus, _authStatus.Status);});
        }

 public StoryController()
 {
     defaultStory =
         new Story()
         {
             Id = 1,
             Name = "Holly Hope Aspinall",
             StoryTitle = "An Unexpected Journey",
             Events = new List<Event>()
             {
                 new Event
                 {
                     Id=1,
                     Title="Sticks The Landing",
                     Description="Holly was born today at 20:04 weighing in at 8lb 13oz",
                     DateTime=new DateTime(2015,06,12,20,04,00),
                     ImgUrl="Content/Images/dribbbleburger_1x.png",
                 },
                 new Event
                 {
                     Id=2,
                     Title="Welcome To The World",
                     Description="Holly is welcomed into the world by her grandparents",
                     DateTime=new DateTime(2015,06,12,22,00,00),
                     ImgUrl="Content/Images/Optionis.jpg",
                 },
             },
         };
 }

        public Battle()
        {
            if (story == null)
            {
                this.story = App.Story;
                this.hero = story.Hero;
                currentStatus = null;
            }

            InitializeComponent();

            buttons = new Dictionary<Type, Button>()
            {
                {typeof (Rock), RockButton},
                {typeof (Paper), PaperButton},
                {typeof (Scissors), ScissorsButton},
            };

            foreach (var button in buttons.Values)
            {
                button.Visibility = Visibility.Collapsed;
            }

            returnToNavi.Visibility = Visibility.Collapsed;

            RunBattle();
        }

        public void BulkGetUsersWithWrongGUID()
        {
            _story = new Story("Get Memebers By IMembershipApi");

            _story.AsA("User")
              .IWant("to be able to get members, and give wrong users' GUID")
              .SoThat("I can get nothing");

            IDictionary<Guid, UserObject> _Users = new Dictionary<Guid, UserObject>();

            Guid _temp = new Guid();

            _story.WithScenario("Get members by ImembershipApi with the only one correct Ids")
                .Given("only one correct GUID of user and fake one", () =>
                {
                    createdObjectIds.Add(_temp);
                })
                .When("I use the BulkGet, I can get users ", () => _Users = _membershipApi.BulkGet(createdObjectIds))
                .Then("The return a bunch of Users only contain null User ",
                        () =>
                        {
                            _Users[_temp].ShouldBeNull();
                        });

            //createdObjectIds.Remove(_temp);

            this.CleanUp();
        }

 public void Verify()
 {
     _story = this.BDDfy();
     _story.Metadata.ShouldNotBe(null);
     _story.Metadata.Title.ShouldBe(StoryTitle);
     _story.Metadata.TitlePrefix.ShouldBe(StoryTitlePrefix);
 }

        public RequirementsDocument TranslatePivotalToSolr(Story pivotalstory)
        {
            //return null;

            return new RequirementsDocument()
                       {
                           ID = IDGenerator.GetUniqueIDForDocument(pivotalstory.Id.ToString(), _project.SystemType.ToDescription()),
                           Title = HttpUtility.HtmlEncode(pivotalstory.Name),
                           Status = pivotalstory.Current_State,
                           Project = _project.ProjectName,
                           Department = _project.Department,
                           SystemSource = _project.SystemType.ToDescription(),
                           LastIndexed = DateTime.Now,
                           Description = HttpUtility.HtmlEncode(pivotalstory.Description),
                           //AcceptanceCriteria = "Accepted At " + pivotalstory.AcceptedAt,
                           StoryPoints = pivotalstory.Estimate.ToString(),
                           ReleaseIteration = "tbd",
                           ReferenceID = "tbd",
                           StoryType = pivotalstory.Story_Type,
                           Team = pivotalstory.Owned_By,
                           //LastUpdated = pivotalstory.UpdatedAt,
                           StoryURI = pivotalstory.Url,
                           StoryTags = pivotalstory.Labels,
                           IterationStart = GetIterationDurationForStory(pivotalstory.Id,pivotalstory.Project_Id),
                           IterationEnd = GetIterationDurationForStory(pivotalstory.Id,pivotalstory.Project_Id)
                       };
        }

 public bool CopyAttributes(Story pivotalstorySource, WorkItem destinationWorkItem)
 {
     destinationWorkItem.Fields[ConchangoTeamsystemScrumEstimatedeffort].Value = pivotalstorySource.Estimate;
     destinationWorkItem.Fields[ConchangoTeamsystemScrumBusinesspriority].Value = pivotalstorySource.Priority;
     destinationWorkItem.Fields[ConchangoTeamsystemScrumDeliveryorder].Value = pivotalstorySource.Priority;
     return true;
 }

        public Story Create(string storyName, string creatorId, IEnumerable<string> genreNames)
        {
            var existingGenres = this.genreRepository.All()
                .Where(x => genreNames.Contains(x.Name))
                .ToList();

            foreach (var genre in genreNames)
            {
                if (!existingGenres.AsQueryable().Select(x => x.Name).Contains(genre))
                {
                    var newGenre = new Genre
                    {
                        Name = genre
                    };

                    existingGenres.Add(newGenre);
                    this.genreRepository.Add(newGenre);
                }
            }

            this.genreRepository.Save();

            var story = new Story
            {
                AuthorId = creatorId,
                Name = storyName,
                Genres = existingGenres
            };

            this.storyRepository.Add(story);
            this.storyRepository.Save();

            return this.storyRepository.All()
                .FirstOrDefault(x => x.Name == story.Name);
        }

        public void MemberLoginWithCorrectUserNameAndPwd()
        {
            _story = new Story("Login with UserName and Password");

            _story.AsA("User")
              .IWant("to be able to login ")
              .SoThat("I can use features");

            _story.WithScenario("login with a correct username and password")
                .Given("Create a new with old password", () =>
                {
                    _Uobject = _utils.CreateUserObject("Eunge Liu",true);

                    _oldpassword = "123Hello";

                    _newpassword = "Hello123456";

                    _membershipApi.Save(_Uobject, _oldpassword, "123Hello");

                    createdObjectIds.Add(_Uobject.UserId);

                })
                .When("I login", () =>
                {
                    _ret = _membershipApi.Login(_Uobject.UserName, _oldpassword);
                })
                .Then("The User can get Successful Logon",
                        () =>
                        {
                            _ret.ShouldEqual(LoginResults.Successful);
                        });

            this.CleanUp();
        }

 public void Verify()
 {
     _story = this.BDDfy();
     Assert.That(_story.Metadata, Is.Not.Null);
     Assert.That(_story.Metadata.Title, Is.EqualTo(StoryTitle));
     Assert.That(_story.Metadata.TitlePrefix, Is.EqualTo(StoryTitlePrefix));
 }

        public void Process(Story story)
        {
            foreach (var scenario in story.Scenarios)
            {
                var executor = new ScenarioExecutor(scenario);
                executor.InitializeScenario();

                if (scenario.Example != null)
                {
                    var unusedValue = scenario.Example.Values.FirstOrDefault(v => !v.ValueHasBeenUsed);
                    if (unusedValue != null) throw new UnusedExampleException(unusedValue);
                }

                var stepFailed = false;
                foreach (var executionStep in scenario.Steps)
                {
                    if (stepFailed && ShouldExecuteStepWhenPreviousStepFailed(executionStep))
                        break;

                    if (executor.ExecuteStep(executionStep) == Result.Passed) 
                        continue;

                    if (!executionStep.Asserts)
                        break;

                    stepFailed = true;
                }
            }
        }

 public StoryContentPageViewModel(Story story, int index, int height, int width)
 {
     _story = story;
     _index = index;
     _width = width;
     _height = height;
 }

        public void GetUserByCorrectGuid()
        {
            _story = new Story("Get Memebers By IMembershipApi");

            _story.AsA("User")
              .IWant("to be able to get members, and give the correct users' GUID")
              .SoThat("I can do somethings for members");

            IDictionary<Guid, UserObject> _Users = new Dictionary<Guid, UserObject>();

            _story.WithScenario("Get members by ImembershipApi with the correct userName")
                .Given("More than one correct GUID of users", () =>
                {
                    _Uobject = _utils.CreateUserObject("Eunge Liu", true);

                    _membershipApi.Save(_Uobject, "123Hello", "123Hello");

                    createdObjectIds.Add(_Uobject.UserId);

                })
                .When("I use the Get, I can get users ", () => _Uobject2 = _membershipApi.Get(_Uobject.UserId))
                .Then("The User2 is User1",
                        () =>
                        {
                            _Uobject.ShouldEqual(_Uobject2);
                        });

            this.CleanUp();
        }

 internal StoryInfo(Story story_id, int pic, int pic1, int pic2)
 {
     this.story_id = story_id;
     this.pic = pic;
     this.pic1 = pic2;
     this.pic2 = pic2;
 }

        public void Process(Story story)
        {
            // use this report only for tic tac toe stories
            if (story.Metadata == null || !story.Metadata.Type.Name.Contains("TicTacToe"))
                return;

            var scenario = story.Scenarios.First();
            var scenarioReport = new StringBuilder();
            scenarioReport.AppendLine(string.Format(" SCENARIO: {0}  ", scenario.Title));

            if (scenario.Result != Result.Passed && scenario.Steps.Any(s => s.Exception != null))
            {
                scenarioReport.Append(string.Format("    {0} : ", scenario.Result));
                scenarioReport.AppendLine(scenario.Steps.First(s => s.Result == scenario.Result).Exception.Message);
            }

            scenarioReport.AppendLine();

            foreach (var step in scenario.Steps)
                scenarioReport.AppendLine(string.Format("   [{1}] {0}", step.Title, step.Result));

            scenarioReport.AppendLine("--------------------------------------------------------------------------------");
            scenarioReport.AppendLine();

            File.AppendAllText(Path, scenarioReport.ToString());
        }

 public void Process(Story story)
 {
     foreach (var scenario in story.Scenarios)
     {
         Dispose(scenario);
     }
 }

        public override void SetUp()
        {
            sprint = new Sprint();
            story = new Story(new Project(), new Gebruiker(), null, StoryType.UserStory);

            base.SetUp();
        }