Пример #1
0
  public static PackageInfo GetPackageManifest(string path)
 {
     PackageInfo package = new PackageInfo();           
     XmlDocument doc = new XmlDocument();
         doc.Load(path);   
         XmlNode root = doc.DocumentElement;
         XmlNodeList xnList = doc.SelectNodes("sageframe/packages/package");
         foreach (XmlNode xn in xnList)
         {
            
             package.Description = xn["description"].InnerXml.ToString();
             package.Version = xn.Attributes["version"].InnerText.ToString();
             package.OwnerName = xn["owner"].ChildNodes[0].InnerXml.ToString();
             package.Organistaion = xn["owner"].ChildNodes[1].InnerXml.ToString();
             package.URL = xn["owner"].ChildNodes[2].InnerXml.ToString();
             package.Email = xn["owner"].ChildNodes[3].InnerXml.ToString();
             package.ReleaseNotes = xn["releasenotes"].InnerXml.ToString();
             package.License = xn["license"].InnerXml.ToString();
         }
     
     
     return package;
     
     
 }
Пример #2
0
 public Package(string name, PackageInfo info, PackageStatus status)
 {
     Name = name;
     Id = (info != null ? info.PackageId : null);
     Info = info;
     Status = status;
 }
Пример #3
0
        private static void WritePackageDetails(XmlWriter writer, List<FileDetails> selectedResxFiles,PackageInfo package)
        {
            writer.WriteStartElement("package");
            writer.WriteAttributeString("name", package.PackageName);
            writer.WriteAttributeString("type", package.PackageType);
            writer.WriteAttributeString("version", package.Version);
            writer.WriteElementString("friendlyname", package.FriendlyName);
            writer.WriteElementString("description", package.Description);
            writer.WriteStartElement("owner");
            writer.WriteElementString("name", package.OwnerName);
            writer.WriteElementString("organization",package.Organistaion);
            writer.WriteElementString("url","");
            writer.WriteElementString("email", package.Email);
            writer.WriteEndElement();
            writer.WriteElementString("license", package.License);
            writer.WriteElementString("releasenotes", package.ReleaseNotes);
            writer.WriteStartElement("components");
            writer.WriteStartElement("component");
            writer.WriteAttributeString("type", "CoreLanguage");
            writer.WriteStartElement("languagefiles");
            writer.WriteElementString("code","");
            writer.WriteElementString("displayname", "");
            writer.WriteElementString("fallback", "");           
           
            WritePackageResources(writer,selectedResxFiles);

            WritePackageEndElements(writer);
           

        }
Пример #4
0
        static void CreateAssembly(PackageInfo package) {

            // Save the snk file from the embedded resource to the disk so we can use it when we compile
            using (var resStream = typeof(Program).Assembly.GetManifestResourceStream("GenerateTestPackages." + keyFileName)) {
                using (var snkStream = File.Create(keyFileName)) {
                    resStream.CopyTo(snkStream);
                }
            }


            var codeProvider = new CSharpCodeProvider();
            var compilerParams = new CompilerParameters() {
                OutputAssembly = Path.GetFullPath(GetAssemblyFullPath(package.FullName)),
                CompilerOptions = "/keyfile:" + keyFileName
            };

            // Add all the dependencies as referenced assemblies
            foreach (DependencyInfo dependency in package.Dependencies) {
                compilerParams.ReferencedAssemblies.Add(GetAssemblyFullPath(dependency.FullName));
            }

            // Create the source code and compile it using CodeDom
            var generator = new AssemblySourceFileGenerator() { Package = package };
            CompilerResults results = codeProvider.CompileAssemblyFromSource(compilerParams, generator.TransformText());

            if (results.Errors.HasErrors) {
                Console.WriteLine(results.Errors[0]);
            }

            File.Delete(keyFileName);
        }
Пример #5
0
        public IPackageInfo LoadFromFolder(string folder)
        {
            folder = Path.GetFullPath(folder);

            var manifest = _fileSystem.LoadFromFile<PackageManifest>(folder, PackageManifest.FILE);
            var package = new PackageInfo(manifest.Name){
                Description = "{0} ({1})".ToFormat(manifest.Name, folder)
            };

            // Right here, this needs to be different
            package.RegisterFolder(BottleFiles.WebContentFolder, _getContentFolderFromPackageFolder(folder));
            package.RegisterFolder(BottleFiles.DataFolder, Path.Combine(folder, BottleFiles.DataFolder));

            var binPath = FileSystem.Combine(_applicationFolder, folder, "bin");
            var debugPath = FileSystem.Combine(binPath, "debug");
            if(_fileSystem.DirectoryExists(debugPath))
            {
                binPath = debugPath;
            }

            var assemblyPaths = findCandidateAssemblyFiles(binPath);
            assemblyPaths.Each(path =>
            {
                var assemblyName = Path.GetFileNameWithoutExtension(path);
                if (manifest.AssemblyNames.Contains(assemblyName))
                {
                    package.RegisterAssemblyLocation(assemblyName, path);
                }
            });

            return package;
        }
Пример #6
0
        /// <summary>
        ///     Deletes all files from a package
        /// </summary>
        /// <param name="installed">Insyalled package</param>
        /// <param name="repositories">Repositories where to find the package</param>
        private void DeleteFiles(PackageInfo installed, ICollection<string> repositories)
        {
            Logger.Log("Deleting installed files... ");

            var factory = new PackageRepositoryFactory();

            IPackage package;

            var globalRepo = new AggregateRepository(factory, repositories, true);

            package = globalRepo.FindPackage(installed.Name, SemanticVersion.Parse(installed.Version), true, true);

            if (package == null)
            {
                throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", installed.Name, installed.Version));
            }

            var fylesystem = new PhysicalFileSystem(installed.InstallationDirectory);

            fylesystem.DeleteFiles(package.GetFiles(), installed.InstallationDirectory);

            File.Delete(Path.Combine(installed.InstallationDirectory, installed.Name + "." + installed.Version + ".nupkg"));

            foreach (var config in Directory.GetFiles(installed.InstallationDirectory, "*.config"))
            {
                File.Delete(config);
            }

            Logger.Log("Installed files deleted");
        }
		/// <summary>
		/// 创建 <see cref="PackageDownloadProgressChangedEventArgs" />  的新实例(PackageDownloadProgressChangedEventArgs)
		/// </summary>
		public PackageDownloadProgressChangedEventArgs(PackageInfo package, long totalBytesToReceive, long bytesReceived, int progressPercentage)
			: base(progressPercentage, package)
		{
			Package = package;
			TotalBytesToReceive = totalBytesToReceive;
			BytesReceived = bytesReceived;
		}
Пример #8
0
 internal Application(PackageInfo pinfo)
 {
     name = pinfo.Name;
     description = pinfo.Description;
     startupPath = pinfo.GetData ("MonoAddinsRoot");
     registryPath = pinfo.GetData ("MonoAddinsRegistry");
     testCommand = pinfo.GetData ("MonoAddinsTestCommand");
 }
Пример #9
0
        static void ProcessPackage(PackageInfo package) {
            // Make sure all its dependencies are processed first
            foreach (var dependency in package.Dependencies) {
                EnsurePackageProcessed(dependency.FullName.ToString());
            }

            Console.WriteLine("Creating package {0}", package.FullName);
            CreateAssembly(package);
            CreatePackage(package);
        }
Пример #10
0
        /// <summary>
        ///     Removes an installed package from the system
        /// </summary>
        /// <param name="info"></param>
        public void Remove(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters, string optionalScript)
        {
            Logger.Log(string.Format("Uninstalling application {0} version {1}", info.Name, info.Version));

            ExecuteRemoveScript(info,parameters, optionalScript);

            DeleteFiles(info,repositories);

            Logger.Log(string.Format("Uninstalled application {0} version {1}", info.Name, info.Version));
        }
Пример #11
0
 public void Process(string filePath, PackageInfo.NamedInstance inst)
 {
     var doc = XDocument.Load(filePath);
     inst.Metadata = new PackageInfo.MetaData();
     var pathToInstall = doc.Root.Element("PathToInstall");
     if (pathToInstall != null)
     {
         inst.Metadata.FolderToInstall = pathToInstall.Value;
     }
 }
Пример #12
0
        /// <summary>
        ///     Installs the specified package into the specified directory
        /// </summary>
        /// <param name="info"></param>
        public void Install(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters)
        {
            Logger.Log(string.Format("Installing application {0} version {1}", info.Name, info.Version));

            DownloadPackage(info, repositories);

            ApplyTransformations(info, null, null);

            ExecuteInstallScript(info, parameters, null);

            Logger.Log(string.Format("Installed application {0} version {1}", info.Name, info.Version));
        }
Пример #13
0
        /// <summary>
        ///     Installs the package
        /// </summary>
        /// <param name="info">Package informations</param>
        /// <param name="repositories">Repositories to use</param>
        /// <param name="parameters">parameters to pass to the script</param>
        /// <param name="installScript">Installation script to execute</param>
        /// <param name="configFile">Name of the configuration file</param>
        /// <param name="configTrasform">Configuration transform to apply</param>
        public void Install(PackageInfo info, ICollection<string> repositories, Dictionary<string, string> parameters, string installScript, string configFile, string configTrasform)
        {
            Logger.Log(String.Format("Starting installation of {0} version {1} ... ", info.Name, info.Version));

            DownloadPackage(info, repositories);

            ApplyTransformations(info, configFile, configTrasform);

            ExecuteInstallScript(info, parameters, installScript);

            Logger.Log(String.Format("{0} version {1} Installed successfully ", info.Name, info.Version));
        }
  /// <summary>
  /// Writes manifest.
  /// </summary>
 /// <param name="path">path</param>
 /// <param name="filename">filename</param>
 /// <param name="selectedResxFiles">List of object of FileDetails class. </param>
 /// <param name="package">Objects of PackageInfo class.</param>
 public static void WriteManifest(string path,string filename,List<FileDetails> selectedResxFiles,PackageInfo package)
 {
     XmlWriter writer = XmlWriter.Create(path + @"/" + filename + ".sfe",XMLUtils.GetXmlWriterSettings());
     // Write first element
     writer.WriteStartElement("sageframe");
     writer.WriteAttributeString("type", "Package");
     writer.WriteAttributeString("version", "1.0.0.1");
     writer.WriteStartElement("packages");
     WritePackageDetails(writer,selectedResxFiles,package);
     // close writer
     writer.Close();
    
 }
Пример #15
0
        static PackageInfo ConvertToPublic(PackageInfoInternal info)
        {
            if (info == null)
            {
                return null;
            }

            var newInfo = new PackageInfo();

            newInfo.Name = info.Name;
            newInfo.Path = info.Path;
            newInfo.InstallInfo = ConvertToPublic(info.InstallInfo);

            return newInfo;
        }
        public AssemblyPackageInfo(Assembly assembly)
        {
            _manifest = new AssemblyPackageManifestFactory().Extract(assembly);
            _inner = new Lazy<PackageInfo>(() =>
            {
                var inner = new PackageInfo(_manifest);

                var exploder = BottleExploder.GetPackageExploder(new FileSystem());
                exploder.ExplodeAssembly(PackageRegistry.GetApplicationDirectory(), assembly, inner);

                return inner;
            });

            _assembly = assembly;
        }
            internal Badging(FileInfo source, string dump)
            {
                this.source = source;

                this.package = new PackageInfo();
                this.application = new ApplicationInfo();
                this.activity = new LaunchableActivity();

                this.sdkVersion = "";
                this.targetSdkVersion = "";

                this.usesPermission = new List<string>();
                this.densities = new List<int>();

                ProcessDump(dump);
            }
Пример #18
0
        /// <summary>
        ///     Excutes the uninstall script
        /// </summary>
        /// <param name="installed">Installed package</param>
        /// <param name="parameters">Parameters to pass to the script</param>
        /// <param name="optionalScript">optional additiona script to execute</param>
        private void ExecuteRemoveScript(PackageInfo installed, Dictionary<string, string> parameters, string optionalScript)
        {
            if (optionalScript != null && optionalScript.Trim().Length > 0)
            {
                Logger.Log("Executing uninstallation script specified as parameter...");
                PowershellHelpers.ExecuteScript(installed.InstallationDirectory, optionalScript, Logger, parameters);
                return;
            }

            if (File.Exists(Path.Combine(installed.InstallationDirectory, "Uninstall.ps1")))
            {
                Logger.Log("Executing uninstall script contained in package ... ");

                PowershellHelpers.Execute(installed.InstallationDirectory, "Uninstall.ps1", installed.Configuration, Logger, parameters);
            }
        }
Пример #19
0
        private IPackageInfo convertToPackage(string directory)
        {
            var folder = _fileSystem.GetFullPath(directory);

            var manifest = _fileSystem.LoadFromFile<HostManifest>(folder, HostManifest.CONTROL, HostManifest.FILE);

            var package = new PackageInfo(manifest.Name)
            {
                Description = "{0} ({1})".ToFormat(manifest.Name, folder)
            };

            package.RegisterFolder("data", FileSystem.Combine(folder, HostManifest.DATA));
            package.RegisterFolder("control", FileSystem.Combine(folder, HostManifest.CONTROL));

            return package;
        }
Пример #20
0
        public static async Task<NupkgEntry> OpenNupkgStreamAsync(
            HttpSource httpSource,
            PackageInfo package,
            TimeSpan cacheAgeLimit,
            Reports reports)
        {
            for (int retry = 0; retry != 3; ++retry)
            {
                try
                {
                    using (var data = await httpSource.GetAsync(
                        package.ContentUri,
                        cacheKey: $"nupkg_{package.Id}.{package.Version}",
                        cacheAgeLimit: retry == 0 ? cacheAgeLimit : TimeSpan.Zero,
                        ensureValidContents: stream => EnsureValidPackageContents(stream, package)))
                    {
                        return new NupkgEntry
                        {
                            TempFileName = data.CacheFileName
                        };
                    }
                }
                catch (Exception ex)
                {
                    var isFinalAttempt = (retry == 2);
                    var message = ex.Message;
                    if (ex is TaskCanceledException)
                    {
                        message = ErrorMessageUtils.GetFriendlyTimeoutErrorMessage(ex as TaskCanceledException, isFinalAttempt, ignoreFailure: false);
                    }

                    if (isFinalAttempt)
                    {
                        reports.Error.WriteLine(
                            $"Error: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine}  {message}".Red().Bold());
                        throw;
                    }
                    else
                    {
                        reports.Information.WriteLine(
                            $"Warning: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine}  {message}".Yellow().Bold());
                    }
                }
            }
            return null;
        }
    public void Execute(IPackage package, string packagePath)
    {
      try
      {
        var packageInfo = new PackageInfo
        {
          Package = package, 
          PackagePath = packagePath
        };

        Container.RegisterInstance<PackageInfo>(packageInfo, new ContainerControlledLifetimeManager());
        MainViewModel.ShowDialog();
      }
      catch (Exception exception)
      {
        MessageBox.Show(exception.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
      }
    }
Пример #22
0
        public static IEnumerable<ContentOnlyPackageInfo> FromAssemblies(string applicationDirectory)
        {
            var exploder = BottleExploder.GetPackageExploder(new FileSystem());
            var assemblies = FubuModuleAttributePackageLoader.FindAssemblies(new string[] {applicationDirectory.AppendPath("bin")});

            var list = new List<ContentOnlyPackageInfo>();

            foreach (var assembly in assemblies)
            {
                var package = new PackageInfo(new PackageManifest());
                exploder.ExplodeAssembly(applicationDirectory, assembly, package);

                package.ForFolder(BottleFiles.WebContentFolder, dir => {
                    list.Add(new ContentOnlyPackageInfo(dir, assembly.GetName().Name));
                });
            }

            return list;
        }
        public IPackageInfo LoadFromFolder(string packageDirectory)
        {
            packageDirectory = packageDirectory.ToFullPath();

            var manifest = _fileSystem.LoadFromFile<PackageManifest>(packageDirectory, PackageManifest.FILE);

            var package = new PackageInfo(manifest){
                Description = "{0} ({1})".ToFormat(manifest.Name, packageDirectory),
                Dependencies = manifest.Dependencies
            };

            // Right here, this needs to be different
            registerFolders(packageDirectory, package);

            var binPath = determineBinPath(packageDirectory);

            readAssemblyPaths(manifest, package, binPath);

            return package;
        }
			/// <summary>
			/// Creates <see cref="BandwidthOverusageRow"/> using <see cref="PackageInfo"/> as a data source.
			/// </summary>
			/// <param name="report">Current <see cref="OverusageReport"/> dataset.</param>
			/// <param name="packageInfo"><see cref="PackageInfo"/> instance.</param>
			/// <returns><see cref="BandwidthOverusageRow"/> instance.</returns>
			/// <exception cref="ArgumentNullException">When <paramref name="report"/> or either <paramref name="packageInfo"/> is <code>null</code>.</exception>
			public static BandwidthOverusageRow CreateFromPackageInfo(OverusageReport report, PackageInfo packageInfo)
			{
				if (report == null)
				{
					throw new ArgumentNullException("report");
				}

				if (packageInfo == null)
				{
					throw new ArgumentNullException("packageInfo");
				}

				BandwidthOverusageRow row = report.BandwidthOverusage.NewBandwidthOverusageRow();

				row.HostingSpaceId = packageInfo.PackageId;
				row.Allocated = packageInfo.BandWidthQuota;
				row.Used = packageInfo.BandWidth;
				row.Usage = (row.Used - row.Allocated);

				return row;
			}
Пример #25
0
 public static async Task<NupkgEntry> OpenNupkgStreamAsync(
     HttpSource httpSource,
     PackageInfo package,
     TimeSpan cacheAgeLimit,
     Reports reports)
 {
     for (int retry = 0; retry != 3; ++retry)
     {
         try
         {
             using (var data = await httpSource.GetAsync(
                 package.ContentUri,
                 cacheKey: $"nupkg_{package.Id}.{package.Version}",
                 cacheAgeLimit: retry == 0 ? cacheAgeLimit : TimeSpan.Zero,
                 ensureValidContents: stream => EnsureValidPackageContents(stream, package)))
             {
                 return new NupkgEntry
                 {
                     TempFileName = data.CacheFileName
                 };
             }
         }
         catch (Exception ex)
         {
             if (retry == 2)
             {
                 reports.Error.WriteLine(
                     $"Error: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine}  {ex.Message}".Red().Bold());
                 throw;
             }
             else
             {
                 reports.Information.WriteLine(
                     $"Warning: DownloadPackageAsync: {package.ContentUri}{Environment.NewLine}  {ex.Message}".Yellow().Bold());
             }
         }
     }
     return null;
 }
Пример #26
0
    private static long CreateExecution(PackageInfo packageInfo,
        bool use32RuntimeOn64, EnvironmentReference reference,
        int commandTimeout, SqlConnection connection)
    {
        long executionId = 0;
        string storedProcName = string.Format("{0}.{1}",
            packageInfo.Parent.Parent.Parent.Name, CREATE_EXECUTION);

        using (var command = new SqlCommand(storedProcName, connection))
        {
            command.CommandType = CommandType.StoredProcedure;
            command.CommandTimeout = commandTimeout;

            command.Parameters.Add(FOLDER_NAME, SqlDbType.NVarChar, 128);
            command.Parameters.Add(PROJECT_NAME, SqlDbType.NVarChar, 128);
            command.Parameters.Add(PACKAGE_NAME, SqlDbType.NVarChar, 260);
            command.Parameters.Add(REFERENCE_ID, SqlDbType.BigInt);
            command.Parameters.Add(USE32BITRUNTIME, SqlDbType.Bit);
            command.Parameters.Add(EXECUTION_ID, SqlDbType.Int);
            command.Parameters[EXECUTION_ID].Direction = ParameterDirection.Output;

            command.Parameters[FOLDER_NAME].Value = packageInfo.Parent.Parent.Name;
            command.Parameters[PROJECT_NAME].Value = packageInfo.Parent.Name;
            command.Parameters[PACKAGE_NAME].Value = packageInfo.Name;

            if (reference != null)
            {
                command.Parameters[REFERENCE_ID].Value = reference.ReferenceId;
            }

            command.Parameters[USE32BITRUNTIME].Value = use32RuntimeOn64;

            command.ExecuteNonQuery();
            executionId = long.Parse(command.Parameters[EXECUTION_ID].Value.ToString());
        }

        return executionId;
    }
Пример #27
0
        internal static async Task<Stream> OpenNuspecStreamFromNupkgAsync(PackageInfo package,
            Func<PackageInfo, Task<Stream>> openNupkgStreamAsync,
            IReport report)
        {
            using (var nupkgStream = await openNupkgStreamAsync(package))
            {
                try {
                    using (var archive = new ZipArchive(nupkgStream, ZipArchiveMode.Read, leaveOpen: true))
                    {
                        var entry = archive.GetEntryOrdinalIgnoreCase(package.Id + ".nuspec");
                        using (var entryStream = entry.Open())
                        {
                            var nuspecStream = new MemoryStream((int)entry.Length);
#if DNXCORE50
                            // System.IO.Compression.DeflateStream throws exception when multiple
                            // async readers/writers are working on a single instance of it
                            entryStream.CopyTo(nuspecStream);
#else
                            await entryStream.CopyToAsync(nuspecStream);
#endif
                            nuspecStream.Seek(0, SeekOrigin.Begin);
                            return nuspecStream;
                        }
                    }
                }
                catch (InvalidDataException)
                {
                    var fileStream = nupkgStream as FileStream;
                    if (fileStream != null)
                    {
                        report.WriteLine("The ZIP archive {0} is corrupt",
                            fileStream.Name.Yellow().Bold());
                    }
                    throw;
                }
            }
        }
Пример #28
0
        private void Subscribe(string masterfile, string masterDic)
        {
            string       line = "";
            FileStream   fs   = new FileStream(masterfile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
            StreamReader sr   = new StreamReader(fs);

            while (!sr.EndOfStream)
            {
                line = sr.ReadLine();
                if (!line.StartsWith("#"))
                {
                    var strs = TypeConverterEx.Split <string>(line);
                    if (strs != null && strs.Length >= 3)
                    {
                        var pckinfo = new PackageInfo();
                        pckinfo.ModuleName    = strs[0].ToUpper();
                        pckinfo.FID           = int.Parse(strs[1]);
                        pckinfo.Format        = FileFormat.Text;
                        pckinfo.FileName      = strs[2].ToLower();
                        pckinfo.FileExtension = Path.GetExtension(pckinfo.FileName);
                        pckinfo.Name          = Path.GetFileName(pckinfo.FileName);
                        pckinfo.WorkDirectory = masterDic;
                        if (strs.Length == 4)
                        {
                            pckinfo.IOState = EnumHelper.FromString <IOState>(strs[3].ToUpper());
                        }
                        else
                        {
                            pckinfo.IOState = IOState.OLD;
                        }

                        var module_name = pckinfo.ModuleName.ToUpper();
                        if (module_name.Contains("DATA"))
                        {
                            pckinfo.Format = FileFormat.Text;
                            if (module_name.Contains("BINARY"))
                            {
                                pckinfo.Format = FileFormat.Binary;
                            }
                            pckinfo.ModuleName = "DATA";
                        }
                        _MFNameManager.AddInSilence(pckinfo);
                        var pck = Select(pckinfo.ModuleName);
                        if (pck != null)
                        {
                            pck.PackageInfo = pckinfo;
                            pck.FileName    = pckinfo.FileName;
                            pck.Clear();
                            pck.Initialize();
                            if (!Packages.Keys.Contains(pck.Name))
                            {
                                Packages.Add(pck.Name, pck);
                                pck.Owner = this;
                            }
                        }
                    }
                }
            }
            fs.Close();
            sr.Close();
        }
Пример #29
0
		/// <summary>
		/// 将指定包的文件添加到忽略列表
		/// </summary>
		/// <param name="pkg"></param>
		void AddPackageToPreserveList(PackageInfo pkg)
		{
			if (pkg == null || pkg.Files == null) return;

			var reserveDic = FileInstaller.PreservedFiles;
			foreach (var file in pkg.Files)
			{
				if (!reserveDic.ContainsKey(file))
				{
					Trace.TraceInformation("添加 {0} 到保持文件列表,因为下载过程中会跳过,所以不可以删除", file);
					reserveDic.Add(file, null);
				}
			}
		}
 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Constructs the LanguageComponentWriter
 /// </summary>
 /// <param name="languagePack">Language Package info.</param>
 /// <param name="basePath">Base Path.</param>
 /// <param name="files">A Dictionary of files</param>
 /// <param name="package">Package Info.</param>
 /// -----------------------------------------------------------------------------
 public LanguageComponentWriter(LanguagePackInfo languagePack, string basePath, Dictionary <string, InstallFile> files, PackageInfo package) : base(basePath, files, package)
 {
     _Language           = LocaleController.Instance.GetLocale(languagePack.LanguageID);
     _PackageType        = languagePack.PackageType;
     _DependentPackageID = languagePack.DependentPackageID;
 }
Пример #31
0
 public void StoreCustomData(Mono.PkgConfig.PcFile pcfile, PackageInfo pkg)
 {
 }
Пример #32
0
 public bool IsCustomDataComplete(string pcfile, PackageInfo pkg)
 {
     return true;
 }
Пример #33
0
 public SkinPackageWriter(PackageInfo package) : base(package)
 {
     _SkinPackage = SkinController.GetSkinByPackageID(package.PackageID);
     SetBasePath();
 }
 /// -----------------------------------------------------------------------------
 /// <summary>
 /// Constructs the LanguageComponentWriter
 /// </summary>
 /// <param name="language">Language Info.</param>
 /// <param name="basePath">Base Path.</param>
 /// <param name="files">A Dictionary of files</param>
 /// <param name="package">Package Info.</param>
 /// -----------------------------------------------------------------------------
 public LanguageComponentWriter(Locale language, string basePath, Dictionary <string, InstallFile> files, PackageInfo package) : base(basePath, files, package)
 {
     _Language    = language;
     _PackageType = LanguagePackType.Core;
 }