示例#1
0
        /// <summary>
        /// Package_Json转换为Table
        /// </summary>
        /// <param name="packageJsonnString"></param>
        public void Package_JsonToTable(string packageJsonnString)
        {
            if (string.IsNullOrWhiteSpace(packageJsonnString))
            {
                return;
            }
            List <Package> packageList = JsonConvert.DeserializeObject <List <Package> >(packageJsonnString);

            if (packageList == null || packageList.Count == 0)
            {
                return;
            }
            _packageTable.Clear();
            PackageConfig config = new PackageConfig();

            foreach (Package item in packageList)
            {
                DataRow row = _packageTable.NewRow();
                row[config.Oid]       = item.Oid;
                row[config.Name]      = item.Name;
                row[config.IsChecked] = item.IsChecked;
                row[config.Order]     = item.Order;
                row[config.Code]      = item.Code;
                _packageTable.Rows.Add(row);
            }
            bindGrid(dataGridView2, _packageTable, new int[] { 0 });
        }
示例#2
0
        public IEnumerable <PackageReference> GetPackageReferences()
        {
            PackageConfig packageConfig = new PackageConfig(ConfigFileName);

            packageConfig.Load();
            return(packageConfig.PackageReferences);
        }
示例#3
0
        /// <summary>
        /// Package_Table转换为JSON
        /// </summary>
        /// <returns></returns>
        public string Package_TableToJson()
        {
            string result = string.Empty;

            if (dataGridView2.DataSource == null)
            {
                return(result);
            }
            DataTable dt = (DataTable)dataGridView2.DataSource;

            if (dt == null || dt.Rows.Count <= 0)
            {
                return(result);
            }
            PackageConfig  config   = new PackageConfig();
            List <Package> packList = new List <Package>();

            foreach (DataRow row in dt.Rows)
            {
                Package package = new Package();
                package.Oid       = row[config.Oid] == DBNull.Value ? 0 : Convert.ToInt32(row[config.Oid]);
                package.Name      = row[config.Name] == DBNull.Value ? "" : (string)row[config.Name];
                package.IsChecked = row[config.IsChecked] == DBNull.Value ? false : Convert.ToBoolean(row[config.IsChecked]);
                package.Order     = row[config.Order] == DBNull.Value ? 0 : Convert.ToInt32(row[config.Order]);
                package.Code      = row[config.Code] == DBNull.Value ? "" : (string)row[config.Code];
                packList.Add(package);
            }
            result = JsonConvert.SerializeObject(packList);
            return(result);
        }
示例#4
0
        public GemServer(string profileName, ServerConfig serverConfig, PackageConfig packageConfig)
        {
            //validate server config
            Guard.That(serverConfig).IsNotNull();
            Guard.That(packageConfig).IsNotNull();

            GemNetwork.ActiveProfile = profileName;

            //setup authentication
            if (serverConfig.RequireAuthentication)
            {
                RequireAuthentication();
            }
            else
            {
                Profile(GemNetwork.ActiveProfile).OnIncomingConnection((srvr, netconnection, msg) =>
                {
                    netconnection.Approve();
                    GemNetworkDebugger.Append.Info(String.Format("Approved {0} {3} Sender: {1}{3} Message: {2}",
                                                                 netconnection, msg.Sender, msg.Message, Environment.NewLine));
                });
            }

            this.serverConfig  = serverConfig;
            this.PackageConfig = packageConfig;

            server = GemNetwork.Server;

            messageProcessor      = new ServerMessageProcessor(server);
            asyncMessageProcessor = new ParallelTaskStarter(TimeSpan.Zero);
        }
 public bool FromConfig(PackageConfig config)
 {
     if (config == null || string.IsNullOrEmpty(config.Name) || !string.IsNullOrEmpty(Key) && Key != config.Name)
     {
         return(false);
     }
     if (string.IsNullOrEmpty(Name))
     {
         Name = config.Name;
     }
     if (string.IsNullOrEmpty(Key))
     {
         Key = config.Name;
     }
     CurrentVersion = config.Version;
     if (NetworkVersions == null)
     {
         NetworkVersions = new Dictionary <PackageConfig.Platform, string>();
     }
     foreach (var platform in config.NetworkSdkVersions.Keys)
     {
         if (!NetworkVersions.ContainsKey(platform))
         {
             NetworkVersions[platform] = config.NetworkSdkVersions[platform];
         }
     }
     return(true);
 }
示例#6
0
        /// <summary>
        /// Connect to the server
        /// </summary>
        public void Connect(ConnectionConfig connectionDetails, PackageConfig packageConfig, ConnectionApprovalMessage approvalMessage)
        {
            this.connectionDetails = connectionDetails;
            this.PackageConfig     = packageConfig;

            var config = new NetPeerConfiguration(connectionDetails.ServerName);

            config.EnableMessageType(NetIncomingMessageType.Data);
            config.EnableMessageType(NetIncomingMessageType.WarningMessage);
            config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
            config.EnableMessageType(NetIncomingMessageType.ErrorMessage);
            config.EnableMessageType(NetIncomingMessageType.Error);
            config.EnableMessageType(NetIncomingMessageType.DebugMessage);
            config.EnableMessageType(NetIncomingMessageType.DiscoveryResponse);

            client = new NetClient(config);
            client.Start();

            //encrypt passwords ?
            //INetEncryption algo = new NetTripleDESEncryption(encryptionKey);
            //handshake.Encrypt(algo);

            //Create the approval message
            var handshake = CreateMessage();

            approvalMessage.Encode(handshake);

            client.Connect(connectionDetails.ServerIP, handshake);
        }
示例#7
0
        static void Main(string[] args)
        {
            try
            {
                MergeLog.Loginformation("Main - Start");

                //Create Mutex object & its related varibale to avoid running multiple instances
                const string appName = "SingleCSVInstanceApp";
                bool         createdNew;
                mutex = new Mutex(true, appName, out createdNew);
                MergeLog.Loginformation("Mutex thread created.");
                if (!createdNew)
                {
                    //Prompt the message to enduser and close the current instance
                    MessageBox.Show("Application is already running.");
                    MergeLog.Loginformation("Mutex thread identified already win form instance is running.");
                    return;
                }

                //Identify the Windows form exe is launched with/without parameters
                if (args.Length > 0)
                {
                    //Declare client object and which will create all required object at runtime
                    BusinessClient businessClient = new BusinessClient();

                    //Read the saved selection of CSV files and destination paths
                    MergeCSVData data = PackageConfig.ReadMergeCSVData();

                    //Validating saved tool configuration values
                    if (string.IsNullOrEmpty(data.CSVFilePath1.Trim()) || string.IsNullOrEmpty(data.CSVFilePath2.Trim()) ||
                        string.IsNullOrEmpty(data.HeaderExists.Trim()) || string.IsNullOrEmpty(data.JsonFilePath.Trim()))
                    {
                        //Prompt the validation message to enduser and close the current instance
                        MessageBox.Show("Invalid Configuration values. Please use UI execution.", "MergeCSVTool");
                        MergeLog.Loginformation("Invalid Configuration values.");
                        return;
                    }

                    // Call the merge method
                    businessClient.MergeCsvToJson(data);
                    MessageBox.Show("Given CSV files are merged successfully.", "MergeCSVTool");
                }
                else
                {
                    //Open Merge win form
                    Application.EnableVisualStyles();
                    Application.SetCompatibleTextRenderingDefault(false);
                    Application.Run(new MergeCSVToJson());
                }
                MergeLog.Loginformation("Main - End");
            }
            catch (Exception ex)
            {
                MergeLog.LogError(ex);
                MessageBox.Show(ex.Message, "MergeCSVTool");
            }
        }
 public Packager(AspNetCorePackager aspNetCorePackager, IHandleFiles fileHandler, PackageConfig packageConfig,
                 AppConfig baseConfig, ConsoleWriter log, Hack hack)
 {
     _aspNetCorePackager = aspNetCorePackager;
     _fileHandler        = fileHandler;
     _packageConfig      = packageConfig;
     _baseConfig         = baseConfig;
     _log  = log;
     _hack = hack;
 }
示例#9
0
        /// <summary>
        /// 初始化PackageConfig
        /// </summary>
        public void InitPackageTable()
        {
            PackageConfig package = new PackageConfig();

            _packageTable = new DataTable();
            _packageTable.Columns.Add(package.Oid, typeof(int));
            _packageTable.Columns.Add(package.Name, typeof(string));
            _packageTable.Columns.Add(package.IsChecked, typeof(bool));
            _packageTable.Columns.Add(package.Order, typeof(int));
            _packageTable.Columns.Add(package.Code, typeof(string));
            bindGrid(dataGridView2, _packageTable, new int[] { 0 });
        }
示例#10
0
        private void MergeCSVToJson_Load(object sender, EventArgs e)
        {
            openCSVFileDlg.Filter   = "CSV files (*.csv)|*.csv";
            openCSVFileDlg.FileName = "";

            MergeCSVData data = PackageConfig.ReadMergeCSVData();

            txtCSVFilePath1.Text   = data.CSVFilePath1;
            txtCSVFilePath2.Text   = data.CSVFilePath2;
            txtJsonFolderPath.Text = data.JsonFilePath;
            chkHeader.Checked      = (data.HeaderExists == string.Empty) ? false : Convert.ToBoolean(data.HeaderExists);
        }
示例#11
0
        public void ItHandlesASingleCertOnASingleEndpoint()
        {
            // g
            var packageConfig = new PackageConfig
            {
                Https = new List <HttpsConfig>
                {
                    new HttpsConfig
                    {
                        ApplicationTypeName = "MyApp",
                        CertThumbprint      = "MyCert",
                        ServiceManifestName = "MyService",
                        EndpointName        = "MyEndpoint"
                    }
                }
            };

            var appManifest = new ApplicationManifest
            {
                ServiceManifestImports = new List <ServiceManifestImport>
                {
                    new ServiceManifestImport
                    {
                        ServiceManifestRef = new ServiceManifestRef
                        {
                            ServiceManifestName = "MyService"
                        }
                    }
                }
            };

            var endpointHandler = new HandleEndpointCert();

            // w
            endpointHandler.SetEndpointCerts(packageConfig, appManifest, "MyApp");

            // t
            var endpointBindingPolicy = appManifest
                                        .ServiceManifestImports.First()
                                        .Policies
                                        .EndpointBindingPolicy.First();

            endpointBindingPolicy.EndpointRef.Should().Be("MyEndpoint");
            endpointBindingPolicy.CertificateRef.Should().Be("Certificate0");

            var endpointCertificate = appManifest.Certificates.EndpointCertificates.First();

            endpointCertificate.Name.Should().Be("Certificate0");
            endpointCertificate.X509FindValue.Should().Be("MyCert");
        }
示例#12
0
 private void CollectAndSaveConfigDetails()
 {
     try
     {
         mergeCSVData = new MergeCSVData();
         mergeCSVData.CSVFilePath1 = txtCSVFilePath1.Text;
         mergeCSVData.CSVFilePath2 = txtCSVFilePath2.Text;
         mergeCSVData.JsonFilePath = txtJsonFolderPath.Text;
         mergeCSVData.HeaderExists = chkHeader.Checked.ToString();
         PackageConfig.WriteMergeCSVData(mergeCSVData);
     }
     catch (Exception e)
     {
         MergeLog.LogError(e);
         throw e;
     }
 }
示例#13
0
        //自动打AB包
        public static void BuildAB(PackageConfig packageConfig)
        {
            PlatformType platformType = PlatformType.PC;
            bool         isBuildExe   = false;
            bool         isContainAB  = true;

            switch (packageConfig.platformType)
            {
            case PackageConfig.PlatformType.Andriod:
                platformType = PlatformType.Android;
                break;

            case PackageConfig.PlatformType.IOS:
                platformType = PlatformType.IOS;
                break;
            }
            BuildHelper.Build(platformType, packageConfig.buildAssetBundleOptions, packageConfig.buildOptions, isBuildExe, isContainAB);
        }
示例#14
0
文件: GemClient.cs 项目: gmich/Gem
        /// <summary>
        /// Initializes a new instance of GemClient.
        /// </summary>
        /// <param name="profile">The profile the client's configuration is set</param>
        /// <param name="connectionConfig">The configuration for the connection</param>
        /// <param name="packageConfig">The configuration for the outgoing messages</param>
        public GemClient(string profile, ConnectionConfig connectionConfig, PackageConfig packageConfig)
        {
            Guard.That(connectionConfig).IsNotNull();
            Guard.That(packageConfig).IsNotNull();

            PackageConfig            = packageConfig;
            connectionDetails        = connectionConfig;
            GemNetwork.ActiveProfile = profile;

            //TODO: check if the client is already connected
            this.client = GemNetwork.Client;
            this.client.PackageConfig = PackageConfig;

            RegisterServerNotificationPackages(profile);

            messageProcessor      = new ClientMessageProcessor(client);
            asyncMessageProcessor = new ParallelTaskStarter(TimeSpan.Zero);
        }
示例#15
0
 public ServiceHashCalculator(
     ConsoleWriter log,
     PackageConfig packageConfig,
     IHandleFiles fileHandler,
     ManifestHandler manifestHandler,
     ManifestLoader <ApplicationManifest> appManifestLoader,
     ManifestLoader <ServiceManifest> serviceManifestLoader,
     HandleEnciphermentCert handleEnciphermentCert,
     HandleEndpointCert handleEndpointCert)
 {
     _log                    = log;
     _packageConfig          = packageConfig;
     _fileHandler            = fileHandler;
     _manifestHandler        = manifestHandler;
     _appManifestLoader      = appManifestLoader;
     _serviceManifestLoader  = serviceManifestLoader;
     _handleEnciphermentCert = handleEnciphermentCert;
     _handleEndpointCert     = handleEndpointCert;
 }
 public ManifestHandler(
     AppConfig baseConfig,
     PackageConfig packageConfig,
     ManifestLoader <ApplicationManifest> appManifestLoader,
     ManifestLoader <ServiceManifest> serviceManifestLoader,
     HandleEnciphermentCert handleEnciphermentCert,
     HandleEndpointCert handleEndpointCert,
     ApplicationManifestHandler appManifestHandler,
     ServiceManifestHandler serviceManifestHandler)
 {
     _baseConfig             = baseConfig;
     _packageConfig          = packageConfig;
     _appManifestLoader      = appManifestLoader;
     _serviceManifestLoader  = serviceManifestLoader;
     _handleEnciphermentCert = handleEnciphermentCert;
     _handleEndpointCert     = handleEndpointCert;
     _appManifestHandler     = appManifestHandler;
     _serviceManifestHandler = serviceManifestHandler;
 }
        public void Test()
        {
            // g
            var packageConfig = new PackageConfig
            {
                Encipherment = new List <Encipherment>
                {
                    new Encipherment
                    {
                        ApplicationTypeName = "MyApp",
                        CertName            = "MyCert",
                        CertThumbprint      = "MyThumb",
                        Name = "MyCustomName"
                    }
                }
            };

            var appManifest         = new ApplicationManifest();
            var enciphermentHandler = new HandleEnciphermentCert();

            // w
            enciphermentHandler.SetEnciphermentCerts(packageConfig, appManifest, "MyApp");

            // t
            var securityAccessPolicy = appManifest.Policies.SecurityAccessPolicies.SecurityAccessPolicy.First();

            securityAccessPolicy.ResourceRef.Should().Be("MyCert");
            securityAccessPolicy.GrantRights.Should().Be("Read");
            securityAccessPolicy.PrincipalRef.Should().Be("MyCustomName");
            securityAccessPolicy.ResourceType.Should().Be("Certificate");

            var user = appManifest.Principals.Users.User.First();

            user.AccountType.Should().Be("NetworkService");
            user.Name.Should().Be("MyCustomName");

            var certificate = appManifest.Certificates.SecretsCertificate.First();

            certificate.Name.Should().Be("MyCert");
            certificate.X509FindType.Should().Be("FindByThumbprint");
            certificate.X509FindValue.Should().Be("MyThumb");
        }
示例#18
0
    void LoadPackageConfig()
    {
        string path = Application.dataPath + "/" + PackagePlatform.packageConfigPath;

        if (string.IsNullOrEmpty(path))
        {
            Debug.Log("打包配置文件未找到");
            return;
        }

        string        str = File.ReadAllText(path);
        PackageConfig pc  = JsonUtility.FromJson <PackageConfig>(str);

        mainVersion      = pc.mainVersion;
        minorVersion     = pc.minorVersion;
        rawScenePath     = pc.rawScenePath;
        rawCodePath      = pc.rawCodePath;
        rawConfigPath    = pc.rawConfigPath;
        rawDataTablePath = pc.rawDataTablePath;
    }
示例#19
0
        public bool Connect(ServerConfig serverConfig, PackageConfig packageConfig)
        {
            this.PackageConfig = packageConfig;
            this.serverConfig  = serverConfig;
            if (netServer != null)
            {
                GemNetworkDebugger.Append.Error("Server already started");
                return(false);
            }
            var config = new NetPeerConfiguration(serverConfig.Name)
            {
                Port = serverConfig.Port,
                MaximumConnections       = serverConfig.MaxConnections,
                EnableUPnP               = serverConfig.EnableUPnP,
                ConnectionTimeout        = serverConfig.ConnectionTimeout,
                MaximumHandshakeAttempts = serverConfig.MaxConnectionAttempts
            };

            config.EnableMessageType(NetIncomingMessageType.Data);
            config.EnableMessageType(NetIncomingMessageType.WarningMessage);
            config.EnableMessageType(NetIncomingMessageType.VerboseDebugMessage);
            config.EnableMessageType(NetIncomingMessageType.ErrorMessage);
            config.EnableMessageType(NetIncomingMessageType.Error);
            config.EnableMessageType(NetIncomingMessageType.DebugMessage);
            config.EnableMessageType(NetIncomingMessageType.ConnectionApproval);
            config.EnableMessageType(NetIncomingMessageType.DiscoveryRequest);

            this.netServer = new NetServer(config);

            try
            {
                this.netServer.Start();
                GemNetworkDebugger.Append.Info("Server started");
                return(true);
            }
            catch (Exception ex)
            {
                GemNetworkDebugger.Append.Error("Failed to start the server. Reason {0}", ex.Message);
                return(false);
            }
        }
    static List <AssetBundleBuild> GeneratorAssetbundleEntry()
    {
        string path = Application.dataPath + "/" + PackagePlatform.packageConfigPath;

        if (string.IsNullOrEmpty(path))
        {
            return(null);
        }

        string str = File.ReadAllText(path);

        Dict <string, ABEntry> abEntries = new Dict <string, ABEntry>();

        PackageConfig apc = JsonUtility.FromJson <PackageConfig>(str);

        AssetBundlePackageInfo[] bundlesInfo = apc.bundles;

        for (int i = 0; i < bundlesInfo.Length; i++)
        {
            ABEntry entry = new ABEntry();
            entry.bundleInfo = bundlesInfo[i];

            if (!abEntries.ContainsKey(entry.bundleInfo.name))
            {
                abEntries.Add(entry.bundleInfo.name, entry);
            }
        }

        List <AssetBundleBuild> abbList = new List <AssetBundleBuild>();

        foreach (var rEntryItem in abEntries)
        {
            abbList.AddRange(rEntryItem.Value.ToABBuild());
        }
        return(abbList);
    }
示例#21
0
 public NonSecureClusterConnection(PackageConfig packageConfig, ConsoleWriter log) : base(log)
 {
     _packageConfig = packageConfig;
 }
 public SfProjectHandler(ManifestParser appManifestHandler, AppConfig baseConfig, PackageConfig packageConfig)
 {
     _appManifestHandler = appManifestHandler;
     _baseConfig         = baseConfig;
     _packageConfig      = packageConfig;
 }
示例#23
0
 void Awake()
 {
     packageConfig = (PackageConfig)target;
 }
 public PackageConfigFileFinder(PackageConfig packageConfig)
 {
     _packageConfig = packageConfig;
 }
示例#25
0
 public static void RegisterPackageConfig(Container container, PackageConfig config)
 {
     container.RegisterSingleton(config);
 }
示例#26
0
 public SecureClusterConnection(IHandleFiles blobService, PackageConfig packageConfig, ConsoleWriter log) : base(log)
 {
     _blobService   = blobService;
     _packageConfig = packageConfig;
 }
示例#27
0
        private bool HasVersion()
        {
            Debug("CheckNewVersion ...");

            var url = ProcessConfig.SourceUrl;
            if (url[url.Length - 1] != '/') url += "/";

            string packageXml = HttpDownloader.Get(url + PackageDescFileName);
            _lastConfig = packageXml.ToXmlReader().Deserialize<PackageConfig>();

            if (_fileManager.InstalledVersion != _lastConfig.Version)
            {
                Debug("CheckNewVersion end, found new version = " + _lastConfig.Version);
                _fileManager.SavePackageDesc(packageXml);

                return true;
            }
            else
                Debug("CheckNewVersion end, not found new version");

            return false;
        }
示例#28
0
        public void SetEndpointCerts(
            PackageConfig packageConfig,
            ApplicationManifest appManifest,
            string appTypeName)
        {
            var httpsCerts = packageConfig
                             .Https
                             .Where(x => x.ApplicationTypeName.Equals(appTypeName))
                             .OrderBy(x => x.CertThumbprint)
                             .ToList();

            if (!httpsCerts.Any())
            {
                return;
            }

            if (appManifest.Certificates == null)
            {
                appManifest.Certificates = new Certificates();
            }
            if (appManifest.Certificates.EndpointCertificates == null)
            {
                appManifest.Certificates.EndpointCertificates = new List <EndpointCertificate>();
            }

            var certList = appManifest.Certificates.EndpointCertificates;

            var distinctThumbprints = httpsCerts
                                      .GroupBy(x => x.CertThumbprint);

            distinctThumbprints.ForEach((certGroup, i) =>
            {
                var certificate = certGroup.First();
                var certName    = $"Certificate{i}";

                certList.Add(new EndpointCertificate
                {
                    Name          = certName,
                    X509FindValue = certificate.CertThumbprint
                });

                certGroup.ForEach(cert =>
                {
                    var importNodeList = appManifest
                                         .ServiceManifestImports
                                         .Where(x => x.ServiceManifestRef.ServiceManifestName.Equals(cert.ServiceManifestName))
                                         .ToList();

                    if (!importNodeList.Any())
                    {
                        return;
                    }

                    var importNode = importNodeList.First();

                    if (importNode.Policies == null)
                    {
                        importNode.Policies = new Policies();
                    }
                    if (importNode.Policies.EndpointBindingPolicy == null)
                    {
                        importNode.Policies.EndpointBindingPolicy = new List <EndpointBindingPolicy>();
                    }

                    var binding = new EndpointBindingPolicy
                    {
                        CertificateRef = certName,
                        EndpointRef    = cert.EndpointName
                    };

                    importNode.Policies.EndpointBindingPolicy.Add(binding);
                });
            });

            appManifest.Certificates.EndpointCertificates = certList;
        }
示例#29
0
        static void Main(string[] args)
        {
            Logger.Debug("Updater proc ...");

            try
            {
                if (args == null && args.Length != 1)
                    throw new ArgumentException("Входная папка не задана");

                _mgr = new FileManager(args[0]);
                _package = _mgr.LoadPackageDesc().ToXmlReader().Deserialize<PackageConfig>();

                if (_mgr.InstalledVersion == _mgr.DownloadedVersion)
                {
                    Logger.Debug("Service already updated!");
                    return;
                }

                StartAndWaitAction("OnBeforeUpdateAction", _package.OnBeforeUpdateAction);

                TryUpdate();

                StartAndWaitAction("OnSuccessUpdateAction", _package.OnSuccessUpdateAction);
            }
            catch (Exception ex)
            {
                Logger.Error("Updater proc: " + ex);
                StartAndWaitAction("OnErrorUpdateAction", _package.OnErrorUpdateAction);
            }

            Logger.Debug("Updater proc: end");
        }
        public void SetEnciphermentCerts(
            PackageConfig packageConfig,
            ApplicationManifest appManifest,
            string appTypeName)
        {
            var encipherments = packageConfig
                                .Encipherment
                                .Where(x => EncipherNameEqualsAppName(x, appTypeName))
                                .ToList();

            if (!encipherments.Any())
            {
                return;
            }

            if (appManifest.Principals == null)
            {
                appManifest.Principals = new Principals();
            }
            if (appManifest.Principals.Users == null)
            {
                appManifest.Principals.Users = new Users();
            }
            if (appManifest.Principals.Users.User == null)
            {
                appManifest.Principals.Users.User = new List <User>();
            }
            if (appManifest.Policies == null)
            {
                appManifest.Policies = new Policies();
            }
            if (appManifest.Policies.SecurityAccessPolicies == null)
            {
                appManifest.Policies.SecurityAccessPolicies = new SecurityAccessPolicies();
            }
            if (appManifest.Policies.SecurityAccessPolicies.SecurityAccessPolicy == null)
            {
                appManifest.Policies.SecurityAccessPolicies.SecurityAccessPolicy = new List <SecurityAccessPolicy>();
            }
            if (appManifest.Certificates == null)
            {
                appManifest.Certificates = new Certificates();
            }
            if (appManifest.Certificates.SecretsCertificate == null)
            {
                appManifest.Certificates.SecretsCertificate = new List <SecretsCertificate>();
            }

            foreach (var encipherment in encipherments)
            {
                var user = new User
                {
                    Name        = encipherment.Name,
                    AccountType = "NetworkService"
                };

                var policy = new SecurityAccessPolicy
                {
                    GrantRights  = "Read",
                    PrincipalRef = encipherment.Name,
                    ResourceRef  = encipherment.CertName,
                    ResourceType = "Certificate"
                };

                var secretCert = new SecretsCertificate
                {
                    Name          = encipherment.CertName,
                    X509FindValue = encipherment.CertThumbprint,
                    X509FindType  = "FindByThumbprint"
                };

                appManifest.Principals.Users.User.Add(user);
                appManifest.Policies.SecurityAccessPolicies.SecurityAccessPolicy.Add(policy);
                appManifest.Certificates.SecretsCertificate.Add(secretCert);
            }
        }