[csharp][java] Fix enum discriminator default value

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -3080,6 +3080,7 @@ public CodegenModel fromModel(String name, Schema schema) {
             listOLists.add(m.requiredVars);
             listOLists.add(m.vars);
             listOLists.add(m.allVars);
+            listOLists.add(m.readWriteVars);
             for (List<CodegenProperty> theseVars : listOLists) {
                 for (CodegenProperty requiredVar : theseVars) {
                     if (discPropName.equals(requiredVar.baseName)) {
@@ -3113,6 +3114,37 @@ public CodegenModel fromModel(String name, Schema schema) {
         return m;
     }
 
+    protected static void setEnumDiscriminatorDefaultValue(CodegenModel model) {
+        if (model.discriminator == null) {
+            return;
+        }
+        String discPropName = model.discriminator.getPropertyBaseName();
+        Stream.of(model.requiredVars, model.vars, model.allVars, model.readWriteVars)
+                .flatMap(List::stream)
+                .filter(v -> discPropName.equals(v.baseName))
+                .forEach(v -> v.defaultValue = getEnumValueForProperty(model.schemaName, model.discriminator, v));
+    }
+
+    protected static String getEnumValueForProperty(
+            String modelName, CodegenDiscriminator discriminator, CodegenProperty var) {
+        if (!discriminator.getIsEnum() && !var.isEnum) {
+            return null;
+        }
+        Map<String, String> mapping = Optional.ofNullable(discriminator.getMapping()).orElseGet(Collections::emptyMap);
+        for (Map.Entry<String, String> e : mapping.entrySet()) {
+            String schemaName = e.getValue().indexOf('/') < 0 ? e.getValue() : ModelUtils.getSimpleRef(e.getValue());
+            if (modelName.equals(schemaName)) {
+                return e.getKey();
+            }
+        }
+        Object values = var.allowableValues.get("values");
+        if (!(values instanceof List<?>)) {
+            return null;
+        }
+        List<?> valueList = (List<?>) values;
+        return valueList.stream().filter(o -> o.equals(modelName)).map(o -> (String) o).findAny().orElse(null);
+    }
+
     protected void SortModelPropertiesByRequiredFlag(CodegenModel model) {
         Comparator<CodegenProperty> comparator = new Comparator<CodegenProperty>() {
             @Override
@@ -3523,15 +3555,6 @@ protected CodegenDiscriminator createDiscriminator(String schemaName, Schema sch
                         .orElseGet(() -> typeMapping.get("string"));
         discriminator.setPropertyType(propertyType);
 
-        // check to see if the discriminator property is an enum string
-        if (schema.getProperties() != null &&
-                schema.getProperties().get(discriminatorPropertyName) instanceof StringSchema) {
-            StringSchema s = (StringSchema) schema.getProperties().get(discriminatorPropertyName);
-            if (s.getEnum() != null && !s.getEnum().isEmpty()) { // it's an enum string
-                discriminator.setIsEnum(true);
-            }
-        }
-
         discriminator.setMapping(sourceDiscriminator.getMapping());
         List<MappedModel> uniqueDescendants = new ArrayList<>();
         if (sourceDiscriminator.getMapping() != null && !sourceDiscriminator.getMapping().isEmpty()) {
@@ -3583,6 +3606,26 @@ protected CodegenDiscriminator createDiscriminator(String schemaName, Schema sch
         }
         discriminator.getMappedModels().addAll(uniqueDescendants);
 
+        // check current schema, all parents and descendants to see if the discriminator property is an enum string
+        Stream<Schema> schemasToCheckForEnumDiscriminator = Stream.concat(
+                Stream.of(schema),
+                Stream.concat(
+                        ModelUtils.isComposedSchema(schema)
+                                ? ModelUtils.getAllParentsName(schema, openAPI.getComponents().getSchemas(), true).stream()
+                                : Stream.of(),
+                        uniqueDescendants.stream().map(MappedModel::getModelName)
+                ).flatMap(s -> Optional.ofNullable(ModelUtils.getSchema(openAPI, s)).stream())
+        );
+
+        boolean isEnum = schemasToCheckForEnumDiscriminator.anyMatch(s -> Optional
+                .ofNullable(s.getProperties())
+                .map(p -> (Schema) p.get(discriminatorPropertyName))
+                .map(s1 -> ModelUtils.getReferencedSchema(openAPI, s1))
+                .filter(s1 -> s1 instanceof StringSchema && s1.getEnum() != null && !s1.getEnum().isEmpty())
+                .isPresent()
+        );
+        discriminator.setIsEnum(isEnum);
+
         return discriminator;
     }
 

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/AbstractJavaCodegen.java

@@ -1700,6 +1700,7 @@ public CodegenModel fromModel(String name, Schema model) {
 
         // additional import for different cases
         addAdditionalImports(codegenModel, codegenModel.getComposedSchemas());
+        setEnumDiscriminatorDefaultValue(codegenModel);
         return codegenModel;
     }
 

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/CSharpClientCodegen.java

@@ -425,6 +425,7 @@ public String apiTestFileFolder() {
     public CodegenModel fromModel(String name, Schema model) {
         Map<String, Schema> allDefinitions = ModelUtils.getSchemas(this.openAPI);
         CodegenModel codegenModel = super.fromModel(name, model);
+        setEnumDiscriminatorDefaultValue(codegenModel);
         if (allDefinitions != null && codegenModel != null && codegenModel.parent != null) {
             final Schema<?> parentModel = allDefinitions.get(toModelName(codegenModel.parent));
             if (parentModel != null) {

modules/openapi-generator/src/main/java/org/openapitools/codegen/utils/ModelUtils.java

@@ -1595,6 +1595,12 @@ public static String getParentName(Schema composedSchema, Map<String, Schema> al
      * @return the name of the parent model
      */
     public static List<String> getAllParentsName(Schema composedSchema, Map<String, Schema> allSchemas, boolean includeAncestors) {
+        return getAllParentsName(composedSchema, allSchemas, includeAncestors, new HashSet<>());
+    }
+
+    // Use a set of seen names to avoid infinite recursion
+    private static List<String> getAllParentsName(
+            Schema composedSchema, Map<String, Schema> allSchemas, boolean includeAncestors, Set<String> seenNames) {
         List<Schema> interfaces = getInterfaces(composedSchema);
         List<String> names = new ArrayList<String>();
 
@@ -1603,6 +1609,10 @@ public static List<String> getAllParentsName(Schema composedSchema, Map<String,
                 // get the actual schema
                 if (StringUtils.isNotEmpty(schema.get$ref())) {
                     String parentName = getSimpleRef(schema.get$ref());
+                    if (seenNames.contains(parentName)) {
+                        continue;
+                    }
+                    seenNames.add(parentName);
                     Schema s = allSchemas.get(parentName);
                     if (s == null) {
                         LOGGER.error("Failed to obtain schema from {}", parentName);
@@ -1611,7 +1621,7 @@ public static List<String> getAllParentsName(Schema composedSchema, Map<String,
                         // discriminator.propertyName is used or x-parent is used
                         names.add(parentName);
                         if (includeAncestors && isComposedSchema(s)) {
-                            names.addAll(getAllParentsName(s, allSchemas, true));
+                            names.addAll(getAllParentsName(s, allSchemas, true, seenNames));
                         }
                     } else {
                         // not a parent since discriminator.propertyName is not set

modules/openapi-generator/src/main/resources/Java/libraries/okhttp-gson/pojo.mustache

@@ -80,6 +80,11 @@ public class {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{{#vendorExtens
     {{/parcelableModel}}
     {{/parent}}
     {{#discriminator}}
+    {{#discriminator.isEnum}}
+{{#readWriteVars}}{{#isDiscriminator}}{{#defaultValue}}
+    this.{{name}} = {{defaultValue}};
+{{/defaultValue}}{{/isDiscriminator}}{{/readWriteVars}}
+    {{/discriminator.isEnum}}
     {{^discriminator.isEnum}}
     this.{{{discriminatorName}}} = this.getClass().getSimpleName();
     {{/discriminator.isEnum}}

modules/openapi-generator/src/test/java/org/openapitools/codegen/csharpnetcore/CSharpClientCodegenTest.java

@@ -140,4 +140,46 @@ public void test31specAdditionalPropertiesOfOneOf() throws IOException {
         assertFileContains(modelFile.toPath(),
                 " Dictionary<string, ResponseResultsValue> results = default(Dictionary<string, ResponseResultsValue>");
     }
+
+    @Test
+    public void testEnumDiscriminatorDefaultValueIsNotString() throws IOException {
+        File output = Files.createTempDirectory("test").toFile().getCanonicalFile();
+        output.deleteOnExit();
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec(
+                "src/test/resources/3_0/enum_discriminator_inheritance.yaml");
+        final DefaultGenerator defaultGenerator = new DefaultGenerator();
+        final ClientOptInput clientOptInput = new ClientOptInput();
+        clientOptInput.openAPI(openAPI);
+        CSharpClientCodegen cSharpClientCodegen = new CSharpClientCodegen();
+        cSharpClientCodegen.setOutputDir(output.getAbsolutePath());
+        cSharpClientCodegen.setAutosetConstants(true);
+        clientOptInput.config(cSharpClientCodegen);
+        defaultGenerator.opts(clientOptInput);
+
+        Map<String, File> files = defaultGenerator.generate().stream()
+                .collect(Collectors.toMap(File::getPath, Function.identity()));
+
+        Map<String, String> expectedContents = Map.of(
+                "Cat", "PetTypeEnum petType = PetTypeEnum.Catty",
+                "Dog", "PetTypeEnum petType = PetTypeEnum.Dog",
+                "Gecko", "PetTypeEnum petType = PetTypeEnum.Gecko",
+                "Chameleon", "PetTypeEnum petType = PetTypeEnum.Camo",
+                "MiniVan", "CarType carType = CarType.MiniVan",
+                "CargoVan", "CarType carType = CarType.CargoVan",
+                "SUV", "CarType carType = CarType.SUV",
+                "Truck", "CarType carType = CarType.Truck",
+                "Sedan", "CarType carType = CarType.Sedan"
+
+        );
+        for (Map.Entry<String, String> e : expectedContents.entrySet()) {
+            String modelName = e.getKey();
+            String expectedContent = e.getValue();
+            File file = files.get(Paths
+                    .get(output.getAbsolutePath(), "src", "Org.OpenAPITools", "Model", modelName + ".cs")
+                    .toString()
+            );
+            assertNotNull(file, "Could not find file for model: " + modelName);
+            assertFileContains(file.toPath(), expectedContent);
+        }
+    }
 }

modules/openapi-generator/src/test/java/org/openapitools/codegen/java/JavaClientCodegenTest.java

@@ -2287,6 +2287,39 @@ public void testAllOfWithSinglePrimitiveTypeRef() {
         assertNull(files.get("pom.xml"));
     }
 
+    @Test
+    public void testEnumDiscriminatorDefaultValueIsNotString() {
+        final Path output = newTempFolder();
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec(
+                "src/test/resources/3_0/enum_discriminator_inheritance.yaml");
+        JavaClientCodegen codegen = new JavaClientCodegen();
+        codegen.setOutputDir(output.toString());
+
+        Map<String, File> files = new DefaultGenerator().opts(new ClientOptInput().openAPI(openAPI).config(codegen))
+                .generate().stream().collect(Collectors.toMap(File::getName, Function.identity()));
+
+        Map<String, String> expectedContents = Map.of(
+                "Cat", "this.petType = PetTypeEnum.CATTY",
+                "Dog", "this.petType = PetTypeEnum.DOG",
+                "Gecko", "this.petType = PetTypeEnum.GECKO",
+                "Chameleon", "this.petType = PetTypeEnum.CAMO",
+                "MiniVan", "this.carType = CarType.MINI_VAN",
+                "CargoVan", "this.carType = CarType.CARGO_VAN",
+                "SUV", "this.carType = CarType.SUV",
+                "Truck", "this.carType = CarType.TRUCK",
+                "Sedan", "this.carType = CarType.SEDAN"
+
+        );
+        for (Map.Entry<String, String> e : expectedContents.entrySet()) {
+            String modelName = e.getKey();
+            String expectedContent = e.getValue();
+            File entityFile = files.get(modelName + ".java");
+            assertNotNull(entityFile);
+            assertThat(entityFile).content().doesNotContain("Type = this.getClass().getSimpleName();");
+            assertThat(entityFile).content().contains(expectedContent);
+        }
+    }
+
     @Test
     public void testRestTemplateHandleURIEnum() {
         String[] expectedInnerEnumLines = new String[] {

modules/openapi-generator/src/test/resources/3_0/enum_discriminator_inheritance.yaml

@@ -0,0 +1,131 @@
+openapi: 3.0.3
+info:
+  title: Test schema with enum discriminator
+  version: v1
+paths:
+  "/animal":
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                "$ref": "#/components/schemas/Animal"
+components:
+  schemas:
+    Animal:
+      type: object
+      properties:
+        # Inline enum type
+        petType:
+          type: string
+          enum:
+            - Dog
+            - Catty
+            - Gecko
+            - Camo
+      discriminator:
+        propertyName: petType
+        # Mapping with implicit (Dog, Gecko), explicit ref (Catty -> Cat), and explicit schema name (Camo -> Chameleon)
+        mapping:
+          Catty: '#/components/schemas/Cat'
+          Camo: 'Chameleon'
+      required:
+        - petType
+    Cat:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Animal'
+      properties:
+        meow:
+          type: string
+    Dog:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Animal'
+      properties:
+        bark:
+          type: string
+    Lizard:
+      oneOf:
+        - $ref: '#/components/schemas/Gecko'
+        - $ref: '#/components/schemas/Chameleon'
+    Gecko:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Animal'
+      properties:
+        lovesRocks:
+          type: string
+    Chameleon:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Animal'
+      properties:
+        currentColor:
+          type: string
+    # Car inheritance tree: Car -> Truck -> SUV
+    #                       Car -> Van -> MiniVan
+    #                       Car -> Van -> CargoVan
+    #                       Car -> Sedan
+    Car:
+      type: object
+      required:
+        - carType
+      # Discriminator carType not defined in Car properties, but in child properties
+      discriminator:
+        propertyName: carType
+    CarType:
+      type: string
+      enum:
+        - Truck
+        - SUV
+        - Sedan
+        - MiniVan
+        - CargoVan
+    Truck:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Car'
+      properties:
+        carType:
+          $ref: '#/components/schemas/CarType'
+      required:
+        - carType
+    SUV:
+      type: object
+      # SUV gets its discriminator property from Truck
+      allOf:
+        - $ref: '#/components/schemas/Truck'
+    Sedan:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Car'
+      required:
+        - carType
+      properties:
+        carType:
+          $ref: '#/components/schemas/CarType'
+    Van:
+      oneOf:
+        - $ref: '#/components/schemas/MiniVan'
+        - $ref: '#/components/schemas/CargoVan'
+    MiniVan:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Car'
+      properties:
+        carType:
+          $ref: '#/components/schemas/CarType'
+      required:
+        - carType
+    CargoVan:
+      type: object
+      allOf:
+        - $ref: '#/components/schemas/Car'
+      properties:
+        carType:
+          $ref: '#/components/schemas/CarType'
+      required:
+        - carType

samples/client/petstore/java/okhttp-gson/src/main/java/org/openapitools/client/model/EnumStringDiscriminator.java

@@ -107,6 +107,7 @@ public static void validateJsonElement(JsonElement jsonElement) throws IOExcepti
   protected EnumStrTypeEnum enumStrType;
 
   public EnumStringDiscriminator() {
+
   }
 
   public EnumStringDiscriminator enumStrType(EnumStrTypeEnum enumStrType) {