private getResolvedDataObjectInternal()

in src/SfxWeb/src/app/shared/component/detail-view-part/detail-view-part.component.ts [100:182]
62 lines of code
30 McCabe index (conditional complexity)

    private getResolvedDataObjectInternal(data: any, parent: any, preserveEmptyProperties: boolean = false): ResolvedObject {
      const resolvedObject = new ResolvedObject();

      forOwn(data, (value, name) => {
          let resolvedName = startCase(name);
          let resolvedValue = null;

          // Use decorator to resolve value if defined
          if (parent && parent.decorators) {
              if (parent.decorators.showList && ! parent.decorators.showList.includes(name)) {
                  // If a showList is defined, use it to filter the object properties
                  return;
              } else if (parent.decorators.hideList && parent.decorators.hideList.includes(name)) {
                  // If a hideList is defined, use it to filter the object properties
                  return;
              }

              // If a decorator is defined for current property, use it
              if (parent.decorators.decorators && parent.decorators.decorators[name]) {
                  if (parent.decorators.decorators[name].displayName) {
                      resolvedName = parent.decorators.decorators[name].displayName(name);
                  }
                  if (parent.decorators.decorators[name].displayValueInHtml) {
                      resolvedValue = parent.decorators.decorators[name].displayValueInHtml(value);
                  }
              }
          }

          if (!resolvedValue) {
              // Try to look for the same property defined in parent object
              if (parent) {
                  resolvedValue = parent[name] || parent[camelCase(name)];
              }

              // Fall back to the original value
              if (!resolvedValue) {
                  resolvedValue = data[name];
              }
          }

          if (isNumber(resolvedValue) || isBoolean(resolvedValue)) {
              // Number and Boolean are always preserved
          } else if (isUndefined(resolvedValue) || isNull(resolvedValue) || isEmpty(resolvedValue)) {
              if (preserveEmptyProperties) {
                  resolvedValue = Constants.Empty;
              } else {
                  // Remove all empty/undefined/null value properties
                  resolvedValue = null;
              }
          } else if (Array.isArray(resolvedValue)) {
              if (!isObject(first(resolvedValue))) {
                  // The first element in the array is not an object, assume all the elements are value types
                  resolvedValue = `[${resolvedValue.map(v => v.toString()).join(', ')}]`;
              } else {
                  // Resolve sub-array, for array, all properties are preserved unless filtered by showList/hideList
                  resolvedValue = resolvedValue.map(v => this.getResolvedDataObject(v, true));
              }
          } else if (isObject(resolvedValue)) {
              // Deal with badge class as a special case
              if (Utils.isBadge(resolvedValue)) {
                  resolvedValue = resolvedValue as ITextAndBadge;
                  if (resolvedValue.text && resolvedValue.badgeClass) {
                      resolvedValue = HtmlUtils.getBadgeHtml(resolvedValue);
                  } else {
                      resolvedValue = resolvedValue.text;
                  }
              } else {
                  // Resolve sub-object
                  resolvedValue = this.getResolvedDataObject(resolvedValue);
              }
          }

          if (isEmpty(resolvedName)) {
              resolvedName = Constants.Empty;
          }

          if (resolvedValue !== null) {
              resolvedObject[resolvedName] = resolvedValue;
          }
      });

      return size(resolvedObject) > 0 ? resolvedObject : null;
  }