Esempio n. 1
0
 public ProjectAssemblyLoader(IProjectResolver projectResovler,
                              IAssemblyLoadContextAccessor loadContextAccessor,
                              ILibraryManager libraryManager)
 {
     _projectResolver = projectResovler;
     _loadContextAccessor = loadContextAccessor;
     _libraryManager = libraryManager;
 }
Esempio n. 2
0
 public ProjectAssemblyLoader(IAssemblyLoadContextAccessor loadContextAccessor,
                              IProjectResolver projectResolver,
                              ICompilationEngine compilationEngine)
 {
     _loadContextAccessor = loadContextAccessor;
     _compilationEngine = compilationEngine;
     _projectResolver = projectResolver;
 }
Esempio n. 3
0
 public PublishProject(
     ProjectReferenceDependencyProvider projectReferenceDependencyProvider,
     IProjectResolver projectResolver,
     LibraryDescription libraryDescription)
 {
     _projectReferenceDependencyProvider = projectReferenceDependencyProvider;
     _projectResolver = projectResolver;
     _libraryDescription = libraryDescription;
 }
Esempio n. 4
0
        public SiteQueries(
            IProjectResolver projectResolver,
            IBasicQueries<SiteSettings> queries,
            IBasicQueries<SiteHost> hostQueries
            )
        {
            this.projectResolver = projectResolver;
            this.queries = queries;
            this.hostQueries = hostQueries;

        }
        public ProjectLibraryExportProvider(IProjectResolver projectResolver,
                                            IServiceProvider serviceProvider)
        {
            _projectResolver = projectResolver;
            _serviceProvider = serviceProvider;

            // REVIEW: In the future we should be able to throw this away
            _projectLoadContext = new Lazy<IAssemblyLoadContext>(() =>
            {
                var factory = (IAssemblyLoadContextFactory)_serviceProvider.GetService(typeof(IAssemblyLoadContextFactory));
                return factory.Create(_serviceProvider);
            });
        }
Esempio n. 6
0
        public GeoCommands(
            IProjectResolver projectResolver,
            IBasicQueries <GeoCountry> countryQueries,
            IBasicCommands <GeoCountry> countryCommands,
            IBasicQueries <GeoZone> stateQueries,
            IBasicCommands <GeoZone> stateCommands

            )
        {
            this.projectResolver = projectResolver;
            this.countryQueries  = countryQueries;
            this.countryCommands = countryCommands;
            this.stateQueries    = stateQueries;
            this.stateCommands   = stateCommands;
        }
Esempio n. 7
0
 public GeoCommands(
     IProjectResolver projectResolver,
     IBasicQueries <GeoCountry> countryQueries,
     IBasicCommands <GeoCountry> countryCommands,
     IBasicQueries <GeoZone> stateQueries,
     IBasicCommands <GeoZone> stateCommands,
     IBasicCommands <Language> langCommands,
     IBasicCommands <Currency> currencyCommands
     )
 {
     this.projectResolver  = projectResolver;
     this.countryQueries   = countryQueries;
     this.countryCommands  = countryCommands;
     this.stateQueries     = stateQueries;
     this.stateCommands    = stateCommands;
     this.langCommands     = langCommands;
     this.currencyCommands = currencyCommands;
 }
Esempio n. 8
0
 public UserQueries(
     IProjectResolver projectResolver,
     IBasicQueries<SiteUser> userQueries,
     IBasicQueries<SiteRole> roleQueries,
     IBasicQueries<UserRole> userRoleQueries,
     IBasicQueries<UserClaim> claimQueries,
     IBasicQueries<UserLogin> loginQueries,
     IBasicQueries<UserLocation> locationQueries,
     IStoragePathResolver<UserLogin> loginPathResolver
     )
 {
     this.projectResolver = projectResolver;
     this.userQueries = userQueries;
     this.roleQueries = roleQueries;
     this.userRoleQueries = userRoleQueries;
     this.claimQueries = claimQueries;
     this.locationQueries = locationQueries;
     this.loginPathResolver = loginPathResolver;
     this.loginQueries = loginQueries;
 }
Esempio n. 9
0
 public Program(ILibraryManager libraries, IApplicationEnvironment env, IProjectResolver projectResolver)
 {
     _libraries       = libraries;
     _env             = env;
     _projectResolver = projectResolver;
 }
 public ProjectReferenceDependencyProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
     Dependencies = Enumerable.Empty<LibraryDescription>();
 }
Esempio n. 11
0
 public ModuleProjectLibraryExportProvider(IProjectResolver projectResolver,
                                           IServiceProvider serviceProvider)
 {
     _projectResolver = projectResolver;
     _serviceProvider = serviceProvider;
 }
 public ProjectReferenceDependencyProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
 }
Esempio n. 13
0
 public ProjectMetadataProvider(IProjectResolver projectResolver, ILibraryManager libraryManager)
 {
     _projectResolver = projectResolver;
     _libraryManager  = libraryManager;
 }
Esempio n. 14
0
        private static async Task EnsureData(
            ISiteQueries siteQueries,
            ISiteCommands siteCommands,
            IUserQueries userQueries,
            IUserCommands userCommands,
            IGeoQueries geoQueries,
            IGeoCommands geoCommands,
            IBasicQueries <SiteRole> roleQueries,
            IBasicQueries <SiteUser> userBasic,
            IProjectResolver projectResolver
            )
        {
            int count = await geoQueries.GetCountryCount();

            if (count == 0)
            {
                foreach (GeoCountry c in InitialData.BuildCountryList())
                {
                    await geoCommands.Add(c);
                }

                foreach (GeoZone c in InitialData.BuildStateList())
                {
                    await geoCommands.Add(c);
                }
            }

            //count = await geoQueries.GetLanguageCount();
            //if (count == 0)
            //{
            //    foreach (Language c in InitialData.BuildLanguageList())
            //    {
            //        await geoCommands.Add(c);
            //    }
            //}

            var all = await geoQueries.GetAllCurrencies();

            count = all.Count;
            if (count == 0)
            {
                foreach (Currency c in InitialData.BuildCurrencyList())
                {
                    await geoCommands.Add(c);
                }
            }

            count = await siteQueries.GetCount();

            SiteSettings newSite = null;

            if (count == 0)
            {
                // create first site
                newSite = InitialData.BuildInitialSite();
                await siteCommands.Create(newSite);
            }

            // ensure roles
            var projectId = await projectResolver.ResolveProjectId();

            count = await roleQueries.GetCountAsync(projectId);

            if (count == 0)
            {
                var adminRole = InitialData.BuildAdminRole();
                adminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(adminRole);

                var roleAdminRole = InitialData.BuildRoleAdminRole();
                roleAdminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(roleAdminRole);

                var contentAdminRole = InitialData.BuildContentAdminsRole();
                contentAdminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(contentAdminRole);

                var authenticatedUserRole = InitialData.BuildAuthenticatedRole();
                authenticatedUserRole.SiteId = newSite.Id;
                await userCommands.CreateRole(authenticatedUserRole);
            }

            // ensure admin user
            count = await userBasic.GetCountAsync(projectId);

            if (count == 0)
            {
                var role = await userQueries.FetchRole(newSite.Id, "Administrators");

                if (role != null)
                {
                    var adminUser = InitialData.BuildInitialAdmin();
                    adminUser.SiteId = newSite.Id;
                    await userCommands.Create(adminUser);

                    await userCommands.AddUserToRole(role.Id, adminUser.Id);

                    role = await userQueries.FetchRole(newSite.Id, "Authenticated Users");

                    if (role != null)
                    {
                        await userCommands.AddUserToRole(role.Id, adminUser.Id);
                    }
                }
            }
        }
Esempio n. 15
0
        private void WriteLockFile(LockFile previousLockFile,
                                   string projectLockFilePath,
                                   Runtime.Project project,
                                   List <GraphItem> graphItems,
                                   PackageRepository repository,
                                   IProjectResolver projectResolver,
                                   IEnumerable <TargetContext> contexts)
        {
            var resolver = new DefaultPackagePathResolver(repository.RepositoryRoot.Root);
            var previousPackageLibraries = previousLockFile?.PackageLibraries.ToDictionary(l => Tuple.Create(l.Name, l.Version));

            var lockFile = new LockFile();

            lockFile.Islocked = Lock;

            // Use empty string as the key of dependencies shared by all frameworks
            lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
                                                         string.Empty,
                                                         project.Dependencies.Select(x => x.LibraryRange.ToString())));

            foreach (var frameworkInfo in project.GetTargetFrameworks())
            {
                lockFile.ProjectFileDependencyGroups.Add(new ProjectFileDependencyGroup(
                                                             frameworkInfo.FrameworkName.ToString(),
                                                             frameworkInfo.Dependencies.Select(x => x.LibraryRange.ToString())));
            }

            // Record all libraries used
            foreach (var item in graphItems.OrderBy(x => x.Match.Library, new LibraryComparer()))
            {
                if (item.Match.LibraryType.Equals(Runtime.LibraryTypes.Implicit))
                {
                    continue;
                }

                var library = item.Match.Library;
                if (library.Name == project.Name)
                {
                    continue;
                }

                if (item.Match.LibraryType.Equals(Runtime.LibraryTypes.Project))
                {
                    var projectDependency = projectResolver.FindProject(library.Name);
                    var projectLibrary    = LockFileUtils.CreateLockFileProjectLibrary(project, projectDependency);

                    lockFile.ProjectLibraries.Add(projectLibrary);
                }
                else if (item.Match.LibraryType.Equals(Runtime.LibraryTypes.Package))
                {
                    var packageInfo = repository.FindPackagesById(library.Name)
                                      .FirstOrDefault(p => p.Version == library.Version);

                    if (packageInfo == null)
                    {
                        throw new InvalidOperationException($"Unresolved package: {library.Name}");
                    }

                    LockFilePackageLibrary previousLibrary = null;
                    previousPackageLibraries?.TryGetValue(Tuple.Create(library.Name, library.Version), out previousLibrary);

                    var package = packageInfo.Package;

                    // The previousLibrary can't be a project, otherwise exception has been thrown.
                    lockFile.PackageLibraries.Add(LockFileUtils.CreateLockFilePackageLibrary(
                                                      previousLibrary,
                                                      resolver,
                                                      package,
                                                      correctedPackageName: library.Name));
                }
                else
                {
                    throw new InvalidOperationException($"Unresolved library: {library.Name}");
                }
            }

            var packageLibraries = lockFile.PackageLibraries.ToDictionary(lib => Tuple.Create(lib.Name, lib.Version));

            // Add the contexts
            foreach (var context in contexts)
            {
                var target = new LockFileTarget();
                target.TargetFramework   = context.RestoreContext.FrameworkName;
                target.RuntimeIdentifier = context.RestoreContext.RuntimeName;

                foreach (var match in context.Matches.OrderBy(x => x.Library, new LibraryComparer()))
                {
                    if (match.Library.Name == project.Name)
                    {
                        continue;
                    }

                    if (match.LibraryType.Equals(Runtime.LibraryTypes.Project))
                    {
                        var projectDependency    = projectResolver.FindProject(match.Library.Name);
                        var projectTargetLibrary = LockFileUtils.CreateLockFileTargetLibrary(projectDependency, context.RestoreContext);
                        target.Libraries.Add(projectTargetLibrary);
                    }
                    else if (match.LibraryType.Equals(Runtime.LibraryTypes.Package))
                    {
                        var packageInfo = repository.FindPackagesById(match.Library.Name)
                                          .FirstOrDefault(p => p.Version == match.Library.Version);

                        var package = packageInfo.Package;

                        target.Libraries.Add(LockFileUtils.CreateLockFileTargetLibrary(
                                                 packageLibraries[Tuple.Create(match.Library.Name, match.Library.Version)],
                                                 package,
                                                 context.RestoreContext,
                                                 correctedPackageName: match.Library.Name));
                    }
                }

                lockFile.Targets.Add(target);
            }

            var lockFileFormat = new LockFileFormat();

            lockFileFormat.Write(projectLockFilePath, lockFile);
        }
 public ProjectReferenceDependencyProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
     Dependencies     = Enumerable.Empty <LibraryDescription>();
 }
 public ModuleProjectLibraryExportProvider(IProjectResolver projectResolver,
                                     IServiceProvider serviceProvider) {
     _projectResolver = projectResolver;
     _serviceProvider = serviceProvider;
 }
Esempio n. 18
0
 public CompilerOptionsProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
 }
Esempio n. 19
0
        private static async Task EnsureData(
            ISiteQueries siteQueries,
            ISiteCommands siteCommands,
            IUserQueries userQueries,
            IUserCommands userCommands,
            IGeoQueries geoQueries,
            IGeoCommands geoCommands,
            IBasicQueries<SiteRole> roleQueries,
            IBasicQueries<SiteUser> userBasic,
            IProjectResolver projectResolver
            )
        {
            
            int count = await geoQueries.GetCountryCount();
            if (count == 0)
            {
                foreach (GeoCountry c in InitialData.BuildCountryList())
                {
                    await geoCommands.Add(c);
                }

                foreach (GeoZone c in InitialData.BuildStateList())
                {
                    await geoCommands.Add(c);
                }
            }
            
            count = await siteQueries.GetCount();
            SiteSettings newSite = null;
            if (count == 0)
            {
                // create first site
                newSite = InitialData.BuildInitialSite();
                await siteCommands.Create(newSite);
            }

            // ensure roles
            var projectId = await projectResolver.ResolveProjectId();
            
            count = await roleQueries.GetCountAsync(projectId);
            if (count == 0)
            {
                var adminRole = InitialData.BuildAdminRole();
                adminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(adminRole);
                
                var roleAdminRole = InitialData.BuildRoleAdminRole();
                roleAdminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(roleAdminRole);
                
                var contentAdminRole = InitialData.BuildContentAdminsRole();
                contentAdminRole.SiteId = newSite.Id;
                await userCommands.CreateRole(contentAdminRole);

                var authenticatedUserRole = InitialData.BuildAuthenticatedRole();
                authenticatedUserRole.SiteId = newSite.Id;
                await userCommands.CreateRole(authenticatedUserRole);
                
            }

            // ensure admin user
            count = await userBasic.GetCountAsync(projectId);

            if (count == 0)
            {
                var role = await userQueries.FetchRole(newSite.Id, "Administrators");
                
                if (role != null)
                {
                    var adminUser = InitialData.BuildInitialAdmin();
                    adminUser.SiteId = newSite.Id;
                    await userCommands.Create(adminUser);
                    
                    await userCommands.AddUserToRole(role.Id, adminUser.Id);

                    role = await userQueries.FetchRole(newSite.Id, "Authenticated Users");
                    
                    if (role != null)
                    {
                        await userCommands.AddUserToRole(role.Id, adminUser.Id);
                    }
                }
                
            }

        }
Esempio n. 20
0
 private static string LocateExistingProject(IProjectResolver projectResolver, string projectName)
 {
     Runtime.Project project;
     if (projectResolver.TryResolveProject(projectName, out project))
     {
         return project.ProjectFilePath;
     }
     return string.Empty;
 }
Esempio n. 21
0
 public ProjectReferenceDependencyProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
 }
Esempio n. 22
0
 public CompilerOptionsProvider(IProjectResolver projectResolver)
 {
     _projectResolver = projectResolver;
 }