public static ActivityResponseDTO ErrorActivityResponseDTOWithoutErrorMessage()
{
var result = new ActivityResponseDTO();
result.Type = ActivityResponse.Error.ToString();
return(result);
}
private static bool TryParseBaseDTO <T>(ActivityResponseDTO activityResponse, string propertyName, out T parsedObject)
{
parsedObject = default(T);
if (string.IsNullOrEmpty(activityResponse.Body))
{
return(false);
}
try
{
JObject responseBody = JObject.Parse(activityResponse.Body);
var tokenObj = responseBody[propertyName];
if (tokenObj == null)
{
return(false);
}
parsedObject = JsonConvert.DeserializeObject <T>(tokenObj.ToString());
return(true);
}
catch (Exception exception)
{
return(false);
}
}
protected override async Task RunCurrentActivity()
{
var crate = FindCrateToProcess(CurrentPayloadStorage);
var payloadObjects = new List <PayloadObjectDTO>();
if (crate.IsOfType <StandardTableDataCM>())
{
var table = crate.Get <StandardTableDataCM>();
if (table.FirstRowHeaders)
{
payloadObjects.AddRange(
table.DataRows.Select(x => new PayloadObjectDTO(x.Row.Select(y => y.Cell)))
);
}
}
CurrentPayloadStorage.Add(
Fr8Data.Crates.Crate.FromContent(
"Sql Query Result",
new StandardPayloadDataCM
{
PayloadObjects = payloadObjects
}
)
);
OperationalState.CurrentActivityResponse =
ActivityResponseDTO.Create(ActivityResponse.ExecuteClientActivity);
OperationalState.CurrentClientActivityName = "ShowTableReport";
await Task.Yield();
}
/**********************************************************************************/
private void LoadAndRunPlan(Guid planId)
{
var plan = ObjectFactory.GetInstance <IPlan>();
var planDO = _uow.PlanRepository.GetById <PlanDO>(planId);
if (planDO == null)
{
throw new InvalidOperationException($"Plan {planId} was not found");
}
var crateStorage = _crate.GetStorage(_container.CrateStorage);
var operationStateCrate = crateStorage.CrateContentsOfType <OperationalStateCM>().Single();
operationStateCrate.CurrentActivityResponse = ActivityResponseDTO.Create(ActivityResponse.Null);
operationStateCrate.History.Add(new OperationalStateCM.HistoryElement
{
Description = "Launch Triggered by Container ID " + _container.Id
});
crateStorage.Remove <OperationalStateCM>();
var payloadCrates = crateStorage.AsEnumerable().ToArray();
plan.Enqueue(planDO.Id, payloadCrates);
}
public static ActivityResponseDTO ErrorActivityResponseDTOWithErrorMessage()
{
var result = new ActivityResponseDTO {
Type = ActivityResponse.Error.ToString()
};
result.AddErrorDTO(ErrorDTO.InternalError(ErrorMessage));
return(result);
}
/**********************************************************************************/
private Guid ExtractGuidParameter(ActivityResponseDTO activityResponse)
{
ResponseMessageDTO responseMessage;
if (!activityResponse.TryParseResponseMessageDTO(out responseMessage))
{
throw new InvalidOperationException("Unable to parse op code parameter");
}
return(Guid.Parse((string)responseMessage.Details));
}
/**********************************************************************************/
protected void SetResponse(ActivityResponse response, string message = null, object details = null)
{
OperationalState.CurrentActivityResponse = ActivityResponseDTO.Create(response);
if (!string.IsNullOrWhiteSpace(message) || details != null)
{
OperationalState.CurrentActivityResponse.AddResponseMessageDTO(new ResponseMessageDTO()
{
Message = message, Details = details
});
}
}
private void UpdateOperationCrate(string errorMessage = null)
{
Storage.RemoveByManifestId((int)MT.OperationalStatus);
var operationalStatus = new OperationalStateCM
{
CurrentActivityResponse = ActivityResponseDTO.Create(ActivityResponse.ExecuteClientActivity),
};
operationalStatus.CurrentActivityResponse.Body = "RunImmediately";
var operationsCrate = Crate.FromContent("Operational Status", operationalStatus);
Storage.Add(operationsCrate);
}
private static ActivityResponseDTO AddBaseDTO <T>(ActivityResponseDTO activityResponse, string propertyName, T objectToAdd)
{
var responseBody = string.IsNullOrEmpty(activityResponse.Body)
? new JObject() : JObject.Parse(activityResponse.Body);
//in future extend it to work with JArray-property base if needed
JToken token = JsonConvert.SerializeObject(objectToAdd);
JToken tempToken;
if (responseBody.TryGetValue(propertyName, out tempToken))
{
//check if already some object exists, that case update it based on property
responseBody[propertyName] = token;
}
else
{
responseBody.Add(propertyName, token);
}
activityResponse.Body = JsonConvert.SerializeObject(responseBody);
return(activityResponse);
}
public static bool TryParseActivityDTO(this ActivityResponseDTO activityResponse, out ActivityDTO activityDTO)
{
return(TryParseBaseDTO <ActivityDTO>(activityResponse, ActivityPropertyName, out activityDTO));
}
public static bool TryParsePayloadDTO(this ActivityResponseDTO activityResponse, out PayloadDTO payloadDTO)
{
return(TryParseBaseDTO <PayloadDTO>(activityResponse, PayloadPropertyName, out payloadDTO));
}
public static ActivityResponseDTO AddPayloadDTO(this ActivityResponseDTO activityResponse, PayloadDTO payloadDTO)
{
return(AddBaseDTO <PayloadDTO>(activityResponse, PayloadPropertyName, payloadDTO));
}
public static bool TryParseErrorDTO(this ActivityResponseDTO activityResponse, out ErrorDTO errorDTO)
{
return(TryParseBaseDTO <ErrorDTO>(activityResponse, ErrorPropertyName, out errorDTO));
}
public static ActivityResponseDTO AddErrorDTO(this ActivityResponseDTO activityResponse, ErrorDTO errorDTO)
{
return(AddBaseDTO <ErrorDTO>(activityResponse, ErrorPropertyName, errorDTO));
}
public override async Task FollowUp()
{
var activityTemplates = (await HubCommunicator.GetActivityTemplates(null, true))
.Select(Mapper.Map <ActivityTemplateDO>)
.ToList();
try
{
var continueClicked = false;
Storage.Remove <StandardQueryCM>();
await UpdatePlanName();
var queryCrate = ExtractQueryCrate(Storage);
Storage.Add(queryCrate);
var continueButton = GetControl <Button>("Continue");
if (continueButton != null)
{
continueClicked = continueButton.Clicked;
if (continueButton.Clicked)
{
continueButton.Clicked = false;
}
}
if (continueClicked)
{
ActivityPayload.ChildrenActivities.Clear();
var queryFr8WarehouseActivityTemplate = activityTemplates
.FirstOrDefault(x => x.Name == "Query_Fr8_Warehouse");
if (queryFr8WarehouseActivityTemplate == null)
{
return;
}
var queryFr8WarehouseTemplate = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Query_Fr8_Warehouse");
var queryFr8WarehouseAction = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, queryFr8WarehouseTemplate);
var crateStorage = queryFr8WarehouseAction.CrateStorage;
var upstreamManifestTypes = crateStorage
.CrateContentsOfType <KeyValueListCM>(x => x.Label == "Upstream Crate ManifestType List")
.FirstOrDefault();
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.FirstOrDefault();
var radioButtonGroup = controls
.FindByName <RadioButtonGroup>("QueryPicker");
UpstreamCrateChooser upstreamCrateChooser = null;
if (radioButtonGroup != null &&
radioButtonGroup.Radios.Count > 0 &&
radioButtonGroup.Radios[0].Controls.Count > 0)
{
upstreamCrateChooser = radioButtonGroup.Radios[0].Controls[0] as UpstreamCrateChooser;
}
if (upstreamCrateChooser != null)
{
if (upstreamManifestTypes != null)
{
upstreamCrateChooser.SelectedCrates[0].ManifestType.selectedKey = upstreamManifestTypes.Values[0].Key;
upstreamCrateChooser.SelectedCrates[0].ManifestType.Value = upstreamManifestTypes.Values[0].Value;
}
upstreamCrateChooser.SelectedCrates[0].Label.selectedKey = QueryCrateLabel;
upstreamCrateChooser.SelectedCrates[0].Label.Value = QueryCrateLabel;
}
queryFr8WarehouseAction = await HubCommunicator.ConfigureChildActivity(
ActivityPayload,
queryFr8WarehouseAction
);
Storage.RemoveByManifestId((int)MT.OperationalStatus);
var operationalStatus = new OperationalStateCM();
operationalStatus.CurrentActivityResponse =
ActivityResponseDTO.Create(ActivityResponse.ExecuteClientActivity);
operationalStatus.CurrentActivityResponse.Body = "RunImmediately";
var operationsCrate = Crate.FromContent("Operational Status", operationalStatus);
Storage.Add(operationsCrate);
}
}
catch (Exception)
{
}
}
public static bool TryParseDocumentationDTO(this ActivityResponseDTO activityResponse, out DocumentationDTO documentationDTO)
{
return(TryParseBaseDTO <DocumentationDTO>(activityResponse, DocumentationPropertyName, out documentationDTO));
}
private ActivityUi CreateActivityUi()
{
var result = new ActivityUi
{
ActivityDescription = new TextArea
{
IsReadOnly = true,
Label = "",
Value = "<p>Process incoming DocuSign Envelope notifications if the following are true:</p>"
},
EnvelopeSentOption = new CheckBox
{
Label = "You sent a DocuSign Envelope",
Name = EnvelopeSentEventname,
Events = new List <ControlEvent> {
ControlEvent.RequestConfig
},
},
EnvelopeRecievedOption = new CheckBox
{
Label = "Someone received an Envelope you sent",
Name = EnvelopeRecievedEventName,
Events = new List <ControlEvent> {
ControlEvent.RequestConfig
}
},
EnvelopeSignedOption = new CheckBox
{
Label = "One of your Recipients signed an Envelope",
Name = RecipientSignedEventName,
Events = new List <ControlEvent> {
ControlEvent.RequestConfig
}
},
Recipient = new TextBox
{
Label = "",
Name = "RecipientValue",
Events = new List <ControlEvent> {
ControlEvent.RequestConfig
}
},
SentToRecipientOption = new RadioButtonOption
{
Selected = false,
Name = "recipient",
Value = "Was sent to a specific recipient"
},
TemplateList = new DropDownList
{
Label = "",
Name = "UpstreamCrate",
Events = new List <ControlEvent> {
ControlEvent.RequestConfig
},
ShowDocumentation = ActivityResponseDTO.CreateDocumentationResponse("Minicon", "ExplainMonitoring")
},
BasedOnTemplateOption = new RadioButtonOption
{
Selected = false,
Name = "template",
Value = "Was based on a specific template"
},
TemplateRecipientOptionSelector = new RadioButtonGroup
{
Label = "The envelope:",
GroupName = "TemplateRecipientPicker",
Name = "TemplateRecipientPicker",
Events = new List <ControlEvent> {
new ControlEvent("onChange", "requestConfig")
}
}
};
result.BasedOnTemplateOption.Controls = new List <ControlDefinitionDTO> {
result.TemplateList
};
result.SentToRecipientOption.Controls = new List <ControlDefinitionDTO> {
result.Recipient
};
result.TemplateRecipientOptionSelector.Radios = new List <RadioButtonOption> {
result.SentToRecipientOption, result.BasedOnTemplateOption
};
return(result);
}
/**********************************************************************************/
private bool ProcessActivityResponse(ActivityResponseDTO activityResponse, OperationalStateCM.ActivityExecutionPhase activityExecutionPhase, OperationalStateCM.StackFrame topFrame)
{
ActivityResponse opCode;
if (activityResponse == null)
{
return(true);
}
if (!Enum.TryParse(activityResponse.Type, out opCode))
{
return(true);
}
PlanNodeDO currentNode;
PlanNodeDO targetNode;
Guid id;
switch (opCode)
{
case ActivityResponse.Error:
var currentActivity = _uow.PlanRepository.GetById <ActivityDO>(topFrame.NodeId);
ErrorDTO error = activityResponse.TryParseErrorDTO(out error) ? error : null;
ActivityErrorCode errorCode;
if (Enum.TryParse(error?.ErrorCode, out errorCode) && errorCode == ActivityErrorCode.AUTH_TOKEN_NOT_PROVIDED_OR_INVALID)
{
throw new InvalidTokenRuntimeException(Mapper.Map <ActivityDO, ActivityDTO>(currentActivity),
Mapper.Map <ContainerDO, ContainerDTO>(_container),
error?.Message ?? string.Empty);
}
throw new ErrorResponseException(Mapper.Map <ContainerDO, ContainerDTO>(_container), error?.Message);
case ActivityResponse.ExecuteClientActivity:
break;
case ActivityResponse.LaunchAdditionalPlan:
LoadAndRunPlan(ExtractGuidParameter(activityResponse));
break;
case ActivityResponse.RequestTerminate:
_callStack.Clear();
EventManager.ProcessingTerminatedPerActivityResponse(_container, ActivityResponse.RequestTerminate);
return(false);
case ActivityResponse.RequestSuspend:
_container.State = State.Suspended;
if (activityExecutionPhase == OperationalStateCM.ActivityExecutionPhase.ProcessingChildren)
{
_callStack.PushFrame(topFrame);
}
else
{
// reset state of currently executed activity
topFrame.CurrentActivityExecutionPhase = OperationalStateCM.ActivityExecutionPhase.WasNotExecuted;
}
return(false);
case ActivityResponse.SkipChildren:
if (activityExecutionPhase == OperationalStateCM.ActivityExecutionPhase.WasNotExecuted)
{
_callStack.RemoveTopFrame();
}
break;
case ActivityResponse.JumpToSubplan:
id = ExtractGuidParameter(activityResponse);
targetNode = _uow.PlanRepository.GetById <PlanNodeDO>(id);
if (targetNode == null)
{
throw new InvalidOperationException($"Unable to find node {id}");
}
// @alexavrutin here: commented this block since this check broke Make a Decision in Kiosk mode
// when a new plan is being created.
// currentNode = _uow.PlanRepository.GetById<PlanNodeDO>(topFrame.NodeId);
//if (currentNode.RootPlanNodeId != targetNode.RootPlanNodeId)
//{
// throw new InvalidOperationException("Can't jump to the subplan from different plan. Instead, use Jump to Plan.");
//}
_callStack.Clear();
AddNodeForExecution(id);
break;
case ActivityResponse.JumpToActivity:
id = ExtractGuidParameter(activityResponse);
targetNode = _uow.PlanRepository.GetById <PlanNodeDO>(id);
if (targetNode == null)
{
throw new InvalidOperationException($"Unable to find node {id}");
}
currentNode = _uow.PlanRepository.GetById <PlanNodeDO>(topFrame.NodeId);
if (currentNode.RootPlanNodeId != targetNode.RootPlanNodeId)
{
throw new InvalidOperationException("Can't jump to the activity from different plan. Instead, use Jump to Plan.");
}
if (targetNode.ParentPlanNodeId == null && currentNode.ParentPlanNodeId == null && currentNode.Id != targetNode.Id)
{
throw new InvalidOperationException("Can't jump from the activities that has no parent to anywhere except the activity itself.");
}
if (targetNode.ParentPlanNodeId != currentNode.ParentPlanNodeId)
{
throw new InvalidOperationException("Can't jump to activity that has parent different from activity we are jumping from.");
}
// we are jumping after activity's Run
if (activityExecutionPhase == OperationalStateCM.ActivityExecutionPhase.WasNotExecuted)
{
// remove the frame representing the current activity from stack.
_callStack.RemoveTopFrame();
}
if (id == topFrame.NodeId)
{
// we want to pass current local data (from the topFrame) to the next activity we are calling.
_bypassData = topFrame.LocalData;
}
// this is root node. Just push new frame
if (_callStack.Count == 0 || currentNode.ParentPlanNode == null)
{
AddNodeForExecution(id);
}
else
{
// find activity that is preceeding the one we are jumping to.
// so the next iteration of run cycle will exectute the activity we are jumping to
var prevToJump = currentNode.ParentPlanNode.ChildNodes.OrderByDescending(x => x.Ordering).FirstOrDefault(x => x.Ordering < targetNode.Ordering);
_callStack.TopFrame.CurrentChildId = prevToJump?.Id;
}
break;
case ActivityResponse.CallAndReturn:
id = ExtractGuidParameter(activityResponse);
targetNode = _uow.PlanRepository.GetById <PlanNodeDO>(id);
if (targetNode == null)
{
throw new InvalidOperationException($"Unable to find node {id}");
}
currentNode = _uow.PlanRepository.GetById <PlanNodeDO>(topFrame.NodeId);
if (currentNode.RootPlanNodeId != targetNode.RootPlanNodeId)
{
throw new InvalidOperationException("Can't call the activity from different plan. Instead, use Jump to Plan.");
}
AddNodeForExecution(id);
break;
case ActivityResponse.Break:
if (activityExecutionPhase == OperationalStateCM.ActivityExecutionPhase.WasNotExecuted)
{
// we wan't to have an exception in case of the corrupted stack, so we don't merge this with check below
_callStack.RemoveTopFrame();
}
if (_callStack.Count > 0)
{
_callStack.RemoveTopFrame();
}
break;
}
return(true);
}
public static ActivityResponseDTO AddActivityDTO(this ActivityResponseDTO activityResponse, ActivityDTO activityDTO)
{
return(AddBaseDTO <ActivityDTO>(activityResponse, ActivityPropertyName, activityDTO));
}
public static bool TryParseResponseMessageDTO(this ActivityResponseDTO activityResponse, out ResponseMessageDTO responseMessageDTO)
{
return(TryParseBaseDTO <ResponseMessageDTO>(activityResponse, ResponseMessagePropertyName, out responseMessageDTO));
}
public static ActivityResponseDTO AddResponseMessageDTO(this ActivityResponseDTO activityResponse, ResponseMessageDTO responseMessageDTO)
{
return(AddBaseDTO <ResponseMessageDTO>(activityResponse, ResponseMessagePropertyName, responseMessageDTO));
}
public static ActivityResponseDTO AddDocumentationDTO(this ActivityResponseDTO activityResponse, DocumentationDTO documentationDTO)
{
return(AddBaseDTO <DocumentationDTO>(activityResponse, DocumentationPropertyName, documentationDTO));
}
/**********************************************************************************/
/// <summary>
/// returns error to hub
/// </summary>
/// <param name="errorCode"></param>
/// <param name="currentActivity">Activity where the error occured</param>
/// <param name="currentTerminal">Terminal where the error occured</param>
/// <param name="errorMessage"></param>
/// <param name="errorType"></param>
/// <returns></returns>
protected void RaiseError(string errorMessage, ErrorType errorType, ActivityErrorCode?errorCode = null, string currentActivity = null, string currentTerminal = null)
{
OperationalState.CurrentActivityErrorCode = errorCode;
OperationalState.CurrentActivityResponse = ActivityResponseDTO.Create(ActivityResponse.Error);
OperationalState.CurrentActivityResponse.AddErrorDTO(ErrorDTO.Create(errorMessage, errorType, errorCode.ToString(), null, currentActivity, currentTerminal));
}
