public bool RequiresPackageRestore(FunctionMetadata metadata)
 {
     return(PackageManager.RequiresPackageRestore(Path.GetDirectoryName(metadata.ScriptFile)));
 }
        public async Task RestorePackagesAsync()
        {
            var packageManager = new PackageManager(_functionMetadata, _traceWriter);
            await packageManager.RestorePackagesAsync();

            // Reload the resolver
            _packageAssemblyResolver = new PackageAssemblyResolver(_functionMetadata);
        }
        private static ImmutableArray <PackageReference> InitializeAssemblyRegistry(FunctionMetadata metadata)
        {
            var builder = ImmutableArray <PackageReference> .Empty.ToBuilder();

            string fileName = Path.Combine(Path.GetDirectoryName(metadata.ScriptFile), DotNetConstants.ProjectLockFileName);

            if (File.Exists(fileName))
            {
                var jobject = JObject.Parse(File.ReadAllText(fileName));

                var target = jobject.SelectTokens(string.Format(CultureInfo.InvariantCulture, "$.targets['{0}']", FrameworkTargetName)).FirstOrDefault();

                if (target != null)
                {
                    string nugetHome = PackageManager.GetNugetPackagesPath();

                    foreach (JProperty token in target)
                    {
                        var referenceNameParts = token.Name.Split('/');
                        if (referenceNameParts.Length != 2)
                        {
                            throw new FormatException(string.Format(CultureInfo.InvariantCulture, "The package name '{0}' is not correctly formatted.", token.Name));
                        }

                        var package = new PackageReference(referenceNameParts[0], referenceNameParts[1]);

                        var references = token.SelectTokens("$..compile").FirstOrDefault();
                        if (references != null)
                        {
                            foreach (JProperty reference in references)
                            {
                                if (!reference.Name.EndsWith(EmptyFolderFileMarker, StringComparison.Ordinal))
                                {
                                    string path = Path.Combine(nugetHome, token.Name, reference.Name);
                                    path = path.Replace('/', '\\');

                                    if (File.Exists(path))
                                    {
                                        package.Assemblies.Add(AssemblyName.GetAssemblyName(path), path);
                                    }
                                }
                            }
                        }

                        var frameworkAssemblies = token.SelectTokens("$..frameworkAssemblies").FirstOrDefault();
                        if (frameworkAssemblies != null)
                        {
                            foreach (var assembly in frameworkAssemblies)
                            {
                                string assemblyName = assembly.ToString();
                                package.FrameworkAssemblies.Add(new AssemblyName(assemblyName), assemblyName);
                            }
                        }

                        builder.Add(package);
                    }
                }
            }

            return(builder.ToImmutableArray());
        }