django-forms-frontend-validation 1.0.0__tar.gz

django_forms_frontend_validation-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-Present Andrew Kyle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_forms_frontend_validation-1.0.0/MANIFEST.in

@@ -0,0 +1,10 @@
+# Include the LICENSE and README
+include LICENSE
+include README.md
+
+# Include specific static and template files
+recursive-include formvalidator/static *
+recursive-include formvalidator/templates *
+
+# Exclude the node_modules directory
+prune formvalidator/static/webpack/node_modules

django_forms_frontend_validation-1.0.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: django-forms-frontend-validation
+Version: 1.0.0
+Summary: A Django app for front-end form validation
+Home-page: https://github.com/andrew-kyle92/django-frontend-validation
+Author: Andrew Kyle
+Author-email: andrew.kyle92@yahoo.com
+License: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+
+# django-forms-frontend-validation App
+___
+
+This project provides a comprehensive system for handling and validating HTML forms in Django applications. It combines client-side JavaScript-based validation and server-side Python logic for robust form processing.
+
+The application is designed to streamline the process of form validation, ensuring user inputs meet the requirements before submitting them to the server. The system offers features like automatic required-field validation, error handling, and dynamic CSRF token management for secure data transmission.
+
+## Features
+- Client-Side Validation: 
+  - Automatically validates required fields.
+  - Displays validation errors inline and dynamically updates them upon correction.
+  - Adds asterisks to labels of required fields for better user clarity.
+- Server-Side Settings:
+  - Control which forms and fields to ignore during validation.
+  - Define validation behavior, such as enforcing checks only on form submission.
+- Integration with Django Settings:
+  - Use Django's settings to dynamically configure validation rules.
+- Secure Fetch Calls:
+  - Includes CSRF token management for secure AJAX-based form submissions.
+
+## Usage
+### Setting Up
+1. Include Required Components:
+   - Include the JavaScript files in your project to enable client-side functionality.
+   - Ensure `form_utils.py` is imported and accessible in your Django app.
+2. Define Settings in settings.py
+   - Add `formvalidator` to installed apps.
+      ```python
+      INSTALLED_APPS = [
+        ...,
+        'formvalidator',
+      ]
+      ```
+   - Configure the following variables to customize the behavior.
+      ```python
+      IGNORED_CLASSES = ['example-class', 'example-class-2', ...]
+      IGNORE_VALIDATION = ['example-ignore-validation', ...]
+      VALIDATE_ONLY_ON_SUBMIT = ['all']  # Options: "__all__", specific class names, or leave empty.
+      ```
+3. Initial Forms:
+   - Ensure the `_InitializeForms` method is called during page load to attach validation logic to forms dynamically.
+   To your HTML template with the form, add this.
+   ```html
+    <script>
+    // fv (formsvalidator) is exported from forms.bundle.js
+    window.addEventListener("load", () => {
+        let ignoredClasses = {{ form_validator.ignored_classes|safe }}; // add more classes that represent forms you want this script to ignore.
+        let ignoreValidation = {{ form_validator.ignore_validation|safe }}; // add any form classes that you want to ignore validation
+        let validateOnlyOnSubmit = {{ form_validator.validate_only_on_submit|safe }}; // for hitting all forms make index 0 either __all__, all, * or leave blank for false or use false
+        let forms = document.getElementsByTagName("form");
+        // if (form || userForm) {
+        if (forms.length > 0) {
+            // calling specific functions on all forms
+            fv._InitializeForms(forms, ignoredClasses, ignoreValidation, validateOnlyOnSubmit);
+        }
+    });
+   </script>
+   ```
+4. Server-Side Context:
+   - Use the `FormsValidator` class to pass configuration to templates:
+   ```python
+    from formvalidator.form_utils import FormsValidator
+   
+   
+    def my_view(request):
+        form_validator = FormsValidator()
+        context = {
+            'form_validator': form_validator.get_context(),
+        }    
+        return render(request, 'my_template.html', context)
+   ```

django_forms_frontend_validation-1.0.0/README.md

@@ -0,0 +1,71 @@
+# django-forms-frontend-validation App
+___
+
+This project provides a comprehensive system for handling and validating HTML forms in Django applications. It combines client-side JavaScript-based validation and server-side Python logic for robust form processing.
+
+The application is designed to streamline the process of form validation, ensuring user inputs meet the requirements before submitting them to the server. The system offers features like automatic required-field validation, error handling, and dynamic CSRF token management for secure data transmission.
+
+## Features
+- Client-Side Validation: 
+  - Automatically validates required fields.
+  - Displays validation errors inline and dynamically updates them upon correction.
+  - Adds asterisks to labels of required fields for better user clarity.
+- Server-Side Settings:
+  - Control which forms and fields to ignore during validation.
+  - Define validation behavior, such as enforcing checks only on form submission.
+- Integration with Django Settings:
+  - Use Django's settings to dynamically configure validation rules.
+- Secure Fetch Calls:
+  - Includes CSRF token management for secure AJAX-based form submissions.
+
+## Usage
+### Setting Up
+1. Include Required Components:
+   - Include the JavaScript files in your project to enable client-side functionality.
+   - Ensure `form_utils.py` is imported and accessible in your Django app.
+2. Define Settings in settings.py
+   - Add `formvalidator` to installed apps.
+      ```python
+      INSTALLED_APPS = [
+        ...,
+        'formvalidator',
+      ]
+      ```
+   - Configure the following variables to customize the behavior.
+      ```python
+      IGNORED_CLASSES = ['example-class', 'example-class-2', ...]
+      IGNORE_VALIDATION = ['example-ignore-validation', ...]
+      VALIDATE_ONLY_ON_SUBMIT = ['all']  # Options: "__all__", specific class names, or leave empty.
+      ```
+3. Initial Forms:
+   - Ensure the `_InitializeForms` method is called during page load to attach validation logic to forms dynamically.
+   To your HTML template with the form, add this.
+   ```html
+    <script>
+    // fv (formsvalidator) is exported from forms.bundle.js
+    window.addEventListener("load", () => {
+        let ignoredClasses = {{ form_validator.ignored_classes|safe }}; // add more classes that represent forms you want this script to ignore.
+        let ignoreValidation = {{ form_validator.ignore_validation|safe }}; // add any form classes that you want to ignore validation
+        let validateOnlyOnSubmit = {{ form_validator.validate_only_on_submit|safe }}; // for hitting all forms make index 0 either __all__, all, * or leave blank for false or use false
+        let forms = document.getElementsByTagName("form");
+        // if (form || userForm) {
+        if (forms.length > 0) {
+            // calling specific functions on all forms
+            fv._InitializeForms(forms, ignoredClasses, ignoreValidation, validateOnlyOnSubmit);
+        }
+    });
+   </script>
+   ```
+4. Server-Side Context:
+   - Use the `FormsValidator` class to pass configuration to templates:
+   ```python
+    from formvalidator.form_utils import FormsValidator
+   
+   
+    def my_view(request):
+        form_validator = FormsValidator()
+        context = {
+            'form_validator': form_validator.get_context(),
+        }    
+        return render(request, 'my_template.html', context)
+   ```

django_forms_frontend_validation-1.0.0/django_forms_frontend_validation.egg-info/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: django-forms-frontend-validation
+Version: 1.0.0
+Summary: A Django app for front-end form validation
+Home-page: https://github.com/andrew-kyle92/django-frontend-validation
+Author: Andrew Kyle
+Author-email: andrew.kyle92@yahoo.com
+License: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Django>=3.2
+
+# django-forms-frontend-validation App
+___
+
+This project provides a comprehensive system for handling and validating HTML forms in Django applications. It combines client-side JavaScript-based validation and server-side Python logic for robust form processing.
+
+The application is designed to streamline the process of form validation, ensuring user inputs meet the requirements before submitting them to the server. The system offers features like automatic required-field validation, error handling, and dynamic CSRF token management for secure data transmission.
+
+## Features
+- Client-Side Validation: 
+  - Automatically validates required fields.
+  - Displays validation errors inline and dynamically updates them upon correction.
+  - Adds asterisks to labels of required fields for better user clarity.
+- Server-Side Settings:
+  - Control which forms and fields to ignore during validation.
+  - Define validation behavior, such as enforcing checks only on form submission.
+- Integration with Django Settings:
+  - Use Django's settings to dynamically configure validation rules.
+- Secure Fetch Calls:
+  - Includes CSRF token management for secure AJAX-based form submissions.
+
+## Usage
+### Setting Up
+1. Include Required Components:
+   - Include the JavaScript files in your project to enable client-side functionality.
+   - Ensure `form_utils.py` is imported and accessible in your Django app.
+2. Define Settings in settings.py
+   - Add `formvalidator` to installed apps.
+      ```python
+      INSTALLED_APPS = [
+        ...,
+        'formvalidator',
+      ]
+      ```
+   - Configure the following variables to customize the behavior.
+      ```python
+      IGNORED_CLASSES = ['example-class', 'example-class-2', ...]
+      IGNORE_VALIDATION = ['example-ignore-validation', ...]
+      VALIDATE_ONLY_ON_SUBMIT = ['all']  # Options: "__all__", specific class names, or leave empty.
+      ```
+3. Initial Forms:
+   - Ensure the `_InitializeForms` method is called during page load to attach validation logic to forms dynamically.
+   To your HTML template with the form, add this.
+   ```html
+    <script>
+    // fv (formsvalidator) is exported from forms.bundle.js
+    window.addEventListener("load", () => {
+        let ignoredClasses = {{ form_validator.ignored_classes|safe }}; // add more classes that represent forms you want this script to ignore.
+        let ignoreValidation = {{ form_validator.ignore_validation|safe }}; // add any form classes that you want to ignore validation
+        let validateOnlyOnSubmit = {{ form_validator.validate_only_on_submit|safe }}; // for hitting all forms make index 0 either __all__, all, * or leave blank for false or use false
+        let forms = document.getElementsByTagName("form");
+        // if (form || userForm) {
+        if (forms.length > 0) {
+            // calling specific functions on all forms
+            fv._InitializeForms(forms, ignoredClasses, ignoreValidation, validateOnlyOnSubmit);
+        }
+    });
+   </script>
+   ```
+4. Server-Side Context:
+   - Use the `FormsValidator` class to pass configuration to templates:
+   ```python
+    from formvalidator.form_utils import FormsValidator
+   
+   
+    def my_view(request):
+        form_validator = FormsValidator()
+        context = {
+            'form_validator': form_validator.get_context(),
+        }    
+        return render(request, 'my_template.html', context)
+   ```

django_forms_frontend_validation-1.0.0/django_forms_frontend_validation.egg-info/SOURCES.txt

@@ -0,0 +1,32 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+django_forms_frontend_validation.egg-info/PKG-INFO
+django_forms_frontend_validation.egg-info/SOURCES.txt
+django_forms_frontend_validation.egg-info/dependency_links.txt
+django_forms_frontend_validation.egg-info/requires.txt
+django_forms_frontend_validation.egg-info/top_level.txt
+formvalidator/__init__.py
+formvalidator/admin.py
+formvalidator/apps.py
+formvalidator/forms.py
+formvalidator/models.py
+formvalidator/settings.py
+formvalidator/tests.py
+formvalidator/urls.py
+formvalidator/views.py
+formvalidator/form_utils/__init__.py
+formvalidator/form_utils/form_utils.py
+formvalidator/migrations/__init__.py
+formvalidator/static/dist/forms.bundle.js
+formvalidator/static/webpack/package-lock.json
+formvalidator/static/webpack/package.json
+formvalidator/static/webpack/webpack.config.js
+formvalidator/static/webpack/src/css/style.css
+formvalidator/static/webpack/src/js/formFunctions.js
+formvalidator/static/webpack/src/js/index.js
+formvalidator/templates/base.html
+formvalidator/templates/formvalidator/sample.html
+formvalidator/templates/formvalidator/sample2.html
+formvalidator/templates/includes/header.html

django_forms_frontend_validation-1.0.0/django_forms_frontend_validation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_forms_frontend_validation-1.0.0/django_forms_frontend_validation.egg-info/requires.txt

@@ -0,0 +1 @@
+Django>=3.2

django_forms_frontend_validation-1.0.0/django_forms_frontend_validation.egg-info/top_level.txt

@@ -0,0 +1 @@
+formvalidator

django_forms_frontend_validation-1.0.0/formvalidator/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

django_forms_frontend_validation-1.0.0/formvalidator/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class FormvalidatorConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'formvalidator'

django_forms_frontend_validation-1.0.0/formvalidator/form_utils/__init__.py

@@ -0,0 +1 @@
+from .form_utils import FormsValidator

django_forms_frontend_validation-1.0.0/formvalidator/form_utils/form_utils.py

@@ -0,0 +1,21 @@
+from django.conf import settings
+
+
+class FormsValidator:
+    """
+    Provides access to settings for ignored classes and validation behavior.
+    """
+    def __init__(self):
+        self.ignored_classes = settings.IGNORED_CLASSES
+        self.ignore_validation = settings.IGNORE_VALIDATION
+        self.validate_only_on_submit = settings.VALIDATE_ONLY_ON_SUBMIT
+
+    def get_context(self):
+        """
+        Returns a dictionary for use in template contexts
+        """
+        return {
+            'ignored_classes': self.ignored_classes,
+            'ignore_validation': self.ignore_validation,
+            'validate_only_on_submit': self.validate_only_on_submit
+        }

django_forms_frontend_validation-1.0.0/formvalidator/forms.py

@@ -0,0 +1,9 @@
+from django import forms
+
+
+class SampleForm(forms.Form):
+    first_name = forms.CharField(label='First Name', max_length=100, required=True, widget=forms.TextInput(attrs={'class': 'form-control'}))
+    last_name = forms.CharField(label='Last Name', max_length=100, required=True, widget=forms.TextInput(attrs={'class': 'form-control'}))
+    email = forms.EmailField(label='Email', max_length=100, required=True, widget=forms.TextInput(attrs={'class': 'form-control'}))
+    phone = forms.CharField(label='Phone Number', max_length=100, required=False, widget=forms.TextInput(attrs={'class': 'form-control'}))
+    address = forms.CharField(label='Address', max_length=100, required=False, widget=forms.Textarea(attrs={'class': 'form-control', 'rows': 5, 'cols': 50}))

django_forms_frontend_validation-1.0.0/formvalidator/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

django_forms_frontend_validation-1.0.0/formvalidator/settings.py

@@ -0,0 +1,14 @@
+# ##### Form Configs #####
+# A list of HTML classes of forms you want to ignore, completely
+IGNORED_CLASSES = []
+
+# Ignoring validation doesn't automatically assume you're omitting the form from being
+# the form submittal process. It literally just means you would like to ignore all validation.
+IGNORE_VALIDATION = [] + IGNORED_CLASSES
+
+# A list of classes where the validation is done only after the submit button has been clicked.
+# the types can be boolean, string, or list
+# the string keyword options are 'all', '__all__', '*'
+# if you would like to keep the type as an array, but still want to hit all forms, you can just set
+# index 0 as one of those keywords
+VALIDATE_ONLY_ON_SUBMIT = ["*"]