domain

Documentation

Index

• Variables

Variables

var BuildAlterInfrastucture = func(templateMap map[string]string, queryTemplate, controlTemplate string) (globals.SubstitionTemplateT, error) {
	var getQueryFilePath = func(templateMap map[string]string) (string, error) {
		dirpath := filepath.Join(templateMap[globals.KEY_TARGET_PATH], globals.CONTEXT_DIRNAME, globals.QUERY_DIRNAME)
		if !common.IsDir(dirpath) {
			err := os.MkdirAll(dirpath, os.ModePerm)
			if err != nil {
				return "", err
			}
		}
		fullAlterRelPath := templateMap[globals.KEY_FULL_ALTER_REL_PATH]
		queryPathName := strings.Replace(fullAlterRelPath, "/", "", -1)
		fName := queryPathName + globals.JSON_EXT
		fPath := filepath.Join(dirpath, fName)
		return fPath, nil
	}

	var getQueryId = func(templateMap map[string]string, queryFilePath string) (string, error) {
		queryFileName := filepath.Base(queryFilePath)
		queryName := queryFileName[:len(queryFileName)-len(globals.JSON_EXT)]
		logger.Log.Debug(queryName)
		suffix := 0
		queryId := "ID_" + strconv.Itoa(suffix)
		fullQueryId := queryName + "." + queryId

		return fullQueryId, nil
	}

	var alterRecord globals.SubstitionTemplateT

	queryFilePath, err := getQueryFilePath(templateMap)
	if err != nil {
		return alterRecord, err
	}
	moveItemMap, err := common.GetMoveItemMap(templateMap)
	if err != nil {
		return alterRecord, err
	}

	logger.Log.Debug(moveItemMap)
	fullQueryId, err := getQueryId(templateMap, queryFilePath)
	if err != nil {
		return alterRecord, err
	}
	queryIdParts := strings.Split(fullQueryId, ".")
	shortQueryId := queryIdParts[len(queryIdParts)-1]

	firstFilePath, firstWordInFirstFile, err := common.GetFirstLineOfFirstFile(templateMap)
	if err != nil {
		return alterRecord, err
	}
	logger.Log.Debug(firstFilePath)
	logger.Log.Debug(firstWordInFirstFile)
	templateMap[globals.KEY_FIRST_WORD_IN_FIRST_FILE] = firstWordInFirstFile

	alterRecord =
		globals.SubstitionTemplateT{
			FullQueryId:  fullQueryId,
			ShortQueryId: shortQueryId,

			MoveItemsInfo:        moveItemMap,
			FirstWordInFirstFile: firstWordInFirstFile,
			FirstFilePath:        firstFilePath,
		}

	contentQuery, error := common.RunTemplate(queryTemplate, alterRecord)
	if error != nil {
		return alterRecord, error
	}
	err = MakeQueryTokenFile(templateMap, contentQuery, queryFilePath)
	if err != nil {
		return alterRecord, err
	}

	contentControl, error := common.RunTemplate(controlTemplate, alterRecord)
	if error != nil {
		return alterRecord, error
	}
	err = MakeControlFile(templateMap, contentControl)

	return alterRecord, err
}

var BuildStore = func(templateMap map[string]string) error {
	var buildStoreDir = func(templateMap map[string]string, writeMode bool) error {

		var matches = func(list []string, item string) bool {
			for _, listItem := range list {
				if listItem == item {
					return true
				}
			}
			return false
		}

		move_items := strings.Split(templateMap[globals.KEY_MOVE_ITEMS], ":")
		for i, item := range move_items {
			move_items[i] = strings.TrimSpace(item)
		}

		logger.Log.Debug(move_items)

		files, err := os.ReadDir(templateMap[globals.KEY_CODE_BLOCK_PATH])
		if err != nil {
			return err
		}
		foundItems := []string{}
		missingItems := []string{}

		for _, item := range files {
			if matches(move_items, item.Name()) {
				foundItems = append(foundItems, item.Name())
				item_path := filepath.Join(templateMap[globals.KEY_CODE_BLOCK_PATH], item.Name())

				parentDir := filepath.Dir(item_path)
				alterName := filepath.Base(templateMap[globals.KEY_ALTER_PATH])
				newParent := filepath.Join(parentDir, alterName, globals.STORE_DIRNAME)
				if writeMode {
					err := os.MkdirAll(newParent, os.ModePerm)
					if err != nil {
						return err
					}
					new_dirpath := filepath.Join(newParent, item.Name())
					err = os.Rename(item_path, new_dirpath)
					if err != nil {
						return err
					}
				}
			}
		}

		for _, moveItem := range move_items {
			found := false
			for _, item := range foundItems {
				if item == moveItem {
					found = true
				}
			}
			if !found {
				missingItems = append(missingItems, moveItem)
			}
		}

		if len(missingItems) > 0 {
			msg := "FAILED: the following move-items do not exist: " + strings.Join(missingItems, ", ")
			logger.Log.Error(msg)
			return errors.New(msg)
		}

		return nil
	}

	err := buildStoreDir(templateMap, false)
	if err != nil {
		return err
	}
	err = buildStoreDir(templateMap, true)
	if err != nil {
		return err
	}
	return nil
}

var MakeControlFile = func(templateMap map[string]string, content string) error {

	jsonControlFileScaffold := globals.ScaffoldInfoTListT{

		{
			Filepath: templateMap[globals.KEY_CONTROL_JSON_PATH],
			Content:  content,
		},
	}

	err := common.CreateFiles(jsonControlFileScaffold)
	if err != nil {
		return err
	}
	return nil
}

var MakeQueryTokenFile = func(templateMap map[string]string, content string, queryFilePath string) error {

	queryTokenScaffold := globals.ScaffoldInfoTListT{

		{
			Filepath: queryFilePath,
			Content:  content,
		},
	}

	err := common.CreateFiles(queryTokenScaffold)
	if err != nil {
		return err
	}

	return nil
}