public async Task <GetProjectDTO <ProjectEditViewModel> > CreateNewProjectAsync(string portfolio)
        {
            var context = ServiceContext.PortfolioContext;
            var config  = await portfolioService.GetConfigAsync(portfolio);

            ServiceContext.AssertPermission(config.Portfolio);
            var reservation = await portfolioService.GetProjectReservationAsync(config);

            await context.SaveChangesAsync();

            var newProject = new Project()
            {
                Reservation = reservation
            };

            ProjectEditViewModel newProjectModel = ProjectModelFactory.GetProjectEditModel(newProject);

            var result = new GetProjectDTO <ProjectEditViewModel>()
            {
                Config  = PortfolioMapper.GetProjectLabelConfigModel(config, PortfolioFieldFlags.Create),
                Options = await portfolioService.GetNewProjectOptionsAsync(config),
                Project = newProjectModel
            };

            return(result);
        }
        private async Task <GetProjectDTO <T> > GetProject <T>(string projectId,
                                                               bool includeOptions,
                                                               bool includeHistory,
                                                               bool includeLastUpdate,
                                                               bool includeConfig,
                                                               PortfolioFieldFlags flags             = PortfolioFieldFlags.Read,
                                                               Action <Portfolio> permissionCallback = null)
            where T : ProjectModel, new()
        {
            string            portfolio;
            GetProjectDTO <T> result;


            var context     = ServiceContext.PortfolioContext;
            var reservation = await context.ProjectReservations
                              .SingleOrDefaultAsync(r => r.ProjectId == projectId);

            if (reservation == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }

            var query = (from p in context.Projects
                         .IncludeProject()
                         .IncludeLabelConfigs() // Need label configs so can map project data fields
                         where p.ProjectReservation_Id == reservation.Id
                         select p);

            if (includeHistory || includeLastUpdate)
            {
                query = query.IncludeUpdates();
            }

            var project = await query.SingleOrDefaultAsync();

            if (project == null)
            {
                throw new HttpResponseException(HttpStatusCode.NotFound);
            }
            if (permissionCallback != null)
            {
                permissionCallback(project.Reservation.Portfolio);
            }
            else
            {
                ServiceContext.AssertPermission(project.Reservation.Portfolio);
            }

            portfolio = project.Reservation.Portfolio.ViewKey;

            // Build the result
            result = new GetProjectDTO <T>()
            {
                Project = ProjectModelFactory.GetProjectModel <T>(project, includeHistory, includeLastUpdate)
            };

            if (includeConfig)
            {
                var userIsFSA = ServiceContext.UserHasFSAClaim();
                result.Config = PortfolioMapper.GetProjectLabelConfigModel(project.Reservation.Portfolio.Configuration, flags: flags, fsaOnly: !userIsFSA);
            }
            if (includeOptions)
            {
                var config = await portfolioService.GetConfigAsync(portfolio);

                result.Options = await portfolioService.GetNewProjectOptionsAsync(config, result.Project as ProjectEditViewModel);
            }

            return(result);
        }