Method loadSchemaFromFile

schema/manager.go:347–458

loadSchemaFromFile loads schema from json file - recursive version for nested schemas

(filePath string)

//loadSchemaFromFile loads schema from json file - recursive version for nested schemas
func (manager *Manager) loadSchemaFromFile(filePath string) error {
	if filePath == "" {
		return nil
	}
	log.Info("Loading schema %s ...", filePath)
	schemas, err := util.LoadMap(filePath)
	if err != nil {
		return err
	}

	namespaces, _ := schemas["namespaces"].([]interface{})
	for _, namespaceData := range namespaces {
		namespace, err := NewNamespace(namespaceData)
		if err != nil {
			return err
		}
		if err = manager.registerNamespace(namespace); err != nil {
			return err
		}
	}

	schemaObjList := []*Schema{}
	schemaMap := map[string]*Schema{}
	list, _ := schemas["schemas"].([]interface{})
	for _, schemaData := range list {
		if fileName, ok := schemaData.(string); ok {
			err := manager.loadSchemaFromFile(fileName) // recursive call for included files
			if err != nil {
				return err
			}
		} else {
			metaschema, _ := manager.schema("schema")
			schemaObj, err := newSchemaFromObj(schemaData, metaschema)
			if err != nil {
				return err
			}
			schemaMap[schemaObj.ID] = schemaObj
			schemaObjList = append(schemaObjList, schemaObj)
		}
	}
	_, err = reorderSchemas(schemaObjList)
	if err != nil {
		log.Warning("Error in reordering schema %s", err)
	}
	for _, schemaObj := range schemaObjList {
		if schemaObj.IsAbstract() {
			// Register abstract schema
			manager.registerSchema(schemaObj)
		} else {
			for _, baseSchemaID := range schemaObj.Extends {
				baseSchema, ok := manager.schema(baseSchemaID)
				if !ok {
					return fmt.Errorf("Base Schema %s not found", baseSchemaID)
				}
				if !baseSchema.IsAbstract() {
					return fmt.Errorf("Base Schema %s isn't abstract type", baseSchemaID)
				}
				schemaObj.Extend(baseSchema)