Allow fact template to flatten or keep key/value structure

awx/ui/static/js/shared/format-epoch/format-epoch.filter.js

@@ -0,0 +1,16 @@
+export default
+[   'moment',
+    function(moment) {
+        return function(seconds, formatStr) {
+            if (!formatStr) {
+                formatStr = 'll LT';
+            }
+
+            var millis = seconds * 1000;
+
+            return moment(millis).format(formatStr);
+        };
+    }
+];
+
+

awx/ui/static/js/shared/format-epoch/main.js

@@ -0,0 +1,9 @@
+import formatEpoch from './format-epoch.filter';
+import moment from 'tower/shared/moment/main';
+
+export default
+    angular.module('formatEpoch',
+                   [    moment.name
+                   ])
+        .filter('formatEpoch', formatEpoch);
+

awx/ui/static/js/system-tracking/compare-facts.js

@@ -9,26 +9,39 @@ import compareFlatFacts from './compare-facts/flat';
 import FactTemplate from './compare-facts/fact-template';
 
 export function compareFacts(module, facts) {
+
+
+    var renderOptions = _.merge({}, module);
+
     // If the module has a template or includes a list of keys to display,
     // then perform a flat comparison, otherwise assume nested
     //
-    if (module.factTemplate || module.nameKey) {
+    if (renderOptions.factTemplate || renderOptions.nameKey) {
         // For flat structures we compare left-to-right, then right-to-left to
         // make sure we get a good comparison between both hosts
-        var compare = _.partialRight(compareFlatFacts,
-                                     module.nameKey,
-                                     module.compareKey,
-                                     new FactTemplate(module.factTemplate));
 
-        var leftToRight = compare(facts[0], facts[1]);
-        var rightToLeft = compare(facts[1], facts[0]);
+        if (_.isPlainObject(renderOptions.factTemplate)) {
+            renderOptions.factTemplate =
+                _.mapValues(renderOptions.factTemplate, function(template) {
+                    if (typeof template === 'string' || typeof template === 'function') {
+                        return new FactTemplate(template);
+                    } else {
+                        return template;
+                    }
+                });
+        } else {
+            renderOptions.factTemplate = new FactTemplate(renderOptions.factTemplate);
+        }
+
+        var leftToRight = compareFlatFacts(facts[0], facts[1], renderOptions);
+        var rightToLeft = compareFlatFacts(facts[1], facts[0], renderOptions);
 
         return _(leftToRight)
                     .concat(rightToLeft)
                     .unique('displayKeyPath')
                     .thru(function(result) {
                         return  {   factData: result,
-                                    isNestedDisplay: _.isUndefined(module.factTemplate)
+                                    isNestedDisplay: _.isPlainObject(renderOptions.factTemplate)
                                 };
                     })
                     .value();

awx/ui/static/js/system-tracking/compare-facts/fact-template.js

@@ -0,0 +1,33 @@
+import stringFilters from 'tower/shared/string-filters/main';
+import formatEpoch from 'tower/shared/format-epoch/main';
+
+var $injector = angular.injector(['ng', stringFilters.name, formatEpoch.name]);
+var $interpolate = $injector.get('$interpolate');
+
+function FactTemplate(templateString) {
+    this.templateString = templateString;
+}
+
+function loadFactTemplate(factTemplate, fact) {
+    if (_.isFunction(factTemplate)) {
+        return factTemplate(fact);
+    } else {
+        return factTemplate;
+    }
+}
+
+FactTemplate.prototype.render = function(factData) {
+
+    if (_.isUndefined(factData) || _.isEmpty(factData)) {
+        return 'absent';
+    }
+
+    var template = loadFactTemplate(this.templateString, factData);
+    return $interpolate(template)(factData);
+};
+
+FactTemplate.prototype.hasTemplate = function() {
+    return !_.isUndefined(this.templateString);
+};
+
+export default FactTemplate;

awx/ui/static/js/system-tracking/compare-facts/flat.js

@@ -27,7 +27,6 @@ export default
         var nameKey = renderOptions.nameKey;
         var compareKeys = renderOptions.compareKey;
         var keyNameMap = renderOptions.keyNameMap;
-        var valueFormatter = renderOptions.valueFormatter;
         var factTemplate = renderOptions.factTemplate;
 
 
@@ -35,8 +34,6 @@ export default
             var searcher = {};
             searcher[nameKey] = basisFact[nameKey];
 
-            var slottedValues, basisValue, comparatorValue;
-
             var matchingFact = _.where(comparatorFacts.facts, searcher);
             var diffs;
 
@@ -50,53 +47,75 @@ export default
             var comparisonResults =
                 _.reduce(compareKeys, function(result, compareKey) {
 
-                    if (_.isEmpty(matchingFact)) {
-                        comparatorValue = 'absent';
-                    } else {
-                        comparatorValue = matchingFact[0][compareKey];
-                    }
+                    var comparatorFact = matchingFact[0] || {};
+                    var isNestedDisplay = false;
 
                     var slottedValues = slotFactValues(basisFacts.position,
                                                        basisFact[compareKey],
-                                                       comparatorValue);
+                                                       comparatorFact[compareKey]);
 
                     if (_.isUndefined(slottedValues.left) && _.isUndefined(slottedValues.right)) {
                         return result;
                     }
 
+                    var template = factTemplate;
+
+                    if (_.isObject(template) && template.hasOwnProperty(compareKey)) {
+                        template = template[compareKey];
+
+                        // 'true' means render the key without formatting
+                        if (template === true) {
+                            template =
+                                {   render: function(fact) { return fact[compareKey]; }
+                                };
+                        }
+
+                        isNestedDisplay = true;
+                    } else if (typeof template.hasTemplate === 'function' && !template.hasTemplate()) {
+                        template =
+                            {   render: function(fact) { return fact[compareKey]; }
+                            };
+                        isNestedDisplay = true;
+                    } else if (typeof factTemplate.render === 'function') {
+                        template = factTemplate;
+                    } else if (!template.hasOwnProperty(compareKey)) {
+                        return result;
+                    }
+
+                    if (basisFacts.position === 'left') {
+                        slottedValues.left = template.render(basisFact);
+                        slottedValues.right = template.render(comparatorFact);
+                    } else {
+                        slottedValues.left = template.render(comparatorFact);
+                        slottedValues.right = template.render(basisFact);
+                    }
+
                     if (slottedValues.left !== slottedValues.right) {
                         slottedValues.isDivergent = true;
                     } else {
                         slottedValues.isDivergent = false;
                     }
 
-                    result[compareKey] = slottedValues;
+                    if (isNestedDisplay) {
+                        result[compareKey] = slottedValues;
+                    } else {
+                        result = slottedValues;
+                    }
 
                     return result;
                 }, {});
 
-                var hasDiffs = _.any(comparisonResults, { isDivergent: true });
+                var hasDiffs =
+                    _.any(comparisonResults, { isDivergent: true }) ||
+                        comparisonResults.isDivergent === true;
 
-                if (hasDiffs && factTemplate.hasTemplate()) {
+                if (hasDiffs && typeof factTemplate.render === 'function') {
 
-                    basisValue = factTemplate.render(basisFact);
-
-                    if (_.isEmpty(matchingFact)) {
-                        comparatorValue = 'absent';
-                    } else {
-                        comparatorValue = factTemplate.render(matchingFact[0]);
-                    }
-
-                    if (!_.isEmpty(comparisonResults)) {
-
-                        slottedValues = slotFactValues(basisFact.position, basisValue, comparatorValue);
-
-                        diffs =
-                            {   keyName: basisFact[nameKey],
-                                value1: slottedValues.left,
-                                value2: slottedValues.right
-                            };
-                    }
+                    diffs =
+                        {  keyName: basisFact[nameKey],
+                            value1: comparisonResults.left,
+                            value2: comparisonResults.right
+                        };
 
                 } else if (hasDiffs) {
 
@@ -111,9 +130,7 @@ export default
 
                             return {    keyName: keyName,
                                         value1: slottedValues.left,
-                                        value1IsAbsent: slottedValues.left === 'absent',
                                         value2: slottedValues.right,
-                                        value2IsAbsent: slottedValues.right === 'absent',
                                         isDivergent: slottedValues.isDivergent
                                    };
                         }).compact()

awx/ui/static/js/system-tracking/data-services/get-module-options.factory.js

@@ -13,8 +13,16 @@ var moduleConfig =
             },
         'files':
             {   compareKey: ['size', 'mode', 'md5', 'mtime', 'gid', 'uid'],
+                keyNameMap:
+                    {   'uid': 'ownership'
+                    },
+                factTemplate:
+                    {   'uid': 'user id: {{uid}}, group id: {{gid}}',
+                        'mode': true,
+                        'md5': true,
+                        'mtime': '{{mtime|formatEpoch}}'
+                    },
                 nameKey: 'path',
-                displayKeys: ['size', 'mode', 'mtime', 'uid', 'gid', 'md5'],
                 sortKey: 3
             },
         'ansible':