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);
}
}
