added bulk email validation through excel and cli tool

Signed-off-by: adarsh-jaiss <[email protected]>

Author: Adarsh-jaiss

README.md

@@ -2,6 +2,17 @@
 
 Mailify is a Go package for validating email addresses by checking their format, verifying the existence of MX records for the domain, and attempting to connect to the mail servers using SMTP.
 
+## CLI 
+
+You can use this as a cli tool on your local machine by installing the mailify cli tool
+
+```bash
+go install github.com/yourusername/mailify-cli@latest
+```
+
+For more details, checkout [CLI DOCS](https://github.com/Adarsh-jaiss/mailify/blob/main/cli/README.md)
+
+
 ## Installation
 
 To install the package, run:
@@ -61,5 +72,19 @@ if err != nil {
 fmt.Println("Mail servers:", mailServers)
 ```
 
+
+### Validate all the email addresses in an Excel file
+
+This section demonstrates how to validate all email addresses in an Excel file using the `ProcessAndValidateEmailsViaExcel` method. The method takes the path to the Excel file and the sender's email as parameters. If there is an error during the processing of the file, it will print an error message and terminate the execution.
+
+Example usage:
+
+```go
+	err = client.ProcessAndValidateEmailsViaExcel("emails.xlsx",client.SenderEmail)
+	if err!= nil {
+         fmt.Printf("Error processing file: %v\n", err)
+         return
+	}
+```
 ### Example
-Here is a complete example demonstrating how to use the package : [check examples](https://github.com/Adarsh-jaiss/mailify/blob/main/cmd/mailify/main.go)
+Here is a complete example demonstrating how to use the package : [check examples](https://github.com/Adarsh-jaiss/mailify/blob/main/example/main.go)

cli/README.md

@@ -0,0 +1,169 @@
+# Mailify CLI
+
+Mailify CLI is a powerful command-line tool for email validation and mail server information retrieval. Built on top of the [mailify](https://github.com/adarsh-jaiss/mailify) library, it provides an easy-to-use interface for validating email addresses and getting mail server details.
+
+## Features
+
+- Single email address validation
+- Bulk email validation using Excel files
+- Mail server lookup for domains
+- Mail server lookup for email addresses
+- Simple flag-based interface
+
+## Installation
+
+### Using Go
+
+```bash
+go install github.com/yourusername/mailify-cli@latest
+```
+
+### Using Binary Releases
+
+Download the latest binary for your platform from the [releases page](https://github.com/yourusername/mailify-cli/releases).
+
+## Usage
+
+The CLI tool uses a flag-based interface where all operations are performed using the main `mailify` command with different flags.
+
+### Required Flag
+
+- `-s, --sender`: Sender email address (required for all operations)
+
+### Operation Flags
+
+You can use one of the following operation flags per command:
+
+- `-v, --validate`: Validate a single email address
+- `-e, --excel`: Process and validate emails from an Excel file
+- `-d, --domain`: Get mail servers for a domain
+- `-r, --receipient`: Get mail servers for a recipient email
+
+### Examples
+
+1. **Validate a single email address**
+```bash
+mailify -s [email protected] -v [email protected]
+```
+
+2. **Bulk validate emails from Excel file**
+```bash
+mailify -s [email protected] -e emails.xlsx
+```
+
+3. **Get mail servers for a domain**
+```bash
+mailify -s [email protected] -d example.com
+```
+
+4. **Get mail servers for an email address**
+```bash
+mailify -s [email protected] -r [email protected]
+```
+
+### Help
+
+```bash
+mailify --help
+```
+
+## Development Setup
+
+1. Clone the repository
+```bash
+git clone https://github.com/yourusername/mailify-cli.git
+cd mailify-cli
+```
+
+2. Install dependencies
+```bash
+go mod download
+```
+
+3. Build the project
+```bash
+go build -o mailify
+```
+
+## Release Process
+
+### Using GoReleaser
+
+1. Install GoReleaser:
+```bash
+brew install goreleaser
+```
+
+2. Create `.goreleaser.yml`:
+```yaml
+before:
+  hooks:
+    - go mod tidy
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - windows
+      - darwin
+    goarch:
+      - amd64
+      - arm64
+    binary: mailify
+archives:
+  - replacements:
+      darwin: Darwin
+      linux: Linux
+      windows: Windows
+      amd64: x86_64
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: "{{ incpatch .Version }}-next"
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+```
+
+3. Release Steps:
+```bash
+# Create and push a new tag
+git tag -a v0.1.0 -m "First release"
+git push origin v0.1.0
+
+# Set GitHub token
+export GITHUB_TOKEN="your-github-token"
+
+# Create release
+goreleaser release --rm-dist
+```
+
+## Excel File Format
+
+When using the `-e, --excel` flag, your Excel file should:
+- Have a column containing email addresses
+- Be in `.xlsx` format
+- The tool will create a new column with validation results
+
+## Error Handling
+
+- If no operation flag is specified, the tool will show an error message
+- All operations will return meaningful error messages if something goes wrong
+- The tool validates inputs before processing
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Support
+
+If you encounter any issues or have questions, please:
+1. Check the [GitHub Issues](https://github.com/yourusername/mailify-cli/issues)
+2. Create a new issue if your problem isn't already reported

cli/cmd/root.go

@@ -0,0 +1,138 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/adarsh-jaiss/mailify"
+	"github.com/spf13/cobra"
+)
+
+// senderEmail represents the email address of the sender.
+var (
+	senderEmail    string
+	client         *mailify.Client
+	emailToCheck   string
+	excelFile      string
+	domain         string
+	receipientEmail string
+)
+
+// rootCmd represents the base command for the Mailify CLI tool
+// rootCmd represents the base command when called without any subcommands.
+// It provides functionality to validate email addresses and get mail server information.
+// 
+// Usage:
+//   mailify [flags]
+// 
+// Flags:
+//   -e, --email string       Email address to validate
+//   -x, --excel string       Path to Excel file for bulk email validation
+//   -d, --domain string      Domain to get mail servers for
+//   -r, --receipient string  Email address to get mail servers for
+// 
+// Examples:
+//   # Validate a single email address
+//   mailify --email [email protected]
+// 
+//   # Bulk validate emails from an Excel file
+//   mailify --excel emails.xlsx
+// 
+//   # Get mail servers for a domain
+//   mailify --domain example.com
+// 
+//   # Get mail servers for an email address
+//   mailify --receipient [email protected]
+// 
+// If no flags are provided, an error will be returned indicating that no operation was specified.
+var rootCmd = &cobra.Command{
+	Use:   "mailify",
+	Short: "Mailify is a CLI tool for email validation and server information",
+	Long: `Mailify CLI provides functionality to validate email addresses and get mail server information.
+It can process single email addresses or bulk validate emails from Excel files.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		// Initialize client
+		var err error
+		client, err = mailify.NewClient(senderEmail)
+		if err != nil {
+			return fmt.Errorf("failed to create mailify client: %v", err)
+		}
+
+		// Handle single email validation
+		if emailToCheck != "" {
+			result, err := client.ValidateEmail(emailToCheck)
+			if err != nil {
+				return fmt.Errorf("failed to validate email: %v", err)
+			}
+			fmt.Println(client.FormatValidationResult(emailToCheck, result))
+		}
+
+		// Handle bulk validation from Excel
+		if excelFile != "" {
+			err := client.ProcessAndValidateEmailsViaExcel(excelFile, client.SenderEmail)
+			if err != nil {
+				return fmt.Errorf("failed to process Excel file: %v", err)
+			}
+			fmt.Println("Successfully processed and validated emails in", excelFile)
+		}
+
+		// Handle domain mail servers
+		if domain != "" {
+			servers, err := client.GetMailServers(domain)
+			if err != nil {
+				return fmt.Errorf("failed to get mail servers: %v", err)
+			}
+			fmt.Println("Mail servers for", domain+":")
+			for _, server := range servers {
+				fmt.Println("-", server)
+			}
+		}
+
+		// Handle email mail servers
+		if receipientEmail != "" {
+			servers, err := client.GetMailServersFromReceipientEmail(receipientEmail)
+			if err != nil {
+				return fmt.Errorf("failed to get mail servers: %v", err)
+			}
+			fmt.Println("Mail servers for", receipientEmail+":")
+			for _, server := range servers {
+				fmt.Println("-", server)
+			}
+		}
+
+		// Check if no flags were provided
+		if emailToCheck == "" && excelFile == "" && domain == "" && receipientEmail == "" {
+			return fmt.Errorf("no operation specified. Use --help to see available flags")
+		}
+
+		return nil
+	},
+}
+
+// Execute runs the root command and handles any errors that occur during its execution.
+// If an error is encountered, it prints the error message and exits the program with a status code of 1.
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+// init initializes the command-line flags for the root command.
+// It sets up the following flags:
+// - sender: Required flag for specifying the sender email address.
+// - validate: Optional flag for validating a single email address.
+// - excel: Optional flag for processing and validating emails from an Excel file.
+// - domain: Optional flag for getting mail servers for a domain.
+// - receipient: Optional flag for getting mail servers for a recipient email.
+func init() {
+	// Required sender email flag
+	rootCmd.Flags().StringVarP(&senderEmail, "sender", "s", "", "Sender email address (required)")
+	rootCmd.MarkFlagRequired("sender")
+
+	// Operation flags
+	rootCmd.Flags().StringVarP(&emailToCheck, "validate", "v", "", "Validate a single email address")
+	rootCmd.Flags().StringVarP(&excelFile, "excel", "e", "", "Process and validate emails from an Excel file")
+	rootCmd.Flags().StringVarP(&domain, "domain", "d", "", "Get mail servers for a domain")
+	rootCmd.Flags().StringVarP(&receipientEmail, "receipient", "r", "", "Get mail servers for a receipient email")
+}

cli/mailify

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"github.com/adarsh-jaiss/mailify/cli/cmd"
+)
+
+func main() {
+	cmd.Execute()
+}

cli/main.go

@@ -8,13 +8,13 @@ import (
 )
 
 func main() {
-	// Create a new mailguard client
+	// Create a new mailify client
 	senderEmail := "[email protected]"
 	receipientEmail := "[email protected]"
 
 	client, err := mailify.NewClient(senderEmail)
 	if err != nil {
-		log.Fatalf("Failed to create mailguard client: %v", err)
+		log.Fatalf("Failed to create mailify client: %v", err)
 	}
 
 	// Get mail servers for a domain
@@ -39,4 +39,11 @@ func main() {
 
 	fmt.Println("Validation result:", client.FormatValidationResult(receipientEmail,result))
 
+	// Validate all the email address in an Excel file, creates a new column with the validation result
+	err = client.ProcessAndValidateEmailsViaExcel("emails.xlsx",client.SenderEmail)
+	if err!= nil {
+         fmt.Printf("Error processing file: %v\n", err)
+         return
+	}
+
 }