"type": "ms.vss-endpoint.service-endpoint-type"

另外,我想创建一个自定义的Release Artifact Source：

“type”: “ms.vss-releaseartifact.release-artifact-type”

在this documentation之后,我目前的努力是使用外部API填充Artifact Source下的字段.我在下面的’resultSelector’和’resultTemplate’中尝试了很多模式,但无法找到适合我的模式.

在我的示例中,我想在json响应中的’builds’下获取所有’uri’值,并将它们呈现在Artifact Source的’deFinition’inputDescriptor中.我的所有尝试都导致了一个空的组合框,即使我可以看到请求达到所需的API.

json我想解析到组合框：

{
"builds": [
    {
        "uri": "/build1","lastStarted": "2018-11-07T13:12:42.547+0000"
    },{
        "uri": "/build2","lastStarted": "2018-11-09T15:40:30.315+0000"
    },{
        "uri": "/build3","lastStarted": "2018-11-12T17:46:24.805+0000"
    }
],"uri": "https://<server-address>/api/build"
}

你能帮我创建一个Mustache模式来检索上面的“uri”值吗？
我试过了：

$.builds[*].uri

这似乎不起作用.

以下是一些有用的信息.

服务端点的数据源：

"dataSources": [
                {
                  "name": "TestConnection","endpointUrl": "{{endpoint.url}}/api/plugins","resourceUrl": "","resultSelector": "jsonpath:$.values[*]","headers": [],"authenticationScheme": null
                },{
                  "name": "BuildNames","endpointUrl": "{{endpoint.url}}/api/build","resultSelector": "jsonpath:$.builds[*].uri"
                },{
                  "name": "BuildNumbers","endpointUrl": "{{endpoint.url}}/api/builds/{{deFinition}}","resultSelector": "jsonpath:$.buildsNumbers[*].uri"
                }
]

神器来源：

"inputDescriptors": [
     {
       "id": "connection","name": "Artifactory service","inputMode": "combo","isConfidential": false,"hasDynamicValueinformation": true,"validation": {
            "isrequired": true,"dataType": "string","maxLength": 300
       }
     },{
       "id": "deFinition","name": "deFinition","description": "Name of the build.","dependencyInputIds": [
             "connection"
       ],"maxLength": 300
        }
      },{
        "id": "buildNumber","name": "Build Number","description": "Number of the build.","dependencyInputIds": [
            "connection"
         ],"validation": {
             "isrequired": true,"maxLength": 300
        }
       }
],"dataSourceBindings": [
   {
       "target": "deFinition","dataSourceName": "BuildNames","resultTemplate": "{ Value : \"{{uri}}\",displayValue : \"{{uri}}\" }"
    },{
       "target": "versions","dataSourceName": "BuildNumbers",{
       "target": "latestVersion",{
       "target": "artifactDetails","resultTemplate": "{ Name: \"{{version}}\",downloadUrl : \"{{endpoint.url}}\" }"
    },{
       "target": "buildNumber",displayValue : \"{{uri}}\" }"
    }
  ]
 }

我们将非常感谢您提供的任何帮助.

数据源：

{
  "name": "BuildNames","resultSelector": "jsonpath:$.builds[*]"
}

dataSourceBindings：

{
  "target": "deFinition","resultTemplate": "{ \"Value\" : \"{{{uri}}}\",\"displayValue\" : \"{{{uri}}}\" }"
}

public static void main(String[] args) {

        AmazonDynamoDBClient client = new AmazonDynamoDBClient();
        client.setEndpoint("http://localhost:8000");
        DynamoDB dynamoDB = new DynamoDB(client);

        Table table = dynamoDB.getTable("Movies");

        ScanSpec scanSpec = new ScanSpec()
            .withProjectionExpression("#yr,title,info.rating")
            .withFilterExpression("#yr between :start_yr and :end_yr")
            .withNameMap(new NameMap().with("#yr","year"))
            .withValueMap(new ValueMap().withNumber(":start_yr",1950).withNumber(":end_yr",1959));

        ItemCollection<ScanOutcome> items = table.scan(scanSpec);

        Iterator<Item> iter = items.iterator();
        while (iter.hasNext()) {
            Item item = iter.next();
            System.out.println(item.toString());
        }
    }

private static void findProductsForPriceLessthanZero() {

    Table table = dynamoDB.getTable(tableName);

    Map<String,Object> expressionAttributeValues = new HashMap<String,Object>();
    expressionAttributeValues.put(":pr",100);

    ItemCollection<ScanOutcome> items = table.scan(
        "Price < :pr",//FilterExpression
        "Id,Title,ProductCategory,Price",//ProjectionExpression
        null,//ExpressionAttributeNames - not used in this example 
        expressionAttributeValues);

    System.out.println("Scan of " + tableName + " for items with a price less than 100.");
    Iterator<Item> iterator = items.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next().toJSONPretty());
    }    
}

private static void findRepliesUsingAFilterExpression(String forumName,String threadSubject) {

        Table table = dynamoDB.getTable(tableName);

        String replyId = forumName + "#" + threadSubject;

        QuerySpec spec = new QuerySpec()
            .withProjectionExpression("Message,ReplyDateTime,PostedBy")
            .withKeyConditionExpression("Id = :v_id")
            .withFilterExpression("PostedBy = :v_postedby")
            .withValueMap(new ValueMap()
                .withString(":v_id",replyId)
                .withString(":v_postedby","User B"));

        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesUsingAFilterExpression results:");
        Iterator<Item> iterator = items.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toJSONPretty());
        }    
     }

@Override public boolean queryRelationExists(String relationHashKey,String relationRangeKey) {

    Table table = dynamoDB.getTable(this.groupGraphTableName);

    QuerySpec querySpec = new QuerySpec()
        .withKeyConditionExpression("subject = :k_subject and object_relation = :k_object_relation")
        .withValueMap(new ValueMap()
            .withString(":k_subject",relationHashKey)
            .withString(":k_object_relation",relationRangeKey)
        )
        .withMaxResultSize(1)
        .withConsistentRead(true);

    DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("queryRelation",() -> queryTable(table,querySpec),() -> {
          throw new RuntimeException("queryRelation");
        },dynamodbnamespaceGraphQueryHystrix,metrics);

    // can't use getLastLowLevelResult directly; it's false unless the outcome is iterated first :|
    return cmd.execute().iterator().hasNext();
  }

@Override public Optional<Group> loadByKey(String key) {
  Table table = dynamoDB.getTable(this.groupTableName);

  QuerySpec querySpec = new QuerySpec()
      .withKeyConditionExpression(HASH_KEY + " = :k_app_key")
      .withValueMap(new ValueMap()
          .withString(":k_app_key",key)
      )
      .withMaxResultSize(1)
      .withConsistentRead(true);

  DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("loadByKey",() -> {
        throw new RuntimeException("loadByKey");
      },metrics);

  final ItemCollection<QueryOutcome> items = cmd.execute();
  final IteratorSupport<Item,QueryOutcome> iterator = items.iterator();
  if (iterator.hasNext()) {
    return Optional.of(GroupSupport.toGroup(iterator.next().getString("json")));
  }

  return Optional.empty();
}

@Override public List<Feature> loadFeatures(String group) {
  logger.info("{}",kvp("op","loadFeatures","group",group));
  List<Feature> features = Lists.newArrayList();

  Table table = dynamoDB.getTable(featureTableName);

  QuerySpec querySpec = new QuerySpec()
      .withKeyConditionExpression(HASH_KEY + " = :k_" + HASH_KEY)
      .withValueMap(new ValueMap().withString(":k_" + HASH_KEY,group))
      .withConsistentRead(true);

  DynamoDbCommand<ItemCollection<QueryOutcome>> cmd = new DynamoDbCommand<>("loadFeatures",() -> {
        throw new RuntimeException("loadFeatureById");
      },hystrixReadConfiguration,metrics);

  ItemCollection<QueryOutcome> items = cmd.execute();

  for (Page<Item,QueryOutcome> page : items.pages()) {
    page.forEach(item -> features.add(FeatureSupport.toFeature(item.getString("json"))));
  }

  return features;
}

private ScanOutcome scan(ScanSpec scanSpec,PageIterator pageIterator) {
    if ( null == _convertMarker ) {
        throw new IllegalStateException("Index must first be initialized with ConvertMarker");
    }
    if ( pageIterator.getPageSize() <= 0 ) {
        return new ScanOutcome(new ScanResult());
    }
    ItemCollection<ScanOutcome> itemCollection =
        maybeBackoff(true,() -> _scan.scan(withMarker(scanSpec,pageIterator)));

    if ( null != itemCollection ) {
        Iterator<Page<Item,ScanOutcome>> iterator = itemCollection.pages().iterator();
        if ( iterator.hasNext() ) {
            ScanOutcome outcome = maybeBackoff(true,() -> iterator.next().getLowLevelResult());
            ScanResult result = outcome.getScanResult();
            Map<String,AttributeValue> lastKey = result.getLastEvaluatedKey();
            if ( null != lastKey && ! lastKey.isEmpty() ) {
                pageIterator.setMarker(toMarker(lastKey,false));
            } else {
                pageIterator.setMarker(null);
            }
            return outcome;
        }
    }
    pageIterator.setMarker(null);
    return new ScanOutcome(new ScanResult());
}

private QueryOutcome query(Object hk,QuerySpec querySpec,PageIterator pageIterator) {
    if ( null == _convertMarker ) {
        throw new IllegalStateException("Index must first be initialized with ConvertMarker");
    }
    if ( pageIterator.getPageSize() <= 0 ) {
        return new QueryOutcome(new QueryResult());
    }
    ItemCollection<QueryOutcome> itemCollection =
        maybeBackoff(true,() ->
                     _query.query(withMarker(querySpec.withHashKey(_hkName,hk),pageIterator,hk)));

    if ( null != itemCollection ) {
        Iterator<Page<Item,QueryOutcome>> iterator = itemCollection.pages().iterator();
        if ( iterator.hasNext() ) {
            QueryOutcome outcome = maybeBackoff(true,() -> iterator.next().getLowLevelResult());
            QueryResult result = outcome.getQueryResult();
            if ( null != pageIterator.getMarker() && null != result.getItems() && result.getItems().size() > 0 ) {
                pageIterator.setPrevMarker(toMarker(result.getItems().get(0),true));
            } else {
                pageIterator.setPrevMarker(null);
            }
            Map<String,true));
            } else {
                pageIterator.setMarker(null);
            }
            return outcome;
        }
    }
    pageIterator.setPrevMarker(null);
    pageIterator.setMarker(null);
    return new QueryOutcome(new QueryResult());
}

private static void findRepliesInLast15DaysWithConfig(
    String tableName,String forumName,String threadSubject) {

    String replyId = forumName + "#" + threadSubject;
    long twoWeeksAgoMilli = (new Date()).getTime()
        - (15L * 24L * 60L * 60L * 1000L);
    Date twoWeeksAgo = new Date();
    twoWeeksAgo.setTime(twoWeeksAgoMilli);
    SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
    String twoWeeksAgoStr = df.format(twoWeeksAgo);

    Table table = dynamoDB.getTable(tableName);

    QuerySpec querySpec = new QuerySpec()
        .withKeyConditionExpression("Id = :v1 and ReplyDateTime > :v2")
        .withValueMap(new ValueMap()
            .withString(":v1",replyId)
            .withString(":v2",twoWeeksAgoStr))
        .withProjectionExpression("Message,PostedBy");

    ItemCollection<QueryOutcome> items = table.query(querySpec);
    Iterator<Item> iterator = items.iterator();

    System.out.println("Query: printing results...");

    while (iterator.hasNext()) {
        System.out.println(iterator.next().toJSONPretty());
    }
}

@Override
public void run() {
    System.out.println("Scanning " + tableName + " segment " + segment + " out of " + totalSegments + " segments " + itemLimit + " items at a time...");
    int totalScannedItemCount = 0;

    Table table = dynamoDB.getTable(tableName);

    try {
        ScanSpec spec = new ScanSpec()
            .withMaxResultSize(itemLimit)
            .withTotalSegments(totalSegments)
            .withSegment(segment);

        ItemCollection<ScanOutcome> items = table.scan(spec);
        Iterator<Item> iterator = items.iterator();

        Item currentItem = null;
        while (iterator.hasNext()) {
            totalScannedItemCount++;
            currentItem = iterator.next();
            System.out.println(currentItem.toString());
        }    

    } catch (Exception e) {
        System.err.println(e.getMessage());
    } finally {
        System.out.println("Scanned " + totalScannedItemCount 
            + " items from segment " + segment + " out of " 
            + totalSegments + " of " + tableName);
    }
}

private static void findRepliesForAThreadSpecifyOptionalLimit(String forumName,String threadSubject) {

        Table table = dynamoDB.getTable(tableName);

        String replyId = forumName + "#" + threadSubject;   

        QuerySpec spec = new QuerySpec()
            .withKeyConditionExpression("Id = :v_id")
            .withValueMap(new ValueMap()
                .withString(":v_id",replyId))
            .withMaxPageSize(1);

        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesForAThreadSpecifyOptionalLimit results:");

        // Process each page of results
        int pageNum = 0;
        for (Page<Item,QueryOutcome> page : items.pages()) {

            System.out.println("\nPage: " + ++pageNum);

            // Process each item on the current page
            Iterator<Item> item = page.iterator();
            while (item.hasNext()) {
                System.out.println(item.next().toJSONPretty());
            }
        }
    }

private static void findRepliesInLast15DaysWithConfig(String forumName,String threadSubject) {

        Table table = dynamoDB.getTable(tableName);

        long twoWeeksAgoMilli = (new Date()).getTime() - (15L*24L*60L*60L*1000L);
        Date twoWeeksAgo = new Date();
        twoWeeksAgo.setTime(twoWeeksAgoMilli);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        String twoWeeksAgoStr = df.format(twoWeeksAgo);

        String replyId = forumName + "#" + threadSubject;

        QuerySpec spec = new QuerySpec()
            .withProjectionExpression("Message,PostedBy")
            .withKeyConditionExpression("Id = :v_id and ReplyDateTime <= :v_reply_dt_tm")
            .withValueMap(new ValueMap()
                .withString(":v_id",replyId)
                .withString(":v_reply_dt_tm",twoWeeksAgoStr));

        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesInLast15DaysWithConfig results:");
        Iterator<Item> iterator = items.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toJSONPretty());
        }

    }

private static void findRepliesPostedWithinTimePeriod(String forumName,String threadSubject) {

        Table table = dynamoDB.getTable(tableName);

        long startDateMilli = (new Date()).getTime() - (15L*24L*60L*60L*1000L); 
        long endDateMilli = (new Date()).getTime() - (5L*24L*60L*60L*1000L);    
        java.text.SimpleDateFormat df = new java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        String startDate = df.format(startDateMilli);
        String endDate = df.format(endDateMilli);

        String replyId = forumName + "#" + threadSubject;

        QuerySpec spec = new QuerySpec()
            .withProjectionExpression("Message,PostedBy")
            .withKeyConditionExpression("Id = :v_id and ReplyDateTime between :v_start_dt and :v_end_dt")
            .withValueMap(new ValueMap()
                .withString(":v_id",replyId)
                .withString(":v_start_dt",startDate)
                .withString(":v_end_dt",endDate));

        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesPostedWithinTimePeriod results:");
        Iterator<Item> iterator = items.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toJSONPretty());
        }    
    }

private ItemCollection<QueryOutcome> queryTable(Table table,QuerySpec querySpec) {
  return table.query(querySpec);
}

private ItemCollection<QueryOutcome> queryTable(Table table,QuerySpec querySpec) {
  return table.query(querySpec);
}

public static void main(String[] args)  {

        AmazonDynamoDBClient client = new AmazonDynamoDBClient();
        client.setEndpoint("http://localhost:8000");
        DynamoDB dynamoDB = new DynamoDB(client);

        Table table = dynamoDB.getTable("Movies");

        HashMap<String,String> nameMap = new HashMap<String,String>();
        nameMap.put("#yr","year"); 

        HashMap<String,Object> valueMap = new HashMap<String,Object>();
        valueMap.put(":yyyy",1985);

        QuerySpec querySpec = new QuerySpec()
            .withKeyConditionExpression("#yr = :yyyy")
            .withNameMap(new NameMap().with("#yr","year"))
            .withValueMap(valueMap);

        ItemCollection<QueryOutcome> items = table.query(querySpec);

        Iterator<Item> iterator = items.iterator();
        Item item = null;

        System.out.println("Movies from 1985");
        while (iterator.hasNext()) {
            item = iterator.next();
            System.out.println(item.getNumber("year") + ": " + item.getString("title"));
        }

        valueMap.put(":yyyy",1992);
        valueMap.put(":letter1","A");
        valueMap.put(":letter2","L");

        querySpec
            .withProjectionExpression("#yr,info.genres,info.actors[0]")
            .withKeyConditionExpression("#yr = :yyyy and title between :letter1 and :letter2")
            .withNameMap(nameMap)
            .withValueMap(valueMap);

        items = table.query(querySpec);
        iterator = items.iterator();

        System.out.println("Movies from 1992 - titles A-L,with genres and lead actor");
        while (iterator.hasNext()) {
            item = iterator.next();
            System.out.println(item.toString());
        }

    }

private static void findRepliesForAThread(String forumName,String threadSubject) {

        Table table = dynamoDB.getTable(tableName);

        String replyId = forumName + "#" + threadSubject;

        QuerySpec spec = new QuerySpec()
            .withKeyConditionExpression("Id = :v_id")
            .withValueMap(new ValueMap()
                .withString(":v_id",replyId));

        ItemCollection<QueryOutcome> items = table.query(spec);

        System.out.println("\nfindRepliesForAThread results:");

        Iterator<Item> iterator = items.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toJSONPretty());
        }

    }

public static void queryIndex(String indexName) {

    Table table = dynamoDB.getTable(tableName);

    System.out.println
    ("\n***********************************************************\n");
    System.out.print("Querying index " + indexName + "...");

    Index index = table.getIndex(indexName);

    ItemCollection<QueryOutcome> items = null;

    QuerySpec querySpec = new QuerySpec();

    if (indexName == "CreateDateIndex") {
        System.out.println("Issues filed on 2013-11-01");
        querySpec.withKeyConditionExpression("CreateDate = :v_date and begins_with(IssueId,:v_issue)")
            .withValueMap(new ValueMap()
                .withString(":v_date","2013-11-01")
                .withString(":v_issue","A-"));
        items = index.query(querySpec);
    } else if (indexName == "TitleIndex") {
        System.out.println("Compilation errors");
        querySpec.withKeyConditionExpression("Title = :v_title and begins_with(IssueId,:v_issue)")
            .withValueMap(new ValueMap()
                .withString(":v_title","Compilation error")
                .withString(":v_issue","A-"));
        items = index.query(querySpec);
    } else if (indexName == "DueDateIndex") {
        System.out.println("Items that are due on 2013-11-30");
        querySpec.withKeyConditionExpression("DueDate = :v_date")
            .withValueMap(new ValueMap()
                .withString(":v_date","2013-11-30"));
        items = index.query(querySpec);
    } else {
        System.out.println("\nNo valid index name provided");
        return;
    }

    Iterator<Item> iterator = items.iterator();

    System.out.println("Query: printing results...");

    while (iterator.hasNext()) {
        System.out.println(iterator.next().toJSONPretty());
    }


}