Go language - IO project

1. util package

file.go

// CreatFile
// @Title CreatFile
// @Description  create a file 
// @Param name string " file name "
// @Return *os.File " File object "
func CreatFile(name string) *os.File {
    
	file, err := os.Create(name)
	if err != nil {
    
		log.Fatalln(err)
	}
	return file
}

// ReadFile
// @Title ReadFile
// @Description  Read file information 
// @Param name string " file name "
// @Return []string " Results slice "
func ReadFile(name string) []string {
    
	file, err := os.OpenFile(name, os.O_CREATE|os.O_RDONLY, 0666)
	defer func(file *os.File) {
    
		err := file.Close()
		if err != nil {
    
			log.Fatalln(err)
		}
	}(file)
	if err != nil {
    
		log.Fatalln(err)
	}
	reader := bufio.NewReader(file)
	result := make([]string,0)
	for {
    
		lineString, err := reader.ReadString('\n')
		if err == io.EOF {
    
			break
		}
		lineString = strings.Trim(lineString,"\n")
		result = append(result,lineString)
	}

	return result
}

// WriteFile
// @Title WriteFile
// @Description  write file 
// @Param name string " file name "
// @Param strS []string " To write information "
// @Return []string " Results slice "
func WriteFile(name string,strS []string) bool {
    
	file, err := os.OpenFile(name, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
	if err != nil {
    
		log.Fatalln(err)
	}
	defer func(file *os.File) {
    
		err := file.Close()
		if err != nil {
    
			log.Fatalln(err)
		}
	}(file)
	writer := bufio.NewWriter(file)
	for _, str := range strS {
    
		_, err := writer.WriteString(str+"\n")// Write the data to the cache first 
		if err != nil {
    
			log.Fatalln(err)
		}
	}
	err = writer.Flush() // Write the contents of the cache to a file 
	if err != nil {
    
		log.Fatalln(err)
	}
	return true
}

// AppendWriteFile
//  Add a message 
func AppendWriteFile(name string,str string) bool {
    
	file, err := os.OpenFile(name, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
	if err != nil {
    
		log.Fatalln(err)
	}
	defer func(file *os.File) {
    
		err := file.Close()
		if err != nil {
    
			log.Fatalln(err)
		}
	}(file)
	writer := bufio.NewWriter(file)
	_, err = writer.WriteString(str+"\n")
	if err != nil {
    
		log.Fatalln(err)
	}
	err = writer.Flush() // Write the contents of the cache to a file 
	if err != nil {
    
		log.Fatalln(err)
	}
	return true
}

2. model package

// User  user 
type User struct {
    
	UserNo   string //  Number （ user name ）- Student number | Job number 
	UserName string //  full name 
	Password string //  password 
	Level    int    //  jurisdiction  0- Administrators |1- Teachers' |2- Student 
}

// IsStructureEmpty
//  Judge whether the structure is empty by reflection 
func (x User) IsStructureEmpty() bool {
    
	return reflect.DeepEqual(x, User{
    })
}

3. dao package

user_dao.go

// SelectUserByUserNo
// @Title SelectUserByUserNo
// @Description  By student number | Job number query user （0,1,2）
// @Param UserNo string " Student number | Job number "
// @Return model.User " Query results "
func SelectUserByUserNo(UserNo string) model.User {
    
	contain := util.ReadFile("./user.txt")
	var user model.User
	var strS []string
	for _, u := range contain {
    
		strS = strings.Split(u, " ")
		if strS[0] == UserNo {
    
			strS := strings.Split(u, " ")
			user.UserNo = strS[0]
			user.UserName = strS[1]
			user.Password = strS[2]
			user.Level, _ = strconv.Atoi(strings.Trim(strS[3], "\r"))
			return user
		}
	}
	return user
}

// SelectAllUser
// @Title SelectAllUser
// @Description  Query all users （0）
// @Return []model.User " Query the result slice "
func SelectAllUser() []model.User {
    
	contain := util.ReadFile("./user.txt")
	users := make([]model.User, 0)
	var user model.User
	for _, u := range contain {
    
		strS := strings.Split(u, " ")
		user.UserNo = strS[0]
		user.UserName = strS[1]
		user.Password = strS[2]
		user.Level, _ = strconv.Atoi(strings.Trim(strS[3], "\r"))
		users = append(users, user)
	}
	return users
}

// InsertUser
// @Title InsertUser
// @Description  Add users （0）
// @Param user model.User " User information "
// @Return bool " Whether the insertion is successful "
func InsertUser(user model.User) bool {
    
	s := user.UserNo + " " + user.UserName + " " + user.Password + " " + strconv.Itoa(user.Level)
	return util.AppendWriteFile("./user.txt", s)
}

// DeleteUserByUserNo
// @Title DeleteUserByUserNo
// @Description  Delete user （0）
// @Param UserNo string " Student number | Job number "
// @Return bool " Whether the deletion is successful "
func DeleteUserByUserNo(UserNo string) bool {
    
	users := SelectAllUser()
	strS := make([]string, 0)
	for _, user := range users {
    
		if user.UserNo == UserNo {
    
			continue
		}
		s := user.UserNo + " " + user.UserName + " " + user.Password + " " + strconv.Itoa(user.Level)
		strS = append(strS, s)
	}
	return util.WriteFile("./user.txt", strS)
}

// UpdateUserByUserNO
// @Title UpdateUserByUserNO
// @Description  Modify user information （0,1,2）
// @Param user model.User " User information "
// @Return bool " Whether the modification is successful or not "
func UpdateUserByUserNO(user model.User) bool {
    
	users := SelectAllUser()
	strS := make([]string, 0)
	for _, user01 := range users {
    
		if user01.UserNo == user.UserNo {
    
			user01 = user
		}
		s := user01.UserNo + " " + user01.UserName + " " + user01.Password + " " + strconv.Itoa(user01.Level)
		strS = append(strS, s)
	}
	return util.WriteFile("./user.txt", strS)
}

4. service package

user_service.go

func SelectUserByUserNo(userNo string) model.User {
    
	return dao.SelectUserByUserNo(userNo)
}
func SelectAllUser() []model.User {
    
	return dao.SelectAllUser()
}
func InsertUser(user model.User) bool {
    
	if !SelectUserByUserNo(user.UserNo).IsStructureEmpty() {
    
		return false
	} else {
    
		return dao.InsertUser(user)
	}
}
func DeleteUserByUserNo(userNo string) bool {
    
	if SelectUserByUserNo(userNo).IsStructureEmpty() {
    
		return false
	} else {
    
		return dao.DeleteUserByUserNo(userNo)
	}
}
func UpdateUserByUserNo(user model.User) bool {
    
	return dao.UpdateUserByUserNO(user)
}

5. controller package

user_controller.go

// SelectUserByNo
// @Title SelectUserByNo
// @Description  Query user information （0）
func SelectUserByNo() {
    
	var StuNo string
	fmt.Print(" Please enter the student number | Job number :")
	_, err := fmt.Scan(&StuNo)
	if err != nil {
    
		log.Fatalln(err)
	}
	user := service.SelectUserByUserNo(StuNo)
	fmt.Println(" Query results :")
	if user.IsStructureEmpty() {
    
		fmt.Println("\t The user was not queried ")
	} else {
    
		fmt.Printf("\t[ Number :%s, full name :%s, password :%s, jurisdiction %d]\n", user.UserNo, user.UserName, user.Password, user.Level)
	}
}

// SelectALLUser
// @Title SelectALLUser
// @Description  Query all user information （0）
func SelectALLUser() {
    
	users := service.SelectAllUser()
	fmt.Println(" Query results :")
	if len(users) == 0 {
    
		fmt.Println("\t No user found ")
	} else {
    
		for _, user := range users {
    
			fmt.Printf("\t[ Number :%s, full name :%s, password :%s, jurisdiction %d]\n", user.UserNo, user.UserName, user.Password, user.Level)
		}
	}
}

// InsertUser
// @Title InsertUser
// @Description  Add users （0）
func InsertUser() {
    
	fmt.Println(" Please enter user information : ")
	var user model.User
	fmt.Print(" Student number / Job number : ")
	_, err := fmt.Scan(&user.UserNo)
	fmt.Print(" full name : ")
	_, err = fmt.Scan(&user.UserName)
	fmt.Print(" password : ")
	_, err = fmt.Scan(&user.Password)
	fmt.Print(" jurisdiction : ")
	_, err = fmt.Scan(&user.Level)
	if err != nil {
    
		log.Fatalln(err)
	}
	if service.InsertUser(user) {
    
		fmt.Println(" Add success ！")
	} else {
    
		fmt.Println(" Add failure , Student number | Job number already exists ！")
	}
}

// DeleteUserByNo
// @Title DeleteUserByNo
// @Description  Delete user （0）
func DeleteUserByNo() {
    
	var userNo string
	fmt.Print(" Please enter the student number / Job number : ")
	_, err := fmt.Scan(&userNo)
	if err != nil {
    
		log.Fatalln(err)
	}
	if service.DeleteUserByUserNo(userNo) {
    
		fmt.Println(" Delete successful ！")
	} else {
    
		fmt.Println(" Delete failed , Student number | The job number does not exist ！")
	}
}

// UpdateUserByNo
// @Title UpdateUserByNo
// @Description  Modify the user （0）| Modify yourself （1,2）
func UpdateUserByNo(myUser model.User) {
    
	var result bool
	if myUser.Level == 0 {
    
		var userNo string
		fmt.Print(" Student number / Job number : ")
		_, err := fmt.Scan(&userNo)
		if err != nil {
    
			log.Fatalln(err)
		}
		user := service.SelectUserByUserNo(userNo)
		if user.IsStructureEmpty() {
    
			fmt.Println(" The user was not queried ！")
			return
		}
		fmt.Println(" Please select the modified content :")
	out1:
		fmt.Println("1> full name ")
		fmt.Println("2> password ")
		fmt.Println("3> jurisdiction ")
		fmt.Println("4> return ")
		var s string

		_, err = fmt.Scan(&s)
		switch s {
    
		case "1":
			fmt.Print(" full name : ")
			_, err = fmt.Scan(&user.UserName)
			result = service.UpdateUserByUserNo(user)
			break
		case "2":
			fmt.Print(" password : ")
			_, err = fmt.Scan(&user.Password)
			result = service.UpdateUserByUserNo(user)
			break
		case "3":
			fmt.Print(" jurisdiction : ")
			_, err = fmt.Scan(&user.Level)
			result = service.UpdateUserByUserNo(user)
			break
		case "4":
			return
		default:
			fmt.Println(" Illegal input , Please reselect ")
			fmt.Println("------------------------")
			goto out1
		}
	} else {
    
		fmt.Println(" Please select the modified content :")
	out2:
		fmt.Println("1> password ")
		fmt.Println("2> return ")
		var s string
		_, err := fmt.Scan(&s)
		if err != nil {
    
			log.Fatalln(err)
		}
		switch s {
    
		case "1":
			fmt.Print(" password : ")
			_, err = fmt.Scan(&myUser.Password)
			result = service.UpdateUserByUserNo(myUser)
			break
		case "2":
			return
		default:
			fmt.Println(" Illegal input , Please reselect ")
			fmt.Println("------------------------")
			goto out2
		}
	}
	if result {
    
		fmt.Println(" Modification successful ！")
	} else {
    
		fmt.Println(" Modification failed !")
	}
}

// Login
// @Title Login
// @Description  Sign in 
func Login() model.User {
    
	var password string
	var userNo string
	fmt.Print(" Student number | Job number : ")
	_, err := fmt.Scan(&userNo)
	if err != nil {
    
		log.Fatalln(err)
	}
	fmt.Print(" password : ")
	_, err = fmt.Scan(&password)
	if err != nil {
    
		log.Fatalln(err)
	}
	user := service.SelectUserByUserNo(userNo)
	if user.IsStructureEmpty() {
    
		fmt.Println(" Login failed , Student number | Wrong job number or password .")
		return user
	}
	if user.Password == password {
    
		fmt.Println(" Login successful ")
		return user
	} else {
    
		fmt.Println(" Login failed , Student number | Wrong job number or password .")
		return model.User{
    }
	}
}

6. main.go

var User model.User

func init() {
    
	log.SetFlags(log.Lshortfile | log.Ltime | log.Ldate)
}
func main() {
    
	View()
}
func View() {
    
	fmt.Println("------------- Welcome to the educational administration system -------------")
start:
	fmt.Println("1>  Sign in ")
	fmt.Println("2>  sign out ")
	fmt.Println("-------------------------------------------")
	var s string
	_, err := fmt.Scan(&s)
	if err != nil {
    
		log.Fatalln(err)
	}
	switch s {
    
	case "1":
	Login:
		User = controller.Login()
		if User.IsStructureEmpty() {
    
			fmt.Println("----------- Please re-enter -----------")
			goto Login
		}
		for {
    
			if User.Level == 0 {
    
				fmt.Println("--------------- Welcome to the administrator ---------------")
			admin:
				fmt.Println(" Please select what you want to do :")
				fmt.Println("1> Query the user ")
				fmt.Println("2> Add users ")
				fmt.Println("3> Delete user ")
				fmt.Println("4> Modify the user ")
				fmt.Println("5> Log out ")
				var s1 string
				_, err = fmt.Scan(&s1)
				if err != nil {
    
					log.Fatalln(err)
				}
				switch s1 {
    
				case "1":
				Select:
					fmt.Println("1> Query all users ")
					fmt.Println("2> Query the specified student number | Job ID user ")
					fmt.Println("3> return ")
					var s2 string
					_, err = fmt.Scan(&s2)
					if err != nil {
    
						log.Fatalln(err)
					}
					switch s2 {
    
					case "1":
						controller.SelectALLUser()
						break
					case "2":
						controller.SelectUserByNo()
						break
					case "3":
						goto admin
					default:
						fmt.Println(" Illegal input , Please re-enter ！")
						goto Select
					}
				case "2":
					controller.InsertUser()
					break
				case "3":
					controller.DeleteUserByNo()
					break
				case "4":
					controller.UpdateUserByNo(User)
					break
				case "5":
					User = model.User{
    }
					goto start
				default:
					fmt.Println(" Illegal input , Please reselect ！")
					goto admin
				}
			}else {
    
				fmt.Println("--------------- Welcome to login ---------------")
			Common:
				fmt.Println(" Please select what you want to do :")
				fmt.Println("1> Change Password ")
				fmt.Println("2> Log out ")
				var s1 string
				_, err = fmt.Scan(&s1)
				if err != nil {
    
					log.Fatalln(err)
				}
				switch s1 {
    
				case "1":
					controller.UpdateUserByNo(User)
					break
				case "2":
					User = model.User{
    }
					goto start
				default:
					fmt.Println(" Illegal input , Please reselect ！")
					goto Common
				}
			}
		}
	case "2":
		fmt.Println(" Welcome to your next use ！")
		return
	default:
		fmt.Println(" Illegal input , Please re-enter ！")
		goto start
	}

}

7. user.txt file

Document pre design ：
 user.txt : Used to store user information
   Permission is 0( Administrators , The account and password need to be entered manually ) Can be carried out : Add, delete, modify and check student information , You can delete students without a password | Change student password , Account default password 123456
   Permission is 1 Can be carried out : Modification of my password
   Permission is 2 Can be carried out : Modification of my password
    0000 admin admin 0
    1002 tea01 123456 1
    2001 stu01 123456 2