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