C# IProjectRepository.GetById方法代码示例

        public static Stack ToProjectLocalTime(this Stack stack, IProjectRepository repository)
        {
            if (stack == null)
                return null;

            return stack.ToProjectLocalTime(repository.GetById(stack.ProjectId, true));
        }

        public ProjectModule(IProjectRepository projectRepository)
            :base("/read/projects")
        {
            this.RequiresAuthentication();

            Get["/"] = _ => Json(projectRepository.ToList());

            Get["/{id:guid}"] = parameters => Json(projectRepository.GetById((Guid)parameters.id));

            Get["/getactive"] = parameters => Json(projectRepository.GetActive());
        }

        public static WebHookStack FromStack(Stack stack, IProjectRepository projectRepository, IOrganizationRepository organizationRepository) {
            if (stack == null)
                throw new ArgumentNullException("stack");

            if (projectRepository == null)
                throw new ArgumentNullException("projectRepository");

            if (organizationRepository == null)
                throw new ArgumentNullException("organizationRepository");

            var project = projectRepository.GetById(stack.ProjectId);
            if (project == null)
                throw new ArgumentException("ProjectId not found.");

            var organization = organizationRepository.GetById(stack.OrganizationId);
            if (organization == null)
                throw new ArgumentException("OrganizationId not found.");

            return new WebHookStack {
                Id = stack.Id,
                Title = stack.Title,
                Description = stack.Description,
                Tags = stack.Tags,
                RequestPath = stack.SignatureInfo.ContainsKey("Path") ? stack.SignatureInfo["Path"] : null,
                Type = stack.SignatureInfo.ContainsKey("ExceptionType") ? stack.SignatureInfo["ExceptionType"] : null,
                TargetMethod = stack.SignatureInfo.ContainsKey("Method") ? stack.SignatureInfo["Method"] : null,
                ProjectId = stack.ProjectId,
                ProjectName = project.Name,
                OrganizationId = stack.OrganizationId,
                OrganizationName = organization.Name,
                TotalOccurrences = stack.TotalOccurrences,
                FirstOccurrence = stack.FirstOccurrence,
                LastOccurrence = stack.LastOccurrence,
                DateFixed = stack.DateFixed,
                IsRegression = stack.IsRegressed,
                IsCritical = stack.OccurrencesAreCritical || stack.Tags != null && stack.Tags.Contains("Critical"),
                FixedInVersion = stack.FixedInVersion
            };
        }

        public CollaboratorModule(IDispatcherFactory dispatcherFactory, IProjectRepository projectRepository)
        {
            Post["/projects/{projectId}/collaborators"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    var request = this.Bind<AddCollaboratorRequest>();
                    var command = new AddCollaborator(projectId, request.UserId, request.Level);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Get["/projects/{projectId}/collaborators"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Project project = projectRepository.GetById(projectId);
                    IEnumerable<CollaboratorResponse> collaboratorResponses =
                        project.Collaborators.Select(x => new CollaboratorResponse
                                                          {
                                                              UserId = x.UserId,
                                                              Name=x.UserName,
                                                              Level = x.Level.ToString()
                                                          }).ToList();
                    return new CollaboratorListResponse(collaboratorResponses);
                };

            Delete["/projects/{projectId}/collaborators/{userId}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid userId = Guid.Parse((string) p.userId);
                    var command = new RemoveCollaborator(projectId, userId);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };
        }

        public StepModule(IDispatcherFactory dispatcherFactory, IMappingEngine mappingEngine,
            IProjectRepository projectRepository)
        {
            Post["/scenarios/{scenarioId}/criteria/{criterionId}/steps/{stepId}/started"] =
                p =>
                {
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    Guid criterionId = Guid.Parse((string) p.criterionId);
                    Guid stepId = Guid.Parse((string) p.stepId);

                    var request = this.Bind<TestStartRequest>();

                    var command = new StartStep(scenarioId, criterionId, stepId, request.Time);
                    dispatcherFactory.Create(this.UserSession(), command)
                        .Dispatch(this.UserSession(),
                            command);
                    return null;
                };

            Post["/scenarios/{scenarioId}/criteria/{criterionId}/steps/{stepId}/stopped"] =
                p =>
                {
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    Guid criterionId = Guid.Parse((string) p.criterionId);
                    Guid stepId = Guid.Parse((string) p.stepId);

                    var testResultData = this.Bind<TestResultData>();

                    var command = new StopStep(scenarioId, criterionId, stepId, testResultData.Passing,
                        testResultData.Duration, testResultData.Time, testResultData.Message,
                        testResultData.Screenshot);
                    dispatcherFactory.Create(this.UserSession(), command)
                        .Dispatch(this.UserSession(),
                            command);

                    return null;
                };

            Delete["{projectId}/steps/{id}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    var command = new DeleteStep(projectId, Guid.Parse((string) p.id));
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(),
                            command);
                    return null;
                };

            Get["{projectId}/scenarios/{scenarioId}/steps/{stepId}"] =
                p =>
                {
                    Guid stepId = Guid.Parse((string) p.stepId);
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Project project = projectRepository.GetById(projectId);
                    Scenario scenario = project.Stories.SelectMany(x => x.Scenarios)
                        .First(x => x.Id == scenarioId);

                    Step step = scenario
                        .GetLinkedCriteria()
                        .SelectMany(x => x.Criterion.GetSteps())
                        .FirstOrDefault(x => x.Id == stepId);

                    if (step == null) throw new ItemNotFoundException<Step>(stepId);

                    StepDetailResponse stepDetailResponse = mappingEngine.Map<Step, StepDetailResponse>(step);

                    List<LinkedStep> stepRunResults =
                        scenario.GetLinkedCriteria().SelectMany(x => x.GetLinkedSteps()).Where(x => x.Step.Id == stepId)
                            .ToList();

                    stepDetailResponse.Results = stepRunResults.Select(x => new StepResultResponse
                                                                            {
                                                                                Details = x.LastResult().GetDetails(),
                                                                                Duration = x.LastResult().Duration,
                                                                                Message = x.LastResult().GetMessage(),
                                                                                ScreenShotUrl =
                                                                                    x.LastResult().ScreenShotUrl,
                                                                                Time =
                                                                                    x.LastResult().Time.HasValue
                                                                                        ? x.LastResult().Time.Value
                                                                                        : DateTime.MinValue
                                                                            }).ToList();

                    LinkedCriterion linkedCriterion =
                        scenario.GetLinkedCriteria().First(x => x.Criterion.GetSteps().Any(s => s.Id == stepId));
                    LinkedStep linkedStep = linkedCriterion.GetLinkedSteps().First(x => x.Step.Id == stepId);
                    stepDetailResponse.LastRun = linkedStep.LastRun();
                    stepDetailResponse.ScreenShotUrl = linkedStep.GetLastScreenshot();
                    stepDetailResponse.Result = linkedStep.GetTestStatus().ToString();

                    return stepDetailResponse;
                };

            Put["{projectId}/criteria/{criteriaId}/steps/order"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid criteriaId = Guid.Parse((string) p.criteriaId);
//.........这里部分代码省略.........

        public ProjectModule(IDispatcherFactory dispatcherFactory,
            IProjectRepository projectRepository, IMappingEngine mappingEngine)
        {
            Post["/projects/{id}/run"] =
                p =>
                {
                    Guid id = Guid.Parse((string) p.id);
                    var command = new QueueProject(id);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Get["/projects"] =
                _ =>
                {
                    User user = this.UserLoginSession().User;
                    IEnumerable<Project> projects = projectRepository.GetForUser(user);
                    IEnumerable<ProjectListingResponse> projectListingResponses =
                        mappingEngine.Map<IEnumerable<Project>, IEnumerable<ProjectListingResponse>>(projects);
                    return new ProjectListResponse(projectListingResponses);
                };

            Get["/projects/{projectId}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid userId = this.UserLoginSession().User.Id;
                    Project project = projectRepository.GetById(projectId);
                    ProjectDetailsResponse response = mappingEngine.Map<Project, ProjectDetailsResponse>(project);
                    if (response == null) throw new ItemNotFoundException<Project>(projectId);
                    return response;
                };

            Get["/projects/{id}/backup"] =
                p =>
                {
                    throw new NotImplementedException();
                    //Guid id = Guid.Parse((string) p.id);
                    //Project project = projectRepository.GetById(id);

                    //if (project.Collaborators.All(x => x.UserId != this.UserLoginSession().User.Id))
                    //{
                    //    throw new UnauthorizedAccessException("That's not your project!");
                    //}

                    //if (project == null) throw new ItemNotFoundException<Project>(id);

                    //var projectBackupResponse = new ProjectBackupResponse
                    //                            {
                    //                                Name = project.Name,
                    //                                Id = project.Id,
                    //                                History = GetFilteredEventd(project)
                    //                            };
                    //return projectBackupResponse;
                };

            Post["/projects/restore"] =
                p =>
                {
                    throw new NotImplementedException();
                    //string body = Request.Body.AsString();
                    //var projectBackupResponse = JsonConvert.DeserializeObject<ProjectBackupResponse>(body,
                    //    new JsonSerializerSettings {TypeNameHandling = TypeNameHandling.Objects});

                    //var command = new RestoreProject(projectBackupResponse.History);
                    //dispatcherFactory.Create(this.UserLoginSession(), command)
                    //    .Dispatch(this.UserLoginSession(), command);
                    //return null;
                };

            Post["/projects"] =
                _ =>
                {
                    var projectData = this.Bind<NewProjectRequest>();
                    var command = new CreateNewProject(Guid.NewGuid(), projectData.Name);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Put["/projects/{projectId}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    var projectData = this.Bind<ChangeNameRequest>();
                    var command = new ChangeProjectName(projectId, projectData.Name);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Delete["/projects/{id}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.id);
                    var command = new DeleteProject(projectId);
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
//.........这里部分代码省略.........

        public CriteriaModule(IMappingEngine mappingEngine, IDispatcherFactory dispatcherFactory,
            IReadOnlyRepository readOnlyRepository,
            IProjectRepository projectRepository)
        {
            Put["{projectId}/scenarios/{scenarioId}/criteria/order"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    var orderChangeRequests = this.Bind<List<CriterionPriorityChangeRequest>>();
                    var command = new ChangeCriterionOrder(projectId, scenarioId,
                        orderChangeRequests.Select(x => new CriterionOrderChange(x.CriterionId, x.Priority)));
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Delete["{projectId}/scenario/{scenarioId}/criteria/{id}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    var command = new RemoveCriterionFromScenario(projectId, scenarioId, Guid.Parse((string) p.id));
                    dispatcherFactory.Create(this.UserLoginSession(), command)
                        .Dispatch(this.UserLoginSession(), command);
                    return null;
                };

            Get["{projectId}/scenarios/{scenarioId}/criteria"] =
                p =>
                {
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    var scenario = readOnlyRepository.GetById<Scenario>(scenarioId);
                    IEnumerable<CriteriaListingResponse> criteriaListingResponses = mappingEngine
                        .Map<IEnumerable<LinkedCriterion>, IEnumerable<CriteriaListingResponse>>(
                            scenario.GetLinkedCriteria());
                    return new CriteriaListResponse(criteriaListingResponses.ToList());
                };

            Get["{projectId}/scenarios/{scenarioId}/criteria/{criterionId}"] =
                p =>
                {
                    Guid criterionId = Guid.Parse((string) p.criterionId);
                    Guid scenarioId = Guid.Parse((string) p.scenarioId);
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Project project = projectRepository.GetById(projectId);
                    LinkedCriterion linkedCriterion = project.Stories
                        .SelectMany(x => x.Scenarios)
                        .First(x => x.Id == scenarioId).GetLinkedCriteria()
                        .FirstOrDefault(x => x.Criterion.Id == criterionId);

                    if (linkedCriterion == null) throw new ItemNotFoundException<Criterion>(criterionId);

                    CriterionDetailsResponse criterionDetailsResponse =
                        mappingEngine.Map<LinkedCriterion, CriterionDetailsResponse>(linkedCriterion);

                    criterionDetailsResponse.Steps =
                        linkedCriterion.Criterion.GetSteps()
                            .Select(step =>
                                    {
                                        LinkedStep linkedStep =
                                            linkedCriterion.GetLinkedSteps().First(x => x.Step.Id == step.Id);
                                        return new StepListingResponse
                                               {
                                                   StepId = step.Id,
                                                   CriterionId = step.Criterion.Id,
                                                   Priority = step.Priority,
                                                   RunsIn = step.Criterion.RunsIn.ToString(),
                                                   ScreenShotUrl = linkedStep.GetLastScreenshot(),
                                                   Description = step.GetDescription(),
                                                   LastRun = linkedStep.LastRun(),
                                                   Result = linkedStep.GetTestStatus().ToString()
                                               };
                                    }).ToList();

                    return criterionDetailsResponse;
                };

            Get["{projectId}/criteria"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Project project = projectRepository.GetById(projectId);
                    IEnumerable<LinkedCriterion> criteria =
                        project.Stories.SelectMany(x => x.Scenarios).SelectMany(x => x.GetLinkedCriteria())
                            .Distinct(new LinkedCriterionComparer());

                    return
                        new CriteriaListResponse(
                            mappingEngine.Map<IEnumerable<LinkedCriterion>, IEnumerable<CriteriaListingResponse>>(
                                criteria));
                };

            Put["/projects/{projectId}/criteria/{criterionId}"] =
                p =>
                {
                    Guid projectId = Guid.Parse((string) p.projectId);
                    Guid criterionId = Guid.Parse((string) p.criterionId);
                    var projectData = this.Bind<ChangeNameRequest>();
                    var command = new ChangeCriterionName(projectId, criterionId, projectData.Name);
//.........这里部分代码省略.........