private void AssertCrateTypes(ICrateStorage crateStorage)
{
Assert.AreEqual(2, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count(x => x.Label == "Configuration_Controls"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "Available Groups"));
}
private void AssertCrateTypes(ICrateStorage crateStorage)
{
Assert.AreEqual(2, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
Assert.AreEqual(1, crateStorage.CratesOfType <EventSubscriptionCM>().Count());
}
private void AssertConfigureCrate(ICrateStorage crateStorage)
{
Assert.AreEqual(2, crateStorage.Count, "Crate storage count is not equal to 2");
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count(), "StandardConfigurationControlsCM count is not 1");
Assert.AreEqual(1, crateStorage.CratesOfType <CrateDescriptionCM>().Count(), "FieldDescriptionsCM count is not 1");
AssertConfigureControls(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single());
var fieldDescriptions = crateStorage.CratesOfType <CrateDescriptionCM>().Single();
Assert.AreEqual("Runtime Available Crates", fieldDescriptions.Label, "Monitor Atlassian Runtime Fields labeled FieldDescriptionsCM was not found");
Assert.AreEqual(2, fieldDescriptions.Content.CrateDescriptions.Count(), "CrateDescriptions count is not 2");
var crateDescription = fieldDescriptions.Content.CrateDescriptions.Where(t => t.ManifestType.Equals("Standard Payload Data"));
var fields = crateDescription.Single().Fields;
Assert.AreEqual("Monitor Atlassian Runtime Fields", crateDescription.Single().Label, "Monitor Atlassian Runtime Fields labeled CrateDescription was not found");
Assert.AreEqual(9, crateDescription.Single().Fields.Count, "Published runtime field count is not 9");
Assert.IsTrue(fields.Exists(x => x.Name == IssueKey), "IssueKey is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == ProjectName), "ProjectName is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssueResolution), "IssueResolution is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssuePriority), "IssuePriority is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssueAssignee), "IssueAssignee is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssueSummary), "IssueSummary is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssueStatus), "IssueStatus is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == IssueDescription), "IssueDescription is not signalled");
Assert.IsTrue(fields.Exists(x => x.Name == EventType), "EventType is not signalled");
}
public TextSourceMappingBehavior(ICrateStorage crateStorage, string behaviorName, bool requestUpstream)
: base(crateStorage, behaviorName)
{
_reqeustUpstream = requestUpstream;
//BehaviorPrefix = "TextSourceMappingBehavior-";
}
protected bool IsNewTemplateIdChoosen(ICrateStorage crateStorage, string docusignTemplateId)
{
// Get previous DocuSign Template Id
string previousTemplateId = "";
var previousTemplateIdCrate = crateStorage.FirstCrateOrDefault <StandardPayloadDataCM>(a => a.Label == "ChosenTemplateId");
if (previousTemplateIdCrate != null)
{
previousTemplateId = previousTemplateIdCrate.Get <StandardPayloadDataCM>().GetValueOrDefault("TemplateId");
}
crateStorage.ReplaceByLabel(Crate.FromContent("ChosenTemplateId", new StandardPayloadDataCM()
{
PayloadObjects = new List <PayloadObjectDTO>()
{
new PayloadObjectDTO()
{
PayloadObject = new List <KeyValueDTO>()
{
new KeyValueDTO("TemplateId", docusignTemplateId)
}
}
}
}));
return(docusignTemplateId != previousTemplateId);
}
/**********************************************************************************/
/// <summary>
/// Add collection of crates to storage
/// </summary>
/// <param name="crates"></param>
public static void AddRange(this ICrateStorage storage, IEnumerable <Crate> crates)
{
foreach (var crate in crates)
{
storage.Add(crate);
}
}
private Crate <StandardQueryCM> ExtractQueryCrate(ICrateStorage storage)
{
var configurationControls = storage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.SingleOrDefault();
if (configurationControls == null)
{
throw new ApplicationException("Action was not configured correctly");
}
var actionUi = new ActivityUi();
actionUi.ClonePropertiesFrom(configurationControls);
var criteria = JsonConvert.DeserializeObject <List <FilterConditionDTO> >(
actionUi.QueryBuilder.Value
);
// This is weird to use query's name as the way to address MT type.
// MT type has unique ID that should be used for this reason. Query name is something that is displayed to user. It should not contain any internal data.
var queryCM = new StandardQueryCM(
new QueryDTO()
{
Name = MT.DocuSignEnvelope.GetEnumDisplayName(),
Criteria = criteria
}
);
return(Crate <StandardQueryCM> .FromContent(QueryCrateLabel, queryCM));
}
public static void AssertPayloadHasError(ICrateStorage storage)
{
var operationalStateCM = storage.CrateContentsOfType <OperationalStateCM>().Single();
ErrorDTO errorMessage;
Assert.IsTrue(operationalStateCM.CurrentActivityResponse.TryParseErrorDTO(out errorMessage));
}
private void AssertConfigureCrate(ICrateStorage crateStorage)
{
Assert.AreEqual(1, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
AssertConfigureControls(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single());
}
//This method returns one crate of the specified Manifest Type from the payload
public T GetByManifest <T>(PayloadDTO payloadDTO) where T : Manifest
{
ICrateStorage curCrateStorage = FromDto(payloadDTO.CrateStorage);
var curCrate = curCrateStorage.CratesOfType <T>().Single().Content;
return(curCrate);
}
/// <summary>
/// Returns a copy of AcvitityUI for the given activity
/// </summary>
public static TActivityUi GetReadonlyActivityUi <TActivityUi>(this ICrateStorage storage) where TActivityUi : StandardConfigurationControlsCM, new()
{
var controls = storage.FirstCrateOrDefault <StandardConfigurationControlsCM>()?.Content;
var activityUi = new TActivityUi().ClonePropertiesFrom(controls) as TActivityUi;
activityUi.RestoreDynamicControlsFrom(controls);
return(activityUi);
}
/**********************************************************************************/
public static Crate <T> Add <T>(this ICrateStorage storage, string label, T content)
{
var crate = Crate.FromContent(label, content);
storage.Add(crate);
return(crate);
}
private void AssertCrateTypes(ICrateStorage crateStorage)
{
Assert.AreEqual(1, crateStorage.Count,
"There should be only one crate storage in initial and follow up configuration of Write To Log action.");
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count(),
"The target URL text box is missing in the configuration of Write To Log action.");
}
private void AssertCrateTypes(ICrateStorage crateStorage)
{
Assert.AreEqual(5, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "AvailableTemplates"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "AvailableHandlers"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "AvailableRecipientEvents"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "AvailableRunTimeDataFields"));
}
public static void AssertPayloadHasAuthenticationError(ICrateStorage storage)
{
var operationalStateCM = storage.CrateContentsOfType <OperationalStateCM>().Single();
ErrorDTO errorMessage;
operationalStateCM.CurrentActivityResponse.TryParseErrorDTO(out errorMessage);
Assert.AreEqual(ActivityResponse.Error.ToString(), operationalStateCM.CurrentActivityResponse.Type);
Assert.AreEqual(ActivityErrorCode.AUTH_TOKEN_NOT_PROVIDED_OR_INVALID.ToString(), errorMessage.ErrorCode);
Assert.AreEqual("No AuthToken provided.", errorMessage.Message);
}
private void ValidateConfigurationControls(ICrateStorage crateStorage)
{
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single();
Assert.AreEqual(ControlTypes.TextArea, controls.Controls[0].Type);
Assert.AreEqual(ControlTypes.QueryBuilder, controls.Controls[1].Type);
Assert.AreEqual("QueryBuilder", controls.Controls[1].Name);
Assert.AreEqual(ControlTypes.Button, controls.Controls[2].Type);
Assert.AreEqual("Continue", controls.Controls[2].Name);
}
private Crate FindCrateToProcess(ICrateStorage payloadStorage)
{
var selectedCrateDescription = ConfigurationControls
.ReportSelector
.CrateDescriptions.Single(c => c.Selected);
return(payloadStorage
.FirstOrDefault(c => c.ManifestType.Type == selectedCrateDescription.ManifestType &&
c.Label == selectedCrateDescription.Label));
}
private void AssertFollowUpCrateTypes(ICrateStorage crateStorage)
{
Assert.AreEqual(4, crateStorage.Count);
Assert.AreEqual(3, crateStorage.CratesOfType <KeyValueListCM>().Count());
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "Sql Table Definitions"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "Sql Column Types"));
Assert.AreEqual(1, crateStorage.CratesOfType <KeyValueListCM>().Count(x => x.Label == "Sql Connection String"));
}
public Crate GetValue(ICrateStorage crateStorage)
{
var selectedCrate = CrateDescriptions?.FirstOrDefault(x => x.Selected);
if (selectedCrate == null)
{
return(null);
}
return(crateStorage.FirstOrDefault(x => x.Label == selectedCrate.Label && x.ManifestType.Type == selectedCrate.ManifestType));
}
/**********************************************************************************/
private OperationalStateCM GetOperationalState(ICrateStorage crateStorage)
{
var operationalState = crateStorage.CrateContentsOfType <OperationalStateCM>().FirstOrDefault();
if (operationalState == null)
{
throw new Exception("OperationalState was not found within the container payload.");
}
return(operationalState);
}
/**********************************************************************************/
/// <summary>
/// Remove all crates with the content of given type
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static int Remove <T>(this ICrateStorage storage)
{
CrateManifestType manifestType;
if (!ManifestTypeCache.TryResolveManifest(typeof(T), out manifestType))
{
return(0);
}
return(storage.Remove(x => x.ManifestType == manifestType));
}
public void RestoreCustomFields(ICrateStorage crateStorage)
{
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().First();
foreach (var control in controls.Controls)
{
if (control.Name.StartsWith("CustomField_"))
{
Controls.Add(control);
}
}
}
private void AssertCrateTypes(ICrateStorage crateStorage, bool expectValidationErrors = false)
{
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count(), "Missing configuration controls");
Assert.AreEqual(1, crateStorage.CratesOfType <EventSubscriptionCM>().Count(x => x.Label == "Standard Event Subscriptions"), "Missing Standard Event Subscriptions");
if (expectValidationErrors)
{
Assert.AreEqual(1, crateStorage.CratesOfType <ValidationResultsCM>().Count(x => x.Content.HasErrors), "Missing validation errors");
}
Assert.AreEqual(expectValidationErrors ? 3 : 2, crateStorage.Count, "Unexpected crates present");
}
private void AddFileDescriptionToStorage(ICrateStorage storage, List <ControlDefinitionDTO> file_pickers)
{
int labelless_filepickers = 0;
storage.RemoveByManifestId((int)MT.StandardFileHandle);
foreach (var filepicker in file_pickers)
{
string crate_label = GetFileDescriptionLabel(filepicker, labelless_filepickers);
storage.Add(Crate.FromContent(crate_label, new StandardFileDescriptionCM()));
}
}
private void InitializeAccessors(MemberInfo memberInfo, object instance, Func <object, ICrateStorage> readConverter, Func <ICrateStorage, object> writeConverter)
{
if (memberInfo is FieldInfo)
{
_crateStorage = readConverter(((FieldInfo)memberInfo).GetValue(instance));
_setValue = x => ((FieldInfo)memberInfo).SetValue(instance, writeConverter(x));
}
else if (memberInfo is PropertyInfo)
{
_crateStorage = readConverter(((PropertyInfo)memberInfo).GetValue(instance));
_setValue = x => ((PropertyInfo)memberInfo).SetValue(instance, writeConverter(x));
}
}
private List <KeyValueDTO> ExtractPayloadFields(ICrateStorage currentPayload)
{
var eventReportMS = currentPayload.CrateContentsOfType <EventReportCM>().SingleOrDefault();
var eventFieldsCrate = eventReportMS?.EventPayload.SingleOrDefault();
if (eventFieldsCrate == null)
{
return(null);
}
return(eventReportMS.EventPayload.CrateContentsOfType <StandardPayloadDataCM>().SelectMany(x => x.AllValues()).ToList());
}
public EnhancedValidationManager(TerminalActivity <TActivityUi> activity, ICrateStorage payload)
: base(payload)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
_activityUi = activity.ActivityUI;
_ownerNameByControl = new Dictionary <IControlDefinition, string>();
FillOwnerByControl();
}
protected static object GetValue(ICrateStorage payloadStorage, FieldDTO fieldToMatch)
{
if (payloadStorage == null)
{
throw new ArgumentNullException(nameof(payloadStorage));
}
if (fieldToMatch == null)
{
throw new ArgumentNullException(nameof(fieldToMatch));
}
if (string.IsNullOrWhiteSpace(fieldToMatch.Name))
{
return(null);
}
IEnumerable <Crate> filteredCrates = payloadStorage;
if (!string.IsNullOrWhiteSpace(fieldToMatch.SourceActivityId))
{
filteredCrates = filteredCrates.Where(x => x.SourceActivityId == fieldToMatch.SourceActivityId);
}
if (!string.IsNullOrEmpty(fieldToMatch.SourceCrateLabel))
{
filteredCrates = filteredCrates.Where(x => x.Label == fieldToMatch.SourceCrateLabel);
}
if (fieldToMatch.SourceCrateManifest != CrateManifestType.Any && fieldToMatch.SourceCrateManifest != CrateManifestType.Unknown)
{
filteredCrates = filteredCrates.Where(x => x.ManifestType.Equals(fieldToMatch.SourceCrateManifest));
}
//iterate through found crates and search for the field with the specified key
foreach (var crate in filteredCrates)
{
// skip system crates
if (crate.IsOfType <OperationalStateCM>() || crate.IsOfType <CrateDescriptionCM>() || crate.IsOfType <ValidationResultsCM>())
{
continue;
}
var foundValue = GetValue(crate, fieldToMatch.Name);
if (foundValue != null)
{
return(foundValue);
}
}
return(null);
}
public List <RadioButtonGroup> GetValues(ICrateStorage payload = null)
{
var controlsCM = GetOrCreateStandardConfigurationControlsCM();
var radioButtonGroups = controlsCM
.Controls.Where(IsBehaviorControl).OfType <RadioButtonGroup>();
foreach (var rbGroup in radioButtonGroups)
{
rbGroup.GroupName = GetFieldId(rbGroup);
}
return(radioButtonGroups.ToList());
}
public bool CanGetValue(ICrateStorage payloadCrateStorage)
{
if (HasSpecificValue)
{
return(true);
}
if (ValueSource == UpstreamValueSrouce && payloadCrateStorage == null)
{
return(false);
}
return(true);
}
