वैलिडेशन

परिचय

Nylo Website v7 FormValidator क्लास के आधार पर एक वैलिडेशन सिस्टम प्रदान करता है। आप check() मेथड का उपयोग करके पेजों के अंदर डेटा वैलिडेट कर सकते हैं, या स्टैंडअलोन और फ़ील्ड-लेवल वैलिडेशन के लिए सीधे FormValidator का उपयोग कर सकते हैं।

// Validate data in a NyPage/NyState using check()
check((validate) {
  validate.that('user@example.com').email();
  validate.that('Anthony')
              .capitalized()
              .maxLength(50);
}, onSuccess: () {
  print("All validations passed!");
});

// FormValidator with form fields
Field.text("Email", validator: FormValidator.email())

check() के साथ डेटा वैलिडेट करना

किसी भी NyPage के अंदर, डेटा वैलिडेट करने के लिए check() मेथड का उपयोग करें। यह एक कॉलबैक स्वीकार करता है जो वैलिडेटर्स की सूची प्राप्त करता है। डेटा जोड़ने और नियम चेन करने के लिए .that() का उपयोग करें:

class _RegisterPageState extends NyPage<RegisterPage> {

  void handleForm() {
    check((validate) {
      validate.that(_emailController.text, label: "Email").email();
      validate.that(_passwordController.text, label: "Password")
          .notEmpty()
          .password(strength: 2);
    }, onSuccess: () {
      // All validations passed
      _submitForm();
    }, onValidationError: (FormValidationResponseBag bag) {
      // Validation failed
      print(bag.firstErrorMessage);
    });
  }
}

check() कैसे काम करता है

1. check() एक खाली List<FormValidator> बनाता है
2. आपका कॉलबैक .that(data) का उपयोग करके सूची में डेटा के साथ एक नया FormValidator जोड़ता है
3. प्रत्येक .that() एक FormValidator रिटर्न करता है जिस पर आप नियम चेन कर सकते हैं
4. कॉलबैक के बाद, सूची में प्रत्येक वैलिडेटर की जाँच की जाती है
5. परिणाम एक FormValidationResponseBag में एकत्र किए जाते हैं

एकाधिक फ़ील्ड्स वैलिडेट करना

check((validate) {
  validate.that(_nameController.text, label: "Name").notEmpty().capitalized();
  validate.that(_emailController.text, label: "Email").email();
  validate.that(_phoneController.text, label: "Phone").phoneNumberUs();
  validate.that(_ageController.text, label: "Age").numeric().minValue(18);
}, onSuccess: () {
  _submitForm();
});

वैकल्पिक label पैरामीटर एक मानव-पठनीय नाम सेट करता है जो एरर मैसेज में उपयोग किया जाता है (उदा. "The Email must be a valid email address.")।

वैलिडेशन रिज़ल्ट्स

check() मेथड एक FormValidationResponseBag (List<FormValidationResult> की एक सूची) रिटर्न करता है, जिसे आप सीधे भी निरीक्षण कर सकते हैं:

FormValidationResponseBag bag = check((validate) {
  validate.that(_emailController.text, label: "Email").email();
  validate.that(_passwordController.text, label: "Password")
      .password(strength: 1);
});

if (bag.isValid) {
  print("All valid!");
} else {
  // Get the first error message
  String? error = bag.firstErrorMessage;
  print(error);

  // Get all failed results
  List<FormValidationResult> errors = bag.validationErrors;

  // Get all successful results
  List<FormValidationResult> successes = bag.validationSuccess;
}

FormValidationResult

प्रत्येक FormValidationResult एक सिंगल वैल्यू के वैलिडेशन का परिणाम दर्शाता है:

FormValidator validator = FormValidator(data: "test@email.com")
    .email()
    .maxLength(50);

FormValidationResult result = validator.check();

if (result.isValid) {
  print("Valid!");
} else {
  // First error message
  String? message = result.getFirstErrorMessage();

  // All error messages
  List<String> messages = result.errorMessages();

  // Error responses
  List<FormValidationError> errors = result.errorResponses;
}

FormValidator का उपयोग

FormValidator का उपयोग स्टैंडअलोन या फ़ॉर्म फ़ील्ड्स के साथ किया जा सकता है।

स्टैंडअलोन उपयोग

// Using a named constructor
FormValidator validator = FormValidator.email();
FormValidationResult result = validator.check("user@example.com");

if (result.isValid) {
  print("Email is valid");
} else {
  String? errorMessage = result.getFirstErrorMessage();
  print("Error: $errorMessage");
}

कंस्ट्रक्टर में डेटा के साथ

FormValidator validator = FormValidator(data: "user@example.com", attribute: "Email")
    .email()
    .maxLength(50);

FormValidationResult result = validator.check();
print(result.isValid); // true

FormValidator नेम्ड कंस्ट्रक्टर्स

Nylo Website v7 सामान्य वैलिडेशन के लिए नेम्ड कंस्ट्रक्टर्स प्रदान करता है:

// Email validation
FormValidator.email(message: "Please enter a valid email")

// Password validation (strength 1 or 2)
FormValidator.password(strength: 1)
FormValidator.password(strength: 2, message: "Password too weak")

// Phone numbers
FormValidator.phoneNumberUk()
FormValidator.phoneNumberUs()

// URL validation
FormValidator.url()

// Length constraints
FormValidator.minLength(5, message: "Too short")
FormValidator.maxLength(100, message: "Too long")

// Value constraints
FormValidator.minValue(18, message: "Must be 18+")
FormValidator.maxValue(100)

// Size constraints (for lists/strings)
FormValidator.minSize(2, message: "Select at least 2")
FormValidator.maxSize(5)

// Not empty
FormValidator.notEmpty(message: "This field is required")

// Contains values
FormValidator.contains(['option1', 'option2'])

// Starts/ends with
FormValidator.beginsWith("https://")
FormValidator.endsWith(".com")

// Boolean checks
FormValidator.booleanTrue(message: "Must accept terms")
FormValidator.booleanFalse()

// Numeric
FormValidator.numeric()

// Date validations
FormValidator.date()
FormValidator.dateInPast()
FormValidator.dateInFuture()
FormValidator.dateAgeIsOlder(18, message: "Must be 18+")
FormValidator.dateAgeIsYounger(65)

// Text case
FormValidator.uppercase()
FormValidator.lowercase()
FormValidator.capitalized()

// Location formats
FormValidator.zipcodeUs()
FormValidator.postcodeUk()

// Regex pattern
FormValidator.regex(r'^[A-Z]{3}\d{4}$', message: "Invalid format")

// Custom validation
FormValidator.custom(
  message: "Invalid value",
  validate: (data) => data != null,
)

वैलिडेशन नियम चेन करना

इंस्टेंस मेथड्स का उपयोग करके कई नियमों को धाराप्रवाह रूप से चेन करें। प्रत्येक मेथड FormValidator रिटर्न करता है, जिससे आप नियम बना सकते हैं:

FormValidator validator = FormValidator()
    .notEmpty()
    .email()
    .maxLength(50);

FormValidationResult result = validator.check("user@example.com");

if (!result.isValid) {
  List<String> errors = result.errorMessages();
  print(errors);
}

सभी नेम्ड कंस्ट्रक्टर्स के संबंधित चेन करने योग्य इंस्टेंस मेथड्स हैं:

FormValidator()
    .notEmpty(message: "Required")
    .email(message: "Invalid email")
    .minLength(5, message: "Too short")
    .maxLength(100, message: "Too long")
    .beginsWith("user", message: "Must start with 'user'")
    .lowercase(message: "Must be lowercase")

कस्टम वैलिडेशन

कस्टम नियम (इनलाइन)

इनलाइन वैलिडेशन लॉजिक जोड़ने के लिए .custom() का उपयोग करें:

FormValidator.custom(
  message: "Username already taken",
  validate: (data) {
    // Return true if valid, false if invalid
    return !_takenUsernames.contains(data);
  },
)

या इसे अन्य नियमों के साथ चेन करें:

FormValidator()
    .notEmpty()
    .custom(
      message: "Must start with a letter",
      validate: (data) => RegExp(r'^[a-zA-Z]').hasMatch(data.toString()),
    )

इक्वल्स वैलिडेशन

जाँचें कि कोई वैल्यू दूसरी से मेल खाती है:

FormValidator()
    .notEmpty()
    .equals(
      _passwordController.text,
      message: "Passwords must match",
    )

फ़ील्ड्स के साथ FormValidator का उपयोग

FormValidator फ़ॉर्म्स में Field विजेट्स के साथ इंटीग्रेट होता है। validator पैरामीटर में एक वैलिडेटर पास करें:

class RegisterForm extends NyFormData {
  RegisterForm({String? name}) : super(name ?? "register");

  @override
  fields() => [
        Field.text(
          "Name",
          autofocus: true,
          validator: FormValidator.notEmpty(),
        ),
        Field.email("Email", validator: FormValidator.email()),
        Field.password(
          "Password",
          validator: FormValidator.password(strength: 1),
        ),
      ];
}

आप फ़ील्ड्स के साथ चेन किए गए वैलिडेटर्स का भी उपयोग कर सकते हैं:

Field.text(
  "Username",
  validator: FormValidator()
      .notEmpty(message: "Username is required")
      .minLength(3, message: "At least 3 characters")
      .maxLength(20, message: "At most 20 characters"),
)

Field.slider(
  "Rating",
  validator: FormValidator.minValue(4, message: "Rating must be at least 4"),
)

उपलब्ध वैलिडेशन नियम

FormValidator के लिए सभी उपलब्ध नियम, नेम्ड कंस्ट्रक्टर्स और चेन करने योग्य मेथड्स दोनों के रूप में:

सभी नियम एरर मैसेज कस्टमाइज़ करने के लिए एक वैकल्पिक message पैरामीटर स्वीकार करते हैं।

कस्टम वैलिडेशन नियम बनाना

पुन: प्रयोज्य वैलिडेशन नियम बनाने के लिए, FormRule क्लास को एक्सटेंड करें:

class FormRuleUsername extends FormRule {
  @override
  String? rule = "username";

  @override
  String? message = "The {{attribute}} must be a valid username.";

  FormRuleUsername({String? message}) {
    if (message != null) {
      this.message = message;
    }
  }

  @override
  bool validate(data) {
    if (data is! String) return false;
    // Username: alphanumeric, underscores, 3-20 chars
    return RegExp(r'^[a-zA-Z0-9_]{3,20}$').hasMatch(data);
  }
}

message में प्लेसहोल्डर के रूप में {{attribute}} का उपयोग करें -- रनटाइम पर इसे फ़ील्ड के लेबल से बदल दिया जाएगा।

कस्टम FormRule का उपयोग

FormValidator.rule() का उपयोग करके अपना कस्टम नियम FormValidator में जोड़ें:

FormValidator validator = FormValidator.rule([
  FormRuleNotEmpty(),
  FormRuleUsername(),
]);

FormValidationResult result = validator.check("my_username");

या क्लास बनाए बिना एक-बार के नियमों के लिए .custom() मेथड का उपयोग करें:

FormValidator()
    .notEmpty()
    .custom(
      message: "Username must start with a letter",
      validate: (data) => RegExp(r'^[a-zA-Z]').hasMatch(data.toString()),
    )