generateToMapMethod method

void generateToMapMethod(ClassBuilder clazz, BuildContext ctx, LibraryBuilder file)

Implementation

void generateToMapMethod(
    ClassBuilder clazz, BuildContext ctx, LibraryBuilder file) {
  var originalClassName = ctx.originalClassName;
  if (originalClassName == null) {
    log.warning('Unable to generate toMap(), classname is null');
    return;
  }
  clazz.methods.add(Method((method) {
    method
      ..static = true
      ..name = 'toMap'
      ..returns = Reference('Map<String, dynamic>')
      ..requiredParameters.add(Parameter((b) {
        b
          ..name = 'model'
          ..type = TypeReference((b) => b
            ..symbol = originalClassName
            ..isNullable = true);
      }));

    var buf = StringBuffer();

    /*
    ctx.requiredFields.forEach((key, msg) {
      if (ctx.excluded[key]?.canSerialize == false) return;
      buf.writeln('''
      if (model.$key == null) {
        throw FormatException("$msg");
      }
      ''');
    });
    */

    buf.writeln('return {');
    var i = 0;

    // Add named parameters
    for (var field in ctx.fields) {
      var type = ctx.resolveSerializedFieldType(field.name);

      // Skip excluded fields
      if (ctx.excluded[field.name]?.canSerialize == false) continue;

      var alias = ctx.resolveFieldName(field.name);

      if (i++ > 0) buf.write(', ');

      var serializedRepresentation = 'model.${field.name}';

      String serializerToMap(ReCase rc, String value) {
        // if (rc.pascalCase == ctx.modelClassName) {
        //   return '($value)?.toJson()';
        // }
        return '${rc.pascalCase.replaceAll('?', '')}Serializer.toMap($value)';
      }

      var fieldNameSerializer = ctx.fieldInfo[field.name]?.serializer;
      if (fieldNameSerializer != null) {
        var name = MirrorSystem.getName(fieldNameSerializer);
        serializedRepresentation = '$name(model.${field.name})';
      }

      // Serialize dates
      else if (dateTimeTypeChecker.isAssignableFromType(type)) {
        var question =
            field.type.nullabilitySuffix == NullabilitySuffix.question
                ? "?"
                : "";
        serializedRepresentation =
            'model.${field.name}$question.toIso8601String()';
      }

      // Serialize model classes via `XSerializer.toMap`
      else if (isModelClass(type)) {
        var rc = ReCase(type.getDisplayString(withNullability: true));
        serializedRepresentation = serializerToMap(rc, 'model.${field.name}');
      } else if (type is InterfaceType) {
        if (isListOfModelType(type)) {
          var name =
              type.typeArguments[0].getDisplayString(withNullability: true);
          if (name.startsWith('_')) name = name.substring(1);
          var rc = ReCase(name);
          var m = serializerToMap(rc, 'm');

          var question =
              (field.type.nullabilitySuffix == NullabilitySuffix.question)
                  ? '?'
                  : '';
          serializedRepresentation =
              'model.${field.name}$question.map((m) => $m).toList()';
          log.fine('serializedRepresentation => $serializedRepresentation');
        } else if (isMapToModelType(type)) {
          var rc = ReCase(
              type.typeArguments[1].getDisplayString(withNullability: true));
          serializedRepresentation =
              '''model.${field.name}.keys.fold({}, (map, key) {
            return map..[key] =
            ${serializerToMap(rc, 'model.${field.name}[key]')};
          })''';
        } else if (type.element is Enum) {
          var convert =
              (field.type.nullabilitySuffix == NullabilitySuffix.question)
                  ? '!'
                  : '';

          serializedRepresentation = '''
          model.${field.name} != null ?
            ${type.getDisplayString(withNullability: false)}.values.indexOf(model.${field.name}$convert)
            : null
          ''';
        } else if (const TypeChecker.fromRuntime(Uint8List)
            .isAssignableFromType(type)) {
          var convert =
              (field.type.nullabilitySuffix == NullabilitySuffix.question)
                  ? '!'
                  : '';

          serializedRepresentation = '''
          model.${field.name} != null ?
            base64.encode(model.${field.name}$convert)
            : null
          ''';
        }
      }

      buf.write("'$alias': $serializedRepresentation");
    }

    buf.write('};');
    method.body = Block.of([
      Code(
          'if (model == null) { throw FormatException("Required field [model] cannot be null"); }'),
      Code(buf.toString()),
    ]);
  }));
}