コード例 #1
0
            public static iLogicForm Get(UiStorage storage, string formName, InventorParameters allowedParameters)
            {
                FormSpecification formSpec = storage.LoadFormSpecification(formName);
                var extractor = new FormExtractor(formSpec, allowedParameters);

                return(extractor.Run());
            }
コード例 #2
0
        public async Task <string> Refresh()
        {
            string returnValue            = "";
            List <ObjectDetails> ossFiles = await _forgeOSS.GetBucketObjectsAsync(_bucket.BucketKey, "cache/");

            foreach (ObjectDetails file in ossFiles)
            {
                string[] fileParts = file.ObjectKey.Split('/');
                string   project   = fileParts[1];
                string   hash      = fileParts[2];
                string   fileName  = fileParts[3];
                if (fileName == "parameters.json")
                {
                    returnValue += "Project " + project + " (" + hash + ") is being updated\n";
                    string paramsFile = Path.Combine(_localCache.LocalRootName, "params.json");
                    await _bucket.DownloadFileAsync(file.ObjectKey, paramsFile);

                    InventorParameters inventorParameters = Json.DeserializeFile <InventorParameters>(paramsFile);
                    try
                    {
                        await _projectWork.DoSmartUpdateAsync(inventorParameters, project, true);

                        returnValue += "Project " + project + " (" + hash + ") was updated\n";
                    } catch (Exception e)
                    {
                        returnValue += "Project " + project + " (" + hash + ") update failed\nException: " + e.Message + "\n";
                    }
                }
            }

            return(returnValue);
        }
コード例 #3
0
 public void SetJob(JobType jobTypeParam, OssBucket bucketParam, ProjectInfo projectInfoParam, string projectUrlParam, InventorParameters parametersParam = null)
 {
     jobType     = jobTypeParam;
     bucket      = bucketParam;
     projectInfo = projectInfoParam;
     projectUrl  = projectUrlParam;
     parameters  = parametersParam;
 }
コード例 #4
0
        public async Task CreateUpdateJob(string projectId, InventorParameters parameters, string token)
        {
            _logger.LogInformation($"invoked CreateJob, connectionId : {Context.ConnectionId}");

            _userResolver.Token = token;

            // create job and run it
            var job = new UpdateModelJobItem(_logger, projectId, parameters, _projectWork);

            await RunJobAsync(job);
        }
コード例 #5
0
        /// <summary>
        /// Generate hash for stringified key/value representation of InventorParameters object.
        /// </summary>
        /// <remarks>It generates hash for the string, parameters are sorted by key, key-value;key-value;....</remarks>
        /// <returns>Hash string.</returns>
        public static string GenerateParametersHashString(InventorParameters parameters)
        {
            // make key-value string ONLY to generate hash
            string keyValuesStr = "";

            foreach (KeyValuePair <string, InventorParameter> param in parameters.OrderBy(kvp => kvp.Key))
            {
                keyValuesStr += $"{param.Key}-{param.Value.Value};";
            }

            return(GenerateHashString(keyValuesStr));
        }
コード例 #6
0
        public InventorParameters ExtractParameters(Document doc, dynamic userParameters)
        {
            /* The resulting json will be like this:
             * {
             *  "length" : {
             *    "unit": "in",
             *    "value": "10 in",
             *    "values": ["5 in", "10 in", "15 in"]
             *  },
             *  "width": {
             *    "unit": "in",
             *    "value": "20 in",
             *  }
             * }
             */
            try
            {
                var parameters = new InventorParameters();
                foreach (dynamic param in userParameters)
                {
                    var nominalValue = param.Expression;
                    try
                    {
                        var unitType = doc.UnitsOfMeasure.GetTypeFromString(param.Units);
                        var value    = doc.UnitsOfMeasure.GetValueFromExpression(param.Expression, unitType);
                        nominalValue = doc.UnitsOfMeasure.GetPreciseStringFromValue(value, unitType);
                    }
                    // not all unitTypes seem to be convertible (e.g. kTextUnits). In that case, we'll go on with param.Expression assigned before.
                    catch (Exception e)
                    {
                        LogError("Can't get nominalValue for " + param.Name + ": " + e.Message);
                    }

                    var parameter = new InventorParameter
                    {
                        Unit   = param.Units,
                        Value  = nominalValue,
                        Values = param.ExpressionList?.GetExpressionList() ?? new string[0]
                    };
                    parameters.Add(param.Name, parameter);
                }

                return(parameters);
            }
            catch (Exception e)
            {
                LogError("Error reading params: " + e.Message);
                return(null);
            }
        }
コード例 #7
0
        /// <summary>
        /// Update project state with the parameters (or take it from cache).
        /// </summary>
        public async Task <ProjectStateDTO> DoSmartUpdateAsync(InventorParameters parameters, string projectId, bool bForceUpdate = false)
        {
            var hash = Crypto.GenerateObjectHashString(parameters);

            //_logger.LogInformation(JsonSerializer.Serialize(parameters));
            _logger.LogInformation($"Incoming parameters hash is {hash}");

            var storage = await _userResolver.GetProjectStorageAsync(projectId);

            var project = storage.Project;

            var localNames = project.LocalNameProvider(hash);

            // check if the data cached already
            if (Directory.Exists(localNames.SvfDir) && !bForceUpdate)
            {
                _logger.LogInformation("Found cached data.");
            }
            else
            {
                var resultingHash = await UpdateAsync(project, storage, parameters, hash, bForceUpdate);

                if (!hash.Equals(resultingHash, StringComparison.Ordinal))
                {
                    _logger.LogInformation($"Update returned different parameters. Hash is {resultingHash}.");
                    await CopyStateAsync(project, resultingHash, hash, storage.IsAssembly);

                    // update
                    hash = resultingHash;
                }
            }

            var dto = _dtoGenerator.MakeProjectDTO <ProjectStateDTO>(project, hash, storage.IsAssembly);

            dto.Parameters = Json.DeserializeFile <InventorParameters>(localNames.Parameters);

            return(dto);
        }
コード例 #8
0
        /// <summary>
        /// Create adoption data.
        /// </summary>
        /// <param name="docUrl">URL to the input Inventor document (IPT or zipped IAM)</param>
        /// <param name="tlaFilename">Top level assembly in the ZIP. (if any)</param>
        /// <param name="parameters">Inventor parameters.</param>
        public async Task <UpdateData> ForUpdateAsync(string docUrl, string tlaFilename, InventorParameters parameters)
        {
            var bucket = await _userResolver.GetBucketAsync();

            var urls = await Task.WhenAll(
                bucket.CreateSignedUrlAsync(OutputModelIAM, ObjectAccess.Write),
                bucket.CreateSignedUrlAsync(OutputModelIPT, ObjectAccess.Write),
                bucket.CreateSignedUrlAsync(SVF, ObjectAccess.Write),
                bucket.CreateSignedUrlAsync(Parameters, ObjectAccess.Write),
                bucket.CreateSignedUrlAsync(InputParams, ObjectAccess.ReadWrite),
                bucket.CreateSignedUrlAsync(BomJson, ObjectAccess.Write)
                );

            await using var jsonStream = Json.ToStream(parameters);
            await bucket.UploadObjectAsync(InputParams, jsonStream);

            return(new UpdateData
            {
                InputDocUrl = docUrl,
                OutputIAMModelUrl = urls[0],
                OutputIPTModelUrl = urls[1],
                SvfUrl = urls[2],
                ParametersJsonUrl = urls[3],
                InputParamsUrl = urls[4],
                BomUrl = urls[5],
                TLA = tlaFilename
            });
        }
コード例 #9
0
        /// <summary>
        /// Generate project data for the given parameters and cache results locally.
        /// </summary>
        /// <returns>Resulting parameters hash</returns>
        private async Task <string> UpdateAsync(Project project, ProjectStorage storage, InventorParameters parameters, string hash, bool bForceUpdate = false)
        {
            _logger.LogInformation("Update the project");
            var bucket = await _userResolver.GetBucketAsync();

            var isUpdateExists = bForceUpdate ? false : await IsGenerated(project, bucket, hash);

            if (isUpdateExists)
            {
                _logger.LogInformation("Detected existing outputs at OSS");
            }
            else
            {
                var inputDocUrl = await bucket.CreateSignedUrlAsync(project.OSSSourceModel);

                UpdateData updateData = await _arranger.ForUpdateAsync(inputDocUrl, storage.Metadata.TLA, parameters);

                ProcessingResult result = await _fdaClient.UpdateAsync(updateData);

                if (!result.Success)
                {
                    _logger.LogError($"Failed to update '{project.Name}' project.");
                    throw new FdaProcessingException($"Failed to update '{project.Name}' project.", result.ReportUrl);
                }

                _logger.LogInformation("Moving files around");

                // rearrange generated data according to the parameters hash
                // NOTE: hash might be changed if Inventor adjust them!
                hash = await _arranger.MoveViewablesAsync(project, storage.IsAssembly);
            }

            _logger.LogInformation($"Cache the project locally ({hash})");

            // and now cache the generate stuff locally
            var projectStorage = new ProjectStorage(project);
            await projectStorage.EnsureViewablesAsync(bucket, hash);

            return(hash);
        }
コード例 #10
0
 public UpdateModelJobItem(ILogger logger, string projectId, InventorParameters parameters, ProjectWork projectWork)
     : base(logger, projectId, projectWork)
 {
     Parameters = parameters;
 }
コード例 #11
0
        private InventorParameters ExtractParameters(Document doc, dynamic userParameters)
        {
            /* The resulting json will be like this:
             * {
             *  "length" : {
             *    "unit": "in",
             *    "value": "10 in",
             *    "values": ["5 in", "10 in", "15 in"]
             *  },
             *  "width": {
             *    "unit": "in",
             *    "value": "20 in",
             *  }
             * }
             */
            try
            {
                var parameters        = new InventorParameters();
                var docUnitsOfMeasure = doc.UnitsOfMeasure;
                foreach (dynamic param in userParameters)
                {
                    var    nominalValue = param.Expression;
                    string errorMessage = null;
                    try
                    {
                        var unitType = docUnitsOfMeasure.GetTypeFromString(param.Units);
                        LogTrace($"Checking expression validity on extraction for {param.Expression} and unit type {param.Units} / {unitType}");
                        if (docUnitsOfMeasure.IsExpressionValid(param.Expression, unitType))
                        {
                            var value = docUnitsOfMeasure.GetValueFromExpression(param.Expression, unitType);
                            nominalValue = docUnitsOfMeasure.GetPreciseStringFromValue(value, unitType);
                        }
                        else
                        {
                            LogTrace($"Expression '{param.Expression}' invalid for unit type '{unitType}' on extract attempt");
                            errorMessage = "Parameter's expression is not valid for its unit type";
                        }
                    }
                    // not all unitTypes seem to be convertible (e.g. kTextUnits). In that case, we'll go on with param.Expression assigned before.
                    catch (Exception e)
                    {
                        LogError("Can't get nominalValue for " + param.Name + ": " + e.Message);
                    }

                    var parameter = new InventorParameter
                    {
                        Unit         = param.Units,
                        Value        = nominalValue,
                        Values       = param.ExpressionList?.GetExpressionList() ?? new string[0],
                        ErrorMessage = errorMessage
                    };
                    parameters.Add(param.Name, parameter);
                }

                return(parameters);
            }
            catch (Exception e)
            {
                LogError("Error reading params: " + e.Message);
                return(null);
            }
        }
コード例 #12
0
        public void Extract(Document doc, Parameters parameters, InventorParameters updateResultParameters = null)
        {
            // extract user parameters
            InventorParameters allParams = ExtractParameters(doc, parameters);

            // save current state
            LogTrace("Updating");
            doc.Update2();
            LogTrace("Saving");
            doc.Save2(SaveDependents: true);

            // detect iLogic forms
            iLogicFormsReader reader = new iLogicFormsReader(doc, allParams);

            iLogicForm[] forms = reader.Extract();
            LogTrace($"Found {forms.Length} iLogic forms");
            foreach (var form in forms)
            {
                LogTrace($" - {form.Name}");
            }

            // Choose set of parameters to use with the following algorithm:
            // - extract all iLogic forms from the document
            //   - keep only 'user parameters' from a form
            // - use _first_ iLogic form with non-empty list of parameters
            // - if no forms - use UserParameters from the document
            InventorParameters resultingParameters;
            var candidate = forms.FirstOrDefault(form => form.Parameters.Count > 0);

            if (candidate != null)
            {
                LogTrace($"Using '{candidate.Name}' form as a parameter filter");
                resultingParameters = candidate.Parameters;
            }
            else
            {
                LogTrace("No non-empty iLogic forms found. Using all user parameters.");
                resultingParameters = ExtractParameters(doc, parameters.UserParameters);
            }

            // if parameters from an update result were passed in, if validation errors were set on any replace values with them
            if (updateResultParameters != null)
            {
                foreach (KeyValuePair <string, InventorParameter> updateResultParam in updateResultParameters)
                {
                    if (updateResultParam.Value.ErrorMessage != null)
                    {
                        resultingParameters[updateResultParam.Key] = updateResultParam.Value;
                    }
                }
            }

            // generate resulting JSON. Note it's not formatted (to have consistent hash)
            string paramsJson = JsonConvert.SerializeObject(resultingParameters, new JsonSerializerSettings {
                NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None
            });

            System.IO.File.WriteAllText("documentParams.json", paramsJson);

            LogTrace("Closing");
            doc.Close(true);
        }
コード例 #13
0
        /// <summary>
        /// Generate project data for the given parameters and cache results locally.
        /// </summary>
        /// <returns>Resulting parameters hash</returns>
        private async Task <(string hash, FdaStatsDTO stats, string reportUrl)> UpdateAsync(ProjectStorage storage, InventorParameters parameters,
                                                                                            string hash, bool bForceUpdate = false)
        {
            _logger.LogInformation("Update the project");
            var bucket = await _userResolver.GetBucketAsync();

            var isUpdateExists = bForceUpdate ? false : await IsGenerated(bucket, storage.GetOssNames(hash));

            FdaStatsDTO stats;
            string      reportUrl;

            if (isUpdateExists)
            {
                _logger.LogInformation("Detected existing outputs at OSS");
                var statsNative = await bucket.DeserializeAsync <List <Statistics> >(storage.GetOssNames(hash).StatsUpdate);

                stats     = FdaStatsDTO.CreditsOnly(statsNative);
                reportUrl = null;
            }
            else
            {
                Project project = storage.Project;

                var inputDocUrl = await bucket.CreateSignedUrlAsync(project.OSSSourceModel);

                UpdateData updateData = await _arranger.ForUpdateAsync(inputDocUrl, storage.Metadata.TLA, parameters);

                ProcessingResult result = await _fdaClient.UpdateAsync(updateData);

                if (!result.Success)
                {
                    _logger.LogError($"Failed to update '{project.Name}' project.");
                    throw new FdaProcessingException($"Failed to update '{project.Name}' project.", result.ReportUrl);
                }

                _logger.LogInformation("Moving files around");

                // rearrange generated data according to the parameters hash
                // NOTE: hash might be changed if Inventor adjust them!
                hash = await _arranger.MoveViewablesAsync(project, storage.IsAssembly);

                // process statistics
                await bucket.UploadAsJsonAsync(storage.GetOssNames(hash).StatsUpdate, result.Stats);

                stats     = FdaStatsDTO.All(result.Stats);
                reportUrl = result.ReportUrl;
            }

            _logger.LogInformation($"Cache the project locally ({hash})");

            // and now cache the generated stuff locally
            await storage.EnsureViewablesAsync(bucket, hash);

            return(hash, stats, reportUrl);
        }
コード例 #14
0
        /// <summary>
        /// Update project state with the parameters (or take it from cache).
        /// </summary>
        public async Task <(ProjectStateDTO dto, FdaStatsDTO stats, string reportUrl)> DoSmartUpdateAsync(InventorParameters parameters,
                                                                                                          string projectId, bool bForceUpdate = false)
        {
            var hash = Crypto.GenerateObjectHashString(parameters);

            _logger.LogInformation($"Incoming parameters hash is {hash}");

            var storage = await _userResolver.GetProjectStorageAsync(projectId);

            FdaStatsDTO stats;
            var         localNames = storage.GetLocalNames(hash);

            string reportUrl;

            // check if the data cached already
            if (Directory.Exists(localNames.SvfDir) && !bForceUpdate)
            {
                _logger.LogInformation("Found cached data.");

                // restore statistics
                var bucket = await _userResolver.GetBucketAsync();

                var statsNative = await bucket.DeserializeAsync <List <Statistics> >(storage.GetOssNames(hash).StatsUpdate);

                stats     = FdaStatsDTO.CreditsOnly(statsNative);
                reportUrl = null;
            }
            else
            {
                string resultingHash;
                (resultingHash, stats, reportUrl) = await UpdateAsync(storage, parameters, hash, bForceUpdate);

                if (!hash.Equals(resultingHash, StringComparison.Ordinal))
                {
                    _logger.LogInformation($"Update returned different parameters. Hash is {resultingHash}.");
                    await CopyStateAsync(storage.Project, resultingHash, hash, storage.IsAssembly);

                    // update
                    hash = resultingHash;
                }
            }

            var dto = _dtoGenerator.MakeProjectDTO <ProjectStateDTO>(storage, hash);

            dto.Parameters = Json.DeserializeFile <InventorParameters>(localNames.Parameters);

            return(dto, stats, reportUrl);
        }
コード例 #15
0
        public void Run(Document doc)
        {
            LogTrace($"Run called with {doc.DisplayName}");

            try
            {
                using (new HeartBeat())
                {
                    Parameters parameters;
                    switch (doc.DocumentType)
                    {
                    case DocumentTypeEnum.kPartDocumentObject:
                        parameters = ((PartDocument)doc).ComponentDefinition.Parameters;
                        break;

                    case DocumentTypeEnum.kAssemblyDocumentObject:
                        parameters = ((AssemblyDocument)doc).ComponentDefinition.Parameters;
                        break;

                    default:
                        LogError($"Unsupported document type: {doc.DocumentType}");
                        return;
                    }

                    // extract user parameters
                    InventorParameters allParams = ExtractParameters(doc, parameters);

                    // save current state
                    LogTrace("Updating");
                    doc.Update2();
                    LogTrace("Saving");
                    doc.Save2(SaveDependents: true);

                    // detect iLogic forms
                    iLogicFormsReader reader = new iLogicFormsReader(doc, allParams);
                    iLogicForm[]      forms  = reader.Extract();
                    LogTrace($"Found {forms.Length} iLogic forms");
                    foreach (var form in forms)
                    {
                        LogTrace($" - {form.Name}");
                    }

                    // Choose set of parameters to use with the following algorithm:
                    // - extract all iLogic forms from the document
                    //   - keep only 'user parameters' from a form
                    // - use _first_ iLogic form with non-empty list of parameters
                    // - if no forms - use UserParameters from the document
                    InventorParameters resultingParameters;
                    var candidate = forms.FirstOrDefault(form => form.Parameters.Count > 0);
                    if (candidate != null)
                    {
                        LogTrace($"Using '{candidate.Name}' form as a parameter filter");
                        resultingParameters = candidate.Parameters;
                    }
                    else
                    {
                        LogTrace("No non-empty iLogic forms found. Using all user parameters.");
                        resultingParameters = ExtractParameters(doc, parameters.UserParameters);
                    }

                    // generate resulting JSON. Note it's not formatted (to have consistent hash)
                    string paramsJson = JsonConvert.SerializeObject(resultingParameters, new JsonSerializerSettings {
                        NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None
                    });
                    System.IO.File.WriteAllText("documentParams.json", paramsJson);

                    LogTrace("Closing");
                    doc.Close(true);
                }
            }
            catch (Exception e)
            {
                LogError("Processing failed. " + e.ToString());
            }
        }
コード例 #16
0
 /// <summary>Constructor.</summary>
 /// <param name="document">Inventor document.</param>
 /// <param name="allowedParameters">Map with Inventor parameters, which are allowed to be extracted.</param>
 public iLogicFormsReader(Document document, InventorParameters allowedParameters)
 {
     _allowedParameters = allowedParameters;
     _storage           = UiStorageFactory.GetDocumentStorage(document);
 }
コード例 #17
0
        private async Task ScanBucket(List <MigrationJob> adoptJobs, List <MigrationJob> configJobs, string bucketKeyOld)
        {
            _logger.LogInformation($"Scanning bucket {bucketKeyOld}");
            MigrationBucketKeyProvider bucketProvider;
            ProjectService             projectService;

            using (var scope = _serviceScopeFactory.CreateScope())
            {
                bucketProvider = scope.ServiceProvider.GetService <MigrationBucketKeyProvider>();
                projectService = scope.ServiceProvider.GetService <ProjectService>();
            }

            OssBucket bucketOld = _bucketFactory.CreateBucket(bucketKeyOld);
            OssBucket bucketNew = _bucketFactory.CreateBucket(bucketProvider.GetBucketKeyFromOld(bucketKeyOld));

            List <string> projectNamesNew = new List <string>();

            try
            {
                List <string> projectNamesNewFromOss = (List <string>) await projectService.GetProjectNamesAsync(bucketNew);

                foreach (string projectName in projectNamesNewFromOss)
                {
                    var    ossAttributes = new OssAttributes(projectName);
                    string metadataFile  = ossAttributes.Metadata;
                    // if metadata file is missing for project we consider that project not migrated
                    if (await bucketNew.ObjectExistsAsync(metadataFile))
                    {
                        projectNamesNew.Add(projectName);
                    }
                }
            }
            catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
            {
                // swallow non existing item
            }

            // gather list of cache paramters files from the new bucket
            List <string> configKeysNew = new List <string>();

            try {
                List <ObjectDetails> configODsNew = await bucketNew.GetObjectsAsync($"{ONC.CacheFolder}/");

                foreach (ObjectDetails configODNew in configODsNew)
                {
                    if (configODNew.ObjectKey.EndsWith(WebApplication.Utilities.LocalName.Parameters))
                    {
                        configKeysNew.Add(configODNew.ObjectKey);
                    }
                }
            }
            catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
            {
                // swallow non existing item
            }

            // gather projects to migrate
            List <string> projectNamesOld = (List <string>) await projectService.GetProjectNamesAsync(bucketOld);

            foreach (string projectName in projectNamesOld)
            {
                if (!projectNamesNew.Contains(projectName))
                {
                    // new project list does not contain old project => lets copy and adopt
                    var    ossAttributes = new OssAttributes(projectName);
                    string metadataFile  = ossAttributes.Metadata;
                    try {
                        ProjectMetadata projectMetadata = await bucketOld.DeserializeAsync <ProjectMetadata>(metadataFile);

                        ProjectInfo projectInfo = new ProjectInfo();
                        projectInfo.Name             = projectName;
                        projectInfo.TopLevelAssembly = projectMetadata.TLA;

                        MigrationJob migrationJob;
                        using (var scope = _serviceScopeFactory.CreateScope())
                        {
                            migrationJob = scope.ServiceProvider.GetService <MigrationJob>();
                        }
                        migrationJob.SetJob(JobType.CopyAndAdopt, bucketOld, projectInfo, ONC.ProjectUrl(projectName));
                        adoptJobs.Add(migrationJob);
                    } catch (Exception e)
                    {
                        _logger.LogError(e, $"Project {projectName} in bucket {bucketKeyOld} does not have metadata file. Skipping it.");
                    }
                }

                // process cached configurations
                List <ObjectDetails> configODs = await bucketOld.GetObjectsAsync($"{ONC.CacheFolder}/{projectName}/");

                foreach (ObjectDetails configOD in configODs)
                {
                    string configKey = configOD.ObjectKey;
                    if (configKey.EndsWith(WebApplication.Utilities.LocalName.Parameters))
                    {
                        // calculate parameter hash based on new algorithmes
                        InventorParameters parameters = await bucketOld.DeserializeAsync <InventorParameters>(configKey);

                        string newHash            = Crypto.GenerateParametersHashString(parameters);
                        OSSObjectNameProvider onp = new OSSObjectNameProvider(projectName, newHash);
                        configKey = onp.Parameters;

                        if (!configKeysNew.Contains(configKey))
                        {
                            ProjectInfo projectInfo = new ProjectInfo();
                            projectInfo.Name = projectName;

                            MigrationJob migrationJob;
                            using (var scope = _serviceScopeFactory.CreateScope())
                            {
                                migrationJob = scope.ServiceProvider.GetService <MigrationJob>();
                            }
                            migrationJob.SetJob(JobType.GenerateConfiguration, bucketOld, projectInfo, ONC.ProjectUrl(projectName), parameters);
                            configJobs.Add(migrationJob);
                        }
                    }
                }
            }

            // check if any of migrated projects were deleted in old bucket
            // (user deleted them after migration started)
            foreach (string projectName in projectNamesNew)
            {
                if (!projectNamesOld.Contains(projectName))
                {
                    MigrationJob migrationJob;
                    using (var scope = _serviceScopeFactory.CreateScope())
                    {
                        migrationJob = scope.ServiceProvider.GetService <MigrationJob>();
                    }
                    migrationJob.SetJob(JobType.RemoveNew, bucketNew, new ProjectInfo(projectName), null);
                    adoptJobs.Add(migrationJob);
                }
            }
        }
コード例 #18
0
 private FormExtractor(FormSpecification formSpec, InventorParameters allowedParameters)
 {
     _formSpec          = formSpec;
     _allowedParameters = allowedParameters;
 }