public override void ValidateParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (!parameters.ContainsKey("FetchXml") || string.IsNullOrEmpty(parameters["FetchXml"])) { throw new Exception("DataRecordQueryMatchEvalautor requires a parameter for FetchXml."); } }
public ProcessRetryContext(long id, int processKey, ILogger logger, IProcessExecutionContext executionContext) { Id = id; ProcessKey = processKey; Logger = logger; ExecutionContext = executionContext; }
public void ValidateParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (!parameters.ContainsKey("EvaluateAs")) { throw new Exception("FakeLogicEvaluatorType requires a parameter named 'EvaluateAs' that contains a boolean value."); } }
public ITransactionContext CreateTransactionContext(IProcessExecutionContext executionContext, IRecordPointer <Guid> transactionContextId, bool useCache = true) { useCache = useCache && executionContext.Cache != null; string cacheKey = null; if (useCache) { cacheKey = CACHE_KEY + transactionContextId.Id.ToString(); if (executionContext.Cache.Exists(cacheKey)) { return(executionContext.Cache.Get <ITransactionContext>(cacheKey)); } } var record = DataConnector.GetTransactionContextRecord(executionContext.DataService, transactionContextId); var customer = CustomerFactory.CreateCustomer(executionContext, record.CustomerId, useCache); var transactionContext = new TransactionContext(record, customer); if (useCache) { var settings = SettingsFactory.CreateSettings(executionContext.Settings); var cacheTimeout = settings.TransactionContextCacheTimeout; executionContext.Cache.Add <ITransactionContext>(cacheKey, transactionContext, cacheTimeout.Value); } return(transactionContext); }
public override void ValidateParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (!parameters.ContainsKey("ActionName") || string.IsNullOrEmpty(parameters["ActionName"])) { throw new Exception("DataRecordActionEvaluator requires a parameter for ActionName."); } }
public ITransactionFeeList CreateFeeList(IProcessExecutionContext executionContext, ITransaction transaction) { try { if (executionContext is null) { throw new ArgumentNullException("executionContext"); } if (transaction is null) { throw new ArgumentNullException("transaction"); } IList <ITransactionFee> transactionFees = new List <ITransactionFee>(); var transactionFeeRecords = DataConnector.GetTransactionFees(executionContext.DataService, transaction); foreach (var r in transactionFeeRecords) { var fee = r.Fee != null?DataConnector.GetFeeById(executionContext.DataService, r.Fee) : null; transactionFees.Add(new TransactionFee(r, fee)); } return(new TransactionFeeList(this.DataConnector, this.PriceCalculatorFactory, transaction, transactionFees)); } catch (Exception ex) { throw ex; } }
private IList <IRequirement> getRequirements(IProcessExecutionContext executionContext, bool useCache) { try { IList <IRequirement> registeredRequirements = new List <IRequirement>(); var requirements = DataConnector.GetAllRequirements(executionContext.DataService); var waiverRoles = DataConnector.GetAllRequirementWaiverRoles(executionContext.DataService); foreach (var requirement in requirements) { ILogicEvaluatorType evaluatorType = this.EvaluatorTypeFactory.BuildEvaluatorType(executionContext, requirement.EvaluatorTypeId, useCache); registeredRequirements.Add( RequirementFactory.CreateRequirement( executionContext, requirement as IRecordPointer <Guid>, requirement.Name, requirement.TypeFlag ?? eRequirementTypeFlags.Validation, requirement.TransactionTypeId, evaluatorType, requirement.RequirementParameters, waiverRoles.Where(r => r.TransactionRequirementId != null && r.TransactionRequirementId.Id == requirement.Id).Select(r => r.RoleId), useCache)); } return(registeredRequirements); } catch (Exception) { throw; } }
public IAgent BuildAgent(IProcessExecutionContext executionContext, IRecordPointer <Guid> agentId, bool useCache = true) { var service = executionContext.DataService as IOrganizationService; var record = service.Retrieve(agentId.RecordType, agentId.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true)).ToEntity <TestProxy.ccllc_agent>(); return(new FakeAgent(record)); }
public void Execute(BoostTestRunnerCommandLineArgs args, BoostTestRunnerSettings settings, IProcessExecutionContext executionContext) { var fixedArgs = args; if (args != null) { // Adapt a copy of the command-line arguments to avoid changing the original fixedArgs = AdaptArguments(args.Clone()); } using (var stderr = new TemporaryFile(IsStandardErrorFileDifferent(args, fixedArgs) ? fixedArgs.StandardErrorFile : null)) { this.Runner.Execute(fixedArgs, settings, executionContext); // Extract the report output to its intended location string source = (fixedArgs == null) ? null : fixedArgs.StandardErrorFile; string destination = (args == null) ? null : args.ReportFile; if ((source != null) && (destination != null)) { try { ExtractReport(source, destination, string.IsNullOrEmpty(stderr.Path)); } catch (Exception ex) { Logger.Exception(ex, "Failed to extract test report from standard error [{0}] to report file [{1}] ({2})", source, destination, ex.Message); } } } }
public void AddFee(IProcessExecutionContext executionContext, IWorkSession session, IFee fee, decimal quantity = 1) { try { // check to see if the related fee is already in the list. If so we will update that item rather than create // a new one. var transactionFee = FeeList.Where(r => r.Fee.Id == fee.Id).FirstOrDefault(); if (transactionFee is null) { var transactionFeeRecord = DataConnector.CreateTransactionFee( executionContext.DataService, Transaction, fee as IRecordPointer <Guid>, fee.Name, quantity); transactionFee = new TransactionFee(transactionFeeRecord, fee); FeeList.Add(transactionFee); } else { transactionFee.IncrementQuantity(quantity); } var priceCalculator = PriceCalculatorFactory.CreatePriceCalculator(executionContext, session, Transaction); transactionFee.CalculatePrice(executionContext, priceCalculator); DataConnector.UpdateTransactionFee(executionContext.DataService, transactionFee); } catch (Exception ex) { throw ex; } }
public Transaction(IProcessExecutionContext executionContext, IAgentFactory agentFactory, ITransactionFeeListFactory transactionFeeListFactory, ITransactionContextFactory transactionContextFactory, ICustomerFactory customerFactory, ITransactionDeficienciesFactory transactionDeficienciesFactory, IDocumentService documentService, IEvidenceService evidenceService, ILocationFactory locationFactory, IRequirementEvaluator requirementEvaluator, ITransactionHistoryFactory transactionHistoryFactory, ITransactionService transactionService, ITransactionType transactionType, ITransactionRecord record) : base(record.RecordType, record.Id) { this.ExecutionContext = executionContext ?? throw new ArgumentNullException("executionContext"); this.AgentFactory = agentFactory ?? throw new ArgumentNullException("agentFactory"); this.TransactionFeeListFactory = transactionFeeListFactory ?? throw new ArgumentNullException("transactionFeeListFactory"); this.TransactionContextFactory = transactionContextFactory ?? throw new ArgumentNullException("transactionContextFactory"); this.CustomerFactory = customerFactory ?? throw new ArgumentNullException("customerFactory"); this.TransactionDeficienciesFactory = transactionDeficienciesFactory ?? throw new ArgumentNullException("transactionDeficienciesFactory"); this.DocumentService = documentService ?? throw new ArgumentNullException("documentService"); this.EvidenceService = evidenceService ?? throw new ArgumentNullException("evidenceService"); this.LocationFactory = locationFactory ?? throw new ArgumentNullException("locationFactory"); this.RequirementEvaluator = requirementEvaluator ?? throw new ArgumentNullException("requirementEvaluator"); this.TransactionHistoryFactory = transactionHistoryFactory ?? throw new ArgumentNullException("transactionHistoryFactory"); this.TransactionService = transactionService ?? throw new ArgumentNullException("transactionService"); this.TransactionType = transactionType ?? throw new ArgumentNullException("transactionType"); this.Name = record.Name; this.ReferenceNumber = record.ReferenceNumber; this.PricingDate = record.PricingDate ?? DateTime.Now.Date; this.InitiatingProcessId = record.InitiatingProcessId ?? throw new ArgumentNullException("InitiatingProcessId"); this.CurrentProcessId = record.CurrentProcessId ?? throw new ArgumentNullException("CurrentProcessId"); this.CurrentStepId = record.CurrentStepId ?? throw new ArgumentNullException("CurrentStepId"); this.ContextRecordId = record.ContextRecordId ?? throw new ArgumentNullException("contextRecordId"); this.CustomerId = record.CustomerId ?? throw new ArgumentNullException("customerId"); this.InitiatingAgentId = record.InitiatingAgentId ?? throw new ArgumentNullException("initiatingAgentId"); this.InitiatingLocationId = record.InitiatingLocationId ?? throw new ArgumentNullException("initiatingLocationId"); }
public ILogicEvaluatorType BuildEvaluatorType(IProcessExecutionContext executionContext, IRecordPointer <Guid> evaluatorTypeId, bool useCache = true) { if (evaluatorTypeId is null) { throw new ArgumentNullException("evaluatorTypeId"); } var cacheTimeout = useCache ? getCacheTimeout(executionContext) : null; useCache = useCache && executionContext.Cache != null && cacheTimeout != null; string cacheKey = null; if (useCache) { cacheKey = CACHE_KEY + evaluatorTypeId.Id.ToString(); if (executionContext.Cache.Exists(cacheKey)) { return(executionContext.Cache.Get <ILogicEvaluatorType>(cacheKey)); } } try { var record = DataConnector.GetEvaluatorTypeRecord(executionContext.DataService, evaluatorTypeId); return(this.BuildEvaluatorType(executionContext, record, record.Name, record.AssemblyName, record.ClassName)); } catch (Exception) { throw; } }
public override void ValidateStepParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (!parameters.ContainsKey("FormId") || string.IsNullOrEmpty(parameters["FormId"])) { throw new Exception("Entity Data Capture step requires parameter 'FormId'"); } }
public IList <IRequirementDeficiency> Evaluate(IProcessExecutionContext executionContext, ITransaction transaction, IList <IRecordPointer <Guid> > requirementPointers) { var evaluationDeficiencies = new List <IRequirementDeficiency>(); foreach (var requirementId in requirementPointers) { var requirement = transaction.TransactionType.Requirements .Where(r => r.Id == requirementId.Id) .FirstOrDefault() ?? throw new Exception("Requirement is not in the list for this transaction"); var result = requirement.Evaluator.Evaluate(executionContext, transaction); var existingDeficiency = transaction.Deficiencies.GetCurrentRequirementDeficiency(requirement); if (result.Passed && existingDeficiency != null && existingDeficiency.Status != eDeficiencyStatusEnum.Waived) { transaction.Deficiencies.ClearDeficiency(executionContext, requirement); } if (!result.Passed) { if (existingDeficiency == null) { evaluationDeficiencies.Add( transaction.Deficiencies.CreateDeficiency(executionContext, requirement)); } else { evaluationDeficiencies.Add(existingDeficiency); } } } return(evaluationDeficiencies); }
public ILocation CreateLocation(IProcessExecutionContext executionContext, IRecordPointer <Guid> locationId, bool useCache = true) { var service = executionContext.DataService as IOrganizationService; var record = service.Retrieve(locationId.RecordType, locationId.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true)).ToEntity <TestProxy.ccllc_location>(); return(new FakeLocation(record)); }
public override void ValidateStepParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (parameters.Count > 0) { throw new Exception("Branch Step does not support parameters"); } }
public IEncryptionService Create(IProcessExecutionContext executionContext, bool disableCache = false) { bool useCache = !disableCache && executionContext.Cache != null; if (useCache && executionContext.Cache.Exists(CACHE_KEY)) { return(executionContext.Cache.Get <IEncryptionService>(CACHE_KEY)); } var settings = SettingsFactory.Create(executionContext); var secretProvider = SecretProviderFactory.Create(executionContext, disableCache); var encryptionKey = secretProvider.GetValue <string>(settings.EncryptionKeyName) ?? throw new Exception("Missing Secret for encryption key."); var encryptor = new DefaultEncryptor(encryptionKey); var cacheTimeout = settings.CacheTimeout; if (useCache && cacheTimeout.HasValue) { executionContext.Cache.Add <IEncryptionService>(CACHE_KEY, encryptor, cacheTimeout.Value); } return(encryptor); }
public override void Execute(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, ISerializedParameters parameters) { try { if (!parameters.ContainsKey("ActionName")) { throw new Exception("DataRecordAction requires a parameter for ActionName"); } var dataRecord = transaction.DataRecord; var req = new OrganizationRequest(parameters["ActionName"]); req["Target"] = new EntityReference(dataRecord.RecordType, dataRecord.Id); req["Transaction"] = transaction.ToEntityReference(); //process any additional parameter data passed in from the configuration. if (parameters.Count > 1) { foreach (var key in parameters.Keys) { if (key != "ActionName" && !string.IsNullOrEmpty(parameters[key])) { req[key] = parameters[key]; } } } executionContext.DataService.ToOrgService().Execute(req); } catch (Exception ex) { throw new Exception(ex.Message, ex); } }
/// <summary> /// Returns a list of registered transaction types that are applicable based on the current context record and the limitations /// imposed by the agent and channel associated with the work session. /// </summary> /// <param name="session"></param> /// <param name="contextRecord"></param> /// <returns></returns> public IReadOnlyList <ITransactionType> GetAvaialbleTransactionTypes(IProcessExecutionContext executionContext, IWorkSession session, ITransactionContext transactionContext) { try { executionContext.Trace("Getting Transaction Types for context record type {0} and status {1}", transactionContext.RecordType, transactionContext.RecordStatus); var availableTransactions = RegisteredTransactionTypes .Where(t => session.SupportsChannel(t.AuthorizedChannels) && session.HasRole(t.AuthorizedRoles) && session.CanOperateAgainstCustomer(transactionContext.Customer) && transactionContext.IsContextType(t.EligibleContexts)) .OrderBy(t => t.Group.DisplayRank) .ThenBy(t => t.Group.Name) .ThenBy(t => t.DisplayRank) .ThenBy(t => t.Name) .ToList(); executionContext.Trace("Returning {0} eligible Transaction Types out of {1} registered Transaction Types", availableTransactions.Count, RegisteredTransactionTypes.Count); return(availableTransactions); } catch (Exception) { throw; } }
public IPriceCalculator CreatePriceCalculator(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, bool useCache = true) { useCache = useCache && executionContext.Cache != null; TimeSpan?cacheTimeout = null; string cacheKey = null; if (useCache) { cacheKey = string.Format(CACHE_KEY, session?.Location?.Id, session?.Channel?.Id, transaction?.PricingDate.ToShortDateString()); var settings = SettingsFactory.CreateSettings(executionContext.Settings); cacheTimeout = settings.PricingCalculatorCacheTimeout; if (executionContext.Cache.Exists(cacheKey)) { return(executionContext.Cache.Get <IPriceCalculator>(cacheKey)); } } //TEMPORARY IMPLEMENTATION var priceCalculator = new PriceCalculator(); if (useCache) { executionContext.Cache.Add <IPriceCalculator>(cacheKey, priceCalculator, cacheTimeout.Value); } return(priceCalculator); }
/// <summary> /// Returns all registered <see cref="ITransactionProcess"/> items in the system. Each item is fully configured with all associated /// <see cref="IProcessStep"/> items. /// </summary> /// <param name="executionContext"></param> /// <param name="cacheTimeout"></param> /// <returns></returns> private IList <ITransactionProcess> getProcesses(IProcessExecutionContext executionContext, bool useCache) { try { IList <ITransactionProcess> registeredProceses = new List <ITransactionProcess>(); var processes = DataConnector.GetAllTransactionProcesses(executionContext.DataService); executionContext.Trace("Retrieved {0} Transaction Process records.", processes.Count); var processSteps = getProcessSteps(executionContext, useCache); foreach (var process in processes) { executionContext.Trace("Building Transaction Process {0}", process.Name); var steps = processSteps.Where(s => s.TransactionProcessPointer.Id == process.Id); registeredProceses.Add( this.TransactionProcessFactory.CreateTransactionProcess( executionContext, process, process.Name, process.TransactionTypeId ?? throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessInvalid), process.InitialProcessStepId ?? throw TransactionException.BuildException(TransactionException.ErrorCode.ProcessInvalid), steps, useCache)); } return(registeredProceses); } catch (Exception) { throw; } }
public ISecretProvider Create(IProcessExecutionContext executionContext, bool disableCache = false) { if (!disableCache && executionContext.Cache != null) { if (executionContext.Cache.Exists(CACHE_KEY)) { return(executionContext.Cache.Get <ISecretProvider>(CACHE_KEY)); } } var tenantId = executionContext.Settings.GetValue <string>(SettingKeys.TenantId) ?? throw new Exception("Missing TenantId setting."); var clientId = executionContext.Settings.GetValue <string>(SettingKeys.ClientId) ?? throw new Exception("Missing ClientId setting."); var clientSecret = executionContext.Settings.GetValue <string>(SettingKeys.ClientSecret) ?? throw new Exception("Missing ClientSecret setting."); var vaultName = executionContext.Settings.GetValue <string>(SettingKeys.VaultName) ?? throw new Exception("Missing VaultName setting."); var cacheTimeout = executionContext.Settings.GetValue <TimeSpan?>(SettingKeys.CacheTimeout, TimeSpan.FromMinutes(15)); var secretIds = GetSecretIds(tenantId, clientId, clientSecret, vaultName); var secretProvider = new AzureSecretProvider(WebRequestFactory, Serializer, secretIds, tenantId, clientId, clientSecret, vaultName); if (!disableCache && executionContext.Cache != null && cacheTimeout.HasValue) { executionContext.Cache.Add <ISecretProvider>(CACHE_KEY, secretProvider, cacheTimeout.Value); } return(secretProvider); }
private void checkSettings(IProcessExecutionContext executionContext) { Assert.AreEqual(3, executionContext.Settings.Count); Assert.AreEqual("Value1", executionContext.Settings.GetValue <string>("ENV1")); Assert.AreEqual("Override2", executionContext.Settings.GetValue <string>("ENV2")); }
public override void ValidateStepParameters(IProcessExecutionContext executionContext, ISerializedParameters parameters) { if (!parameters.ContainsKey(feeParameter) || string.IsNullOrEmpty(parameters[feeParameter])) { throw new Exception(string.Format("AddFee required parameter '{0}'.", feeParameter)); } }
public void ArchiveHistoryForStep(IProcessExecutionContext executionContext, IWorkSession session, IProcessStep processStep, bool isRolledBack = false) { var historyRecord = GetHistoryForStep(processStep) as StepHistory; var statusCode = isRolledBack ? eProcessStepHistoryStatusEnum.RolledBack : eProcessStepHistoryStatusEnum.Archived; historyRecord.StepStatus = statusCode; DataConnector.UpdateStepHistoryStatus(executionContext.DataService, historyRecord, statusCode); }
public IRequirementDeficiency CreateDeficiency(IProcessExecutionContext executionContext, IRequirement requirement) { var record = DataConnector.CreateDeficiencyRecord(executionContext.DataService, requirement.Name, this.Transaction, requirement); var deficiency = new RequirementDeficiency(requirement, record.Status, null, null); base.Add(deficiency); return(deficiency); }
public IUIPointer GetUIPointer(IProcessExecutionContext executionContext, ITransaction transaction) { if (Type.IsUIStep) { return(Type.GetUIPointer(executionContext, transaction, Parameters)); } return(null); }
public bool Rollback(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction) { if (!Type.IsReversable) { return(false); } //complete any specific implementation for the step type return(Type.Rollback(executionContext, session, transaction, Parameters)); }
public void ClearDeficiency(IProcessExecutionContext executionContext, IRequirement requirement) { var deficiency = GetCurrentRequirementDeficiency(requirement); if (deficiency.Status != eDeficiencyStatusEnum.Waived) { DataConnector.UpdateDeficiencyRecordStatus(executionContext.DataService, deficiency, eDeficiencyStatusEnum.Cleared); base.Remove(deficiency); } }
public IWorkSession GenerateSession(IProcessExecutionContext executionContext, ISystemUser systemUser, bool useCache = true) { IAgent agent = AgentFactory.BuildAgent(executionContext, systemUser); //temporary implementation until data structures are in place to link a user to a location and channel. IChannel channel = this.GetChannels(executionContext).FirstOrDefault(); //Temporary ILocation location = DataConnector.GetLocationRecords(executionContext.DataService).FirstOrDefault(); //Temporary return(new WorkSession(agent, channel, location, null, null, null, null)); }
private void checkSettings(IProcessExecutionContext executionContext) { Assert.AreEqual(3, executionContext.Settings.Count); var value = executionContext.Settings.GetValue <string>("ENV1"); Assert.AreEqual("Value1", executionContext.Settings .GetValue <string>("ENV1")); Assert.AreEqual("Value2", executionContext.Settings.GetValue <string>("env2")); Assert.AreEqual(TimeSpan.FromTicks(0).Ticks, executionContext.Settings.GetValue <TimeSpan?>("CCLLC.SettingsCacheTimeOut").Value.Ticks); }
/// <summary> /// Executes the contained IBoostTestRunner with the contained arguments and settings /// </summary> /// <param name="context">The execution context of spawned sub-processes</param> public void Execute(IProcessExecutionContext context) { this.Runner.Execute(this.Arguments, this.Settings, context); }
public void Execute(BoostTestRunnerCommandLineArgs args, BoostTestRunnerSettings settings, IProcessExecutionContext context) { Copy("BoostTestAdapterNunit.Resources.ListContentDOT.sample.8.list.content.gv", args.StandardErrorFile); }
public virtual void Execute(BoostTestRunnerCommandLineArgs args, BoostTestRunnerSettings settings, IProcessExecutionContext executionContext) { Utility.Code.Require(settings, "settings"); Utility.Code.Require(executionContext, "executionContext"); using (Process process = executionContext.LaunchProcess(GetExecutionContextArgs(args, settings))) { MonitorProcess(process, settings.Timeout); } }