Merge pull request #348 from EAT-SSU/fix/#327

[#327] 닉네임 규칙 시스템 개선

Author: Hrepay

EATSSU/App/Sources/Presentation/Auth/Enum/NIcknameTextFieldResultType.swift

@@ -13,32 +13,76 @@ enum NicknameTextFieldResultType {
     /// common
     case textFieldEmpty
     /// nickname
-    case nicknameTextFieldOver
     case nicknameTextFieldDuplicated
     case nicknameTextFieldDoubleCheck
     case nicknameTextFieldValid
-
+    case invalidLength
+    case invalidStartOrEnd
+    case consecutiveSpecialChars
+    case onlyNumbers
+    case invalidCharacters
+    case bannedWord
+    case whitespaceAtStartOrEnd
+    case consecutiveWhitespace
+    case emojiOrSpecialChar
+    case adminRelatedWord
+    case serviceNameWord
+    case profanityWord
+    
     var hintMessage: String {
         switch self {
         case .textFieldEmpty:
-            "필수 입력 사항입니다."
-        case .nicknameTextFieldOver:
-            "2~8자내로 입력해주세요."
+            "필수 입력 사항입니다"
         case .nicknameTextFieldDoubleCheck:
             "중복 확인을 진행해주세요."
         case .nicknameTextFieldDuplicated:
             "이미 사용 중인 닉네임이에요."
         case .nicknameTextFieldValid:
-            "사용가능한 닉네임이에요."
+            "사용가능한 닉네임이에요"
+        case .invalidLength:
+            "2~16글자를 입력해 주세요."
+        case .invalidStartOrEnd:
+            "특수문자로 시작/끝나는 닉네임은 사용할 수 없어요."
+        case .consecutiveSpecialChars:
+            "연속된 특수문자(--, __)는 사용할 수 없어요."
+        case .onlyNumbers:
+            "숫자만으로 된 닉네임은 사용할 수 없어요."
+        case .invalidCharacters:
+            "허용 문자(한글/영문/숫자)만 사용할 수 있어요."
+        case .bannedWord:
+            "사용할 수 없는 단어가 포함되어 있어요."
+        case .whitespaceAtStartOrEnd:
+            "띄어쓰기로 시작/끝나는 닉네임은 사용할 수 없어요."
+        case .consecutiveWhitespace:
+            "연속된 띄어쓰기는 사용할 수 없어요."
+        case .emojiOrSpecialChar:
+            "이모지, 특수문자는 사용할 수 없어요."
+        case .adminRelatedWord:
+            "관리자로 혼동될 수 있는 닉네임은 사용할 수 없어요."
+        case .serviceNameWord:
+            "서비스명 단독 닉네임은 사용할 수 없어요."
+        case .profanityWord:
+            "욕설, 비속어 등의 표현이 포함된 닉네임은 사용할 수 없어요."
         }
     }
 
     var textColor: UIColor {
         switch self {
-        case .textFieldEmpty, .nicknameTextFieldOver, .nicknameTextFieldDuplicated, .nicknameTextFieldDoubleCheck:
+        case .nicknameTextFieldValid:
+            EATSSUDesignAsset.Color.GrayScale.gray600.color
+        default:
             .primary
+        }
+    }
+
+    var borderColor: UIColor {
+        switch self {
         case .nicknameTextFieldValid:
-            EATSSUDesignAsset.Color.info.color
+            EATSSUDesignAsset.Color.Main.primary.color
+        case .textFieldEmpty, .nicknameTextFieldDoubleCheck:
+            EATSSUDesignAsset.Color.GrayScale.gray100.color
+        default:
+            .primary
         }
     }
 }

EATSSU/App/Sources/Presentation/Auth/Enum/NicknameBannedWords.swift

@@ -0,0 +1,81 @@
+//
+//  NicknameBannedWords.swift
+//  EATSSU
+//
+//  Created by 황상환 on 10/25/25.
+//
+
+import Foundation
+
+struct NicknameBannedWords {
+    
+    // MARK: - 시스템/운영 관련 금지어
+    static let systemWords: [String] = [
+        "admin", "관리자",
+        "manager", "운영자",
+        "system",
+    ]
+    
+    // MARK: - 서비스명/브랜드명
+    static let serviceWords: [String] = [
+        "eatssu", "EATSSU", "잇슈", "EatSSU",
+        "EAT-SSU", "읻슈", "잍슈", "잇쓔", "잇쓲", "잇씨유", "잇슈우", "잇슈웅",
+        "eat-ssu", "eatsu", "e4tssu", "3at-ssu", "ea7-ssu", "e @t-ssu",
+        "e.at.ssu", "e-a-t-s-s-u", "e_a_t_s_s_u", "e a t ssu",
+        "eat_ssu", "eatssu_", "eatssu123", "e @tssu", "ēat-ssu",
+        "3atssu", "eat$u", "eat5su", "eats$u", "eats-u", "E4T슈"
+    ]
+    
+    // MARK: - 욕설/비속어 (임시 기본 리스트)
+    static let profanityWords: [String] = [
+        "시발", "씨발", "ㅅㅂ",
+        "병신", "ㅂㅅ",
+        "개새끼", "ㄱㅅㄲ",
+        "존나", "ㅈㄴ",
+        "fuck", "shit", "bitch"
+        // 필요시 추가
+    ]
+    
+    // MARK: - 전체 금지어 리스트
+    static var allBannedWords: [String] {
+        return systemWords + serviceWords + profanityWords
+    }
+    
+    // MARK: - 금지어 포함 여부 체크
+    static func containsBannedWord(_ nickname: String) -> Bool {
+        let lowercased = nickname.lowercased()
+        
+        return allBannedWords.contains { bannedWord in
+            lowercased.contains(bannedWord.lowercased())
+        }
+    }
+    
+    // MARK: - 타입별 금지어 체크
+    
+    /// 관리자/운영자 관련 금지어 체크
+    static func containsAdminWord(_ nickname: String) -> Bool {
+        let lowercased = nickname.lowercased()
+        
+        return systemWords.contains { word in
+            lowercased.contains(word.lowercased())
+        }
+    }
+    
+    /// 서비스명/브랜드명 금지어 체크
+    static func containsServiceName(_ nickname: String) -> Bool {
+        let lowercased = nickname.lowercased()
+        
+        return serviceWords.contains { word in
+            lowercased.contains(word.lowercased())
+        }
+    }
+    
+    /// 욕설/비속어 체크
+    static func containsProfanity(_ nickname: String) -> Bool {
+        let lowercased = nickname.lowercased()
+        
+        return profanityWords.contains { word in
+            lowercased.contains(word.lowercased())
+        }
+    }
+}

EATSSU/App/Sources/Presentation/Auth/Enum/NicknameValidator.swift

@@ -0,0 +1,199 @@
+//
+//  NicknameValidator.swift
+//  EATSSU
+//
+//  Created by 황상환 on 10/24/25.
+//
+
+import Foundation
+
+final class NicknameValidator {
+    
+    // MARK: - Validation Methods
+    
+    /// 닉네임 유효성 검사 (모든 규칙 체크)
+    static func validate(_ nickname: String) -> NicknameTextFieldResultType? {
+        // 빈 문자열 체크
+        if nickname.isEmpty {
+            return .textFieldEmpty
+        }
+        
+        // 길이 체크 (2~16자)
+        if !(2...16).contains(nickname.count) {
+            return .invalidLength
+        }
+        
+        // 띄어쓰기 시작/끝 체크
+        if hasWhitespaceAtStartOrEnd(nickname) {
+            return .whitespaceAtStartOrEnd
+        }
+        
+        // 연속 띄어쓰기 체크
+        if hasConsecutiveWhitespace(nickname) {
+            return .consecutiveWhitespace
+        }
+        
+        // 이모지 및 허용되지 않은 특수문자 체크
+        if containsEmojiOrInvalidSpecialChar(nickname) {
+            return .emojiOrSpecialChar
+        }
+        
+        // 허용되지 않은 문자 체크
+        if !isAllowedCharacters(nickname) {
+            return .invalidCharacters
+        }
+        
+        // 시작과 끝이 한글(초성포함), 영문, 숫자인지 체크
+        if !isValidStartAndEnd(nickname) {
+            return .invalidStartOrEnd
+        }
+        
+        // 특수문자 연속 사용 체크
+        if hasConsecutiveSpecialChars(nickname) {
+            return .consecutiveSpecialChars
+        }
+        
+        // 숫자로만 구성되었는지 체크
+        if isOnlyNumbers(nickname) {
+            return .onlyNumbers
+        }
+        
+        // 금지어 체크 (타입별)
+        if let bannedWordType = checkBannedWordType(nickname) {
+            return bannedWordType
+        }
+        
+        // 모든 검사 통과 - 중복 확인 필요
+        return .nicknameTextFieldDoubleCheck
+    }
+    
+    // MARK: - Private Helper Methods
+    
+    /// 띄어쓰기로 시작하거나 끝나는지 체크
+    private static func hasWhitespaceAtStartOrEnd(_ nickname: String) -> Bool {
+        return nickname.first == " " || nickname.last == " "
+    }
+    
+    /// 연속된 띄어쓰기가 있는지 체크
+    private static func hasConsecutiveWhitespace(_ nickname: String) -> Bool {
+        return nickname.contains("  ")
+    }
+    
+    /// 이모지 또는 허용되지 않은 특수문자 포함 여부 체크
+    private static func containsEmojiOrInvalidSpecialChar(_ nickname: String) -> Bool {
+        for scalar in nickname.unicodeScalars {
+            // 이모지 체크
+            if scalar.properties.isEmoji {
+                return true
+            }
+            
+            // 허용된 문자 집합에 없는 특수문자 체크
+            let char = Character(scalar)
+            if char.isPunctuation || char.isSymbol {
+                // - 와 _ 는 허용
+                if char != "-" && char != "_" {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+    
+    /// 허용된 문자만 포함되어 있는지 체크 (한글(초성포함), 영문, 숫자, 띄어쓰기, -, _)
+    private static func isAllowedCharacters(_ nickname: String) -> Bool {
+        var allowed = CharacterSet()
+        
+        // 영문 소문자
+        allowed.formUnion(CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyz"))
+        // 영문 대문자
+        allowed.formUnion(CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+        // 숫자
+        allowed.formUnion(CharacterSet.decimalDigits)
+        // 한글 (완성된 글자)
+        allowed.formUnion(CharacterSet(charactersIn: "가".unicodeScalars.first!..."힣".unicodeScalars.first!))
+        // 한글 자음
+        allowed.formUnion(CharacterSet(charactersIn: "ㄱ".unicodeScalars.first!..."ㅎ".unicodeScalars.first!))
+        // 한글 모음
+        allowed.formUnion(CharacterSet(charactersIn: "ㅏ".unicodeScalars.first!..."ㅣ".unicodeScalars.first!))
+        // 특수문자 (- 와 _ 만 허용)
+        allowed.formUnion(CharacterSet(charactersIn: "-_"))
+        // 띄어쓰기 허용
+        allowed.formUnion(CharacterSet(charactersIn: " "))
+        
+        return nickname.unicodeScalars.allSatisfy { allowed.contains($0) }
+    }
+    
+    /// 시작과 끝이 한글(초성포함), 영문, 숫자인지 체크
+    private static func isValidStartAndEnd(_ nickname: String) -> Bool {
+        guard let first = nickname.first, let last = nickname.last else {
+            return false
+        }
+        
+        var valid = CharacterSet()
+        
+        // 영문 소문자
+        valid.formUnion(CharacterSet(charactersIn: "abcdefghijklmnopqrstuvwxyz"))
+        // 영문 대문자
+        valid.formUnion(CharacterSet(charactersIn: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+        // 숫자
+        valid.formUnion(CharacterSet.decimalDigits)
+        // 한글 (완성된 글자)
+        valid.formUnion(CharacterSet(charactersIn: "가".unicodeScalars.first!..."힣".unicodeScalars.first!))
+        // 한글 자음
+        valid.formUnion(CharacterSet(charactersIn: "ㄱ".unicodeScalars.first!..."ㅎ".unicodeScalars.first!))
+        // 한글 모음
+        valid.formUnion(CharacterSet(charactersIn: "ㅏ".unicodeScalars.first!..."ㅣ".unicodeScalars.first!))
+        
+        let firstString = String(first)
+        let lastString = String(last)
+        
+        let isFirstValid = firstString.unicodeScalars.allSatisfy { valid.contains($0) }
+        let isLastValid = lastString.unicodeScalars.allSatisfy { valid.contains($0) }
+        
+        return isFirstValid && isLastValid
+    }
+    
+    /// 특수문자(-, _)가 연속으로 사용되었는지 체크
+    private static func hasConsecutiveSpecialChars(_ nickname: String) -> Bool {
+        let specialChars: [Character] = ["-", "_"]
+        
+        for i in 0..<nickname.count - 1 {
+            let currentIndex = nickname.index(nickname.startIndex, offsetBy: i)
+            let nextIndex = nickname.index(nickname.startIndex, offsetBy: i + 1)
+            
+            let currentChar = nickname[currentIndex]
+            let nextChar = nickname[nextIndex]
+            
+            if specialChars.contains(currentChar) && specialChars.contains(nextChar) {
+                return true
+            }
+        }
+        
+        return false
+    }
+    
+    /// 숫자로만 구성되어 있는지 체크
+    private static func isOnlyNumbers(_ nickname: String) -> Bool {
+        return nickname.allSatisfy { $0.isNumber }
+    }
+    
+    /// 금지어 타입별 체크
+    private static func checkBannedWordType(_ nickname: String) -> NicknameTextFieldResultType? {
+        // 관리자/운영자 관련 금지어 체크
+        if NicknameBannedWords.containsAdminWord(nickname) {
+            return .adminRelatedWord
+        }
+        
+        // 서비스명/브랜드명 금지어 체크
+        if NicknameBannedWords.containsServiceName(nickname) {
+            return .serviceNameWord
+        }
+        
+        // 욕설/비속어 체크
+        if NicknameBannedWords.containsProfanity(nickname) {
+            return .profanityWord
+        }
+        
+        return nil
+    }
+}