public static PackageLicenseModel FromV2Package(IPackageMetadata package)
 {
     return new PackageLicenseModel(
         package.Id,
         package.LicenseUrl,
         package.Authors);
 }

 public static Manifest Create(IPackageMetadata metadata)
 {
     return new Manifest
     {
         Metadata = new ManifestMetadata
         {
             Id = metadata.Id.SafeTrim(),
             Version = metadata.Version.ToStringSafe(),
             Title = metadata.Title.SafeTrim(),
             Authors = GetCommaSeparatedString(metadata.Authors),
             Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
             Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
             LicenseUrl = ConvertUrlToStringSafe(metadata.LicenseUrl),
             ProjectUrl = ConvertUrlToStringSafe(metadata.ProjectUrl),
             IconUrl = ConvertUrlToStringSafe(metadata.IconUrl),
             RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
             // DevelopmentDependency = metadata.DevelopmentDependency,
             Description = metadata.Description.SafeTrim(),
             Copyright = metadata.Copyright.SafeTrim(),
             Summary = metadata.Summary.SafeTrim(),
             ReleaseNotes = metadata.ReleaseNotes.SafeTrim(),
             Language = metadata.Language.SafeTrim(),
             DependencySets = CreateDependencySets(metadata),
             FrameworkAssemblies = CreateFrameworkAssemblies(metadata),
             ReferenceSets = CreateReferenceSets(metadata),
             MinClientVersionString = metadata.MinClientVersion.ToStringSafe()
         },
     };
 }

        public void Resolve(IPackageMetadata metadata, string folder, string templateName, bool forceUpgrade)
        {
            var gitMetadata = metadata as GitPackageMetadata;
            var protobuildMetadata = metadata as ProtobuildPackageMetadata;
            var folderMetadata = metadata as FolderPackageMetadata;

            if (gitMetadata != null)
            {
                ResolveGit(gitMetadata, folder, templateName, forceUpgrade);
                return;
            }

            if (protobuildMetadata != null)
            {
                ResolveProtobuild(protobuildMetadata, folder, templateName, forceUpgrade);
                return;
            }

            if (folderMetadata != null)
            {
                ResolveFolder(folderMetadata, folder, templateName);
                return;
            }

            throw new InvalidOperationException("Unexpected metadata type " + metadata.GetType().Name + " for source resolve.");
        }

        public static void SavePackage(IPackageMetadata packageMetadata, IEnumerable<IPackageFile> files, string targetFilePath, bool useTempFile)
        {
            var builder = new PackageBuilder();
            // set metadata
            CopyMetadata(packageMetadata, builder);
            // add files
            builder.Files.AddRange(files);

            // create package in the temprary file first in case the operation fails which would
            // override existing file with a 0-byte file.
            string fileNameToUse = useTempFile ? Path.GetTempFileName() : targetFilePath;
            try {
                using (Stream stream = File.Create(fileNameToUse)) {
                    builder.Save(stream);
                }

                if (useTempFile) {
                    File.Copy(fileNameToUse, targetFilePath, true);
                }
            }
            finally {
                try {
                    if (useTempFile && File.Exists(fileNameToUse)) {
                        File.Delete(fileNameToUse);
                    }
                }
                catch {
                    // don't care if this fails
                }
            }
        }

        public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted, bool appendV2ApiToUrl)
        {
            string requestUri = CreateRequestUri(appendV2ApiToUrl);

            HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);

            httpRequest.Method = "PUT";
            httpRequest.AllowAutoRedirect = true;
            httpRequest.KeepAlive = false;
            httpRequest.Headers.Add(ApiKeyHeader, apiKey);
            httpRequest.UserAgent = _userAgent;
            httpRequest.UseDefaultCredentials = true;
            httpRequest.PreAuthenticate = true;

            var multipartRequest = new MultipartWebRequest();
            multipartRequest.AddFile(new FileInfo(filePath), package.ToString());

            // sending package data asynchronously
            await multipartRequest.CreateMultipartRequest(httpRequest);

            // waiting for response asynchronously
            await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);

            if (pushAsUnlisted)
            {
                await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString(), appendV2ApiToUrl);
            }
        }

        public async Task PushPackage(string apiKey, string filePath, IPackageMetadata package, bool pushAsUnlisted)
        {
            string requestUri = EnsureTrailingSlash(_source) + ServiceEndpoint;
            
            HttpWebRequest httpRequest = WebRequest.CreateHttp(requestUri);
            httpRequest.Method = "PUT";
            httpRequest.AllowAutoRedirect = true;
            httpRequest.AllowWriteStreamBuffering = false;
            httpRequest.KeepAlive = false;
            httpRequest.Headers.Add(ApiKeyHeader, apiKey);
            httpRequest.UserAgent = _userAgent;

            var multipartRequest = new MultipartWebRequest();
            multipartRequest.AddFile(new FileInfo(filePath), package.ToString());

            // sending package data asynchronously
            await multipartRequest.CreateMultipartRequest(httpRequest);
            
            // waiting for response asynchronously
            await EnsureSuccessfulResponse(httpRequest, HttpStatusCode.Created);

            if (pushAsUnlisted)
            {
                await DeletePackageFromServer(apiKey, package.Id, package.Version.ToString());
            }
        }

        public static bool IsSatellitePackage(
            IPackageMetadata package, 
            IPackageRepository repository,
            FrameworkName targetFramework,
            out IPackage runtimePackage)
        {
            // A satellite package has the following properties:
            //     1) A package suffix that matches the package's language, with a dot preceding it
            //     2) A dependency on the package with the same Id minus the language suffix
            //     3) The dependency can be found by Id in the repository (as its path is needed for installation)
            // Example: foo.ja-jp, with a dependency on foo

            runtimePackage = null;

            if (package.IsSatellitePackage())
            {
                string runtimePackageId = package.Id.Substring(0, package.Id.Length - (package.Language.Length + 1));
                PackageDependency dependency = package.FindDependency(runtimePackageId, targetFramework);

                if (dependency != null)
                {
                    runtimePackage = repository.FindPackage(runtimePackageId, versionSpec: dependency.VersionSpec, allowPrereleaseVersions: true, allowUnlisted: true);
                }
            }

            return runtimePackage != null;
        }

 public RoslynReflector(IPackageMetadata package)
 {
     _types = new Dictionary<string, TypeModel>();
     _namespaces = new Dictionary<string, NamespaceModel>();
     _extensions = new Dictionary<string, ExtensionModel>();
     _package = package;
 }

 public static IPackage BuildPackage(IPackageMetadata metadata, IEnumerable<IPackageFile> files)
 {
     var builder = new PackageBuilder();
     CopyMetadata(metadata, builder);
     builder.Files.AddRange(files);
     return builder.Build();
 }

 public static Manifest Create(IPackageMetadata metadata)
 {
     return new Manifest {
         Metadata = new ManifestMetadata {
             Id = metadata.Id.SafeTrim(),
             Version = metadata.Version.ToStringSafe(),
             Title = metadata.Title.SafeTrim(),
             Authors = GetCommaSeparatedString(metadata.Authors),
             Owners = GetCommaSeparatedString(metadata.Owners) ?? GetCommaSeparatedString(metadata.Authors),
             Tags = String.IsNullOrEmpty(metadata.Tags) ? null : metadata.Tags.SafeTrim(),
             LicenseUrl = metadata.LicenseUrl != null ? metadata.LicenseUrl.OriginalString.SafeTrim() : null,
             ProjectUrl = metadata.ProjectUrl != null ? metadata.ProjectUrl.OriginalString.SafeTrim() : null,
             IconUrl = metadata.IconUrl != null ? metadata.IconUrl.OriginalString.SafeTrim() : null,
             RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
             Description = metadata.Description.SafeTrim(),
             Summary = metadata.Summary.SafeTrim(),
             Language = metadata.Language.SafeTrim(),
             Dependencies = metadata.Dependencies == null ||
                            !metadata.Dependencies.Any() ? null :
                            (from d in metadata.Dependencies
                             select new ManifestDependency {
                                 Id = d.Id.SafeTrim(),
                                 Version = d.VersionSpec.ToStringSafe()
                             }).ToList(),
             FrameworkAssemblies = metadata.FrameworkAssemblies == null ||
                                   !metadata.FrameworkAssemblies.Any() ? null :
                                   (from reference in metadata.FrameworkAssemblies
                                    select new ManifestFrameworkAssembly {
                                        AssemblyName = reference.AssemblyName,
                                        TargetFramework = String.Join(", ", reference.SupportedFrameworks.Select(VersionUtility.GetFrameworkString))
                                    }).ToList()
         }
     };
 }

 public bool Equals(IPackageMetadata other)
 {
     return Id.Equals(other.Id)
            && Version.Equals(other.Version)
            && LocalPath.Equals(other.LocalPath)
            && AreTargetFrameworksEqual(TargetFrameworks, other.TargetFrameworks)
            && AreAssembliesEqual(Assemblies, other.Assemblies);
 }

 public void NotifyFileAdded(IPackageMetadata package, string filepath, PackageType packageType)
 {
     var item = new MruItem {
         Path = filepath.ToLowerInvariant(),
         Id = package.Id,
         Version = package.Version,
         PackageType = packageType
     };
     AddFile(item);
 }

        public void GetProtobuildPackageBinary(IPackageMetadata metadata, out string archiveType, out byte[] packageData)
        {
            var protobuildPackageMetadata = metadata as ProtobuildPackageMetadata;
            if (protobuildPackageMetadata == null)
            {
                throw new InvalidOperationException("Can't call GetProtobuildPackageBinary on non-Protobuild package metadata");
            }

            archiveType = protobuildPackageMetadata.BinaryFormat;
            packageData = GetProtobuildBinaryPackage(protobuildPackageMetadata);
        }

        public IPackage DownloadPackage(IHttpClient downloadClient, byte[] packageHash, IPackageMetadata package)
        {
            if (downloadClient == null)
            {
                throw new ArgumentNullException("downloadClient");
            }
            if (packageHash == null)
            {
                throw new ArgumentNullException("packageHash");
            }
            if (package == null)
            {
                throw new ArgumentNullException("package");
            }

            // Get the operation display text
            string operation = String.Format(CultureInfo.CurrentCulture, NuGetResources.DownloadProgressStatus, package.Id, package.Version);

            EventHandler<ProgressEventArgs> progressAvailableHandler = (sender, e) =>
            {
                OnPackageDownloadProgress(new ProgressEventArgs(operation, e.PercentComplete));
            };

            EventHandler<WebRequestEventArgs> beforeSendingRequesthandler = (sender, e) =>
            {
                OnSendingRequest(e.Request);
            };

            try
            {
                downloadClient.ProgressAvailable += progressAvailableHandler;
                downloadClient.SendingRequest += beforeSendingRequesthandler;

                // TODO: This gets held onto in memory which we want to get rid of eventually
                byte[] buffer = downloadClient.DownloadData();

                if (!_hashProvider.VerifyHash(buffer, packageHash))
                {
                    throw new InvalidDataException(NuGetResources.PackageContentsVerifyError);
                }

                return _packageFactory.CreatePackage(() =>
                {
                    return new MemoryStream(buffer);
                });
            }
            finally
            {
                downloadClient.ProgressAvailable -= progressAvailableHandler;
                downloadClient.SendingRequest -= beforeSendingRequesthandler;
            }
        }

        public virtual void DownloadPackage(Uri uri, IPackageMetadata package, Stream targetStream)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }

            var downloadClient = new HttpClient(uri)
                                 {
                                     UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient)
                                 };
            DownloadPackage(downloadClient, package, targetStream);
        }

 private void OutputDependencies(IPackageMetadata package)
 {
     if (package.DependencySets.Any())
     {
         Console.WriteLine("Package Dependencies:");
         foreach (var dependencySet in package.DependencySets)
         {
             foreach (var dependency in dependencySet.Dependencies)
             {
                 Console.WriteLine("".PadLeft(_indent) + string.Format("{0} - {1} {2}",dependencySet.TargetFramework, dependency.Id, dependency.VersionSpec));
             }
         }
     }
 }

        static void checkIfNuspecHasRequiredFields(IPackageMetadata zp, string packageFile)
        {
            if (String.IsNullOrWhiteSpace(zp.Id))
                throw new Exception(String.Format("Invalid 'id' value in nuspec file at '{0}'", packageFile));

            if (String.IsNullOrWhiteSpace(zp.Version.ToString()))
                throw new Exception(String.Format("Invalid 'version' value in nuspec file at '{0}'", packageFile));

            if (zp.Authors.All(String.IsNullOrWhiteSpace))
                throw new Exception(String.Format("Invalid 'authors' value in nuspec file at '{0}'", zp.Authors));

            if (String.IsNullOrWhiteSpace(zp.Description))
                throw new Exception(String.Format("Invalid 'description' value in nuspec file at '{0}'", zp.Description));
        }

        public virtual IPackage DownloadPackage(Uri uri, IPackageMetadata package)
        {
            if (uri == null)
            {
                throw new ArgumentNullException("uri");
            }
            if (package == null)
            {
                throw new ArgumentNullException("package");
            }

            var downloadClient = new HttpClient(uri)
                                 {
                                     UserAgent = HttpUtility.CreateUserAgentString(DefaultUserAgentClient)
                                 };
            return DownloadPackage(downloadClient, package);
        }

        public void CreatePackage(string apiKey, Stream packageStream, IObserver<int> progressObserver, IPackageMetadata metadata = null)
        {
            var state = new PublishState {
                PublishKey = apiKey,
                PackageMetadata = metadata,
                ProgressObserver = progressObserver
            };

            var url = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}/{1}/{2}/nupkg", _baseGalleryServerUrl, CreatePackageService, apiKey));

            WebClient client = new WebClient();
            client.Proxy = _cachedProxy;
            client.Headers[HttpRequestHeader.ContentType] = "application/octet-stream";
            client.Headers[HttpRequestHeader.UserAgent] = _userAgent;
            client.UploadProgressChanged += OnUploadProgressChanged;
            client.UploadDataCompleted += OnCreatePackageCompleted;
            client.UploadDataAsync(url, "POST", packageStream.ReadAllBytes(), state);
        }

 private static void CopyMetadata(IPackageMetadata source, PackageBuilder builder)
 {
     builder.Id = source.Id;
     builder.Version = source.Version;
     builder.Title = source.Title;
     builder.Authors.AddRange(source.Authors);
     builder.Owners.AddRange(source.Owners);
     builder.IconUrl = source.IconUrl;
     builder.LicenseUrl = source.LicenseUrl;
     builder.ProjectUrl = source.ProjectUrl;
     builder.RequireLicenseAcceptance = source.RequireLicenseAcceptance;
     builder.Description = source.Description;
     builder.Summary = source.Summary;
     builder.Language = source.Language;
     builder.Tags.AddRange(ParseTags(source.Tags));
     builder.Dependencies.AddRange(source.Dependencies);
     builder.FrameworkReferences.AddRange(source.FrameworkAssemblies);
 }