Forem: Mansuur Abdullahi

Simplify Your Dropdown Management with populateDropdown

Mansuur Abdullahi — Tue, 19 Nov 2024 09:24:27 +0000

Let's jump into this! Imagine you're building a dynamic web application, and one of the common tasks is populating dropdown menus based on various data sources. Without a streamlined method, you'd find yourself writing repetitive and error-prone code, which can be a nightmare to maintain. This is where a simple yet powerful function, like populateDropdown, comes to the rescue. It eliminates the hassle and makes your life a whole lot easier.

Problem Statement

When creating web applications, handling dropdowns dynamically can be messy and cumbersome:

Repetition: Writing the same HTML option elements for every dropdown is tedious.
Errors: Manually adding options increases the risk of missing or incorrect entries.
Maintenance: Hard-coded options are difficult to update and manage.

Solution

The populateDropdown function offers a clean and efficient way to populate dropdown menus dynamically. It:
Automates the generation of options based on data arrays.
Customizes attributes, text, and values seamlessly.
Simplifies updates and maintenance of dropdown content.

Here how it works?

Here's the function

/**
 * Populates a dropdown dynamically with customizable attributes, text, and value.
 * @param {string} selector - The dropdown selector.
 * @param {Array} data - The array of objects containing data for the options.
 * @param {string} defaultOption - The default placeholder text for the dropdown.
 * @param {string} textKey - The key in the data object to use for option text.
 * @param {string} valueKey - The key in the data object to use for the value attribute.
 * @param {Array} [attributeKeys] - An array of keys from the data object to use as attributes for options.
 */
function populateDropdown(selector, data, defaultOption = "Select Option", textKey, valueKey, attributeKeys = []) {
  let options = `<option value=''>${defaultOption}</option>`;

  data.forEach((item) => {
    let attrString = attributeKeys
      .map((key) => (item[key] ? `${key}='${item[key]}'` : ""))
      .join(" ");

    options += `<option value='${item[valueKey]}' ${attrString}>${item[textKey]}</option>`;
  });

  $(selector).html(options).attr("disabled", false);
}

Examples

Let's say you have a dropdown for selecting fruits and your data looks like this:

const fruitData = [ 
 { id: 1, name: 'Apple', color: 'red' }, 
 { id: 2, name: 'Banana', color: 'yellow' }, 
 { id: 3, name: 'Cherry', color: 'red' }, 
];

You can populate your dropdown like this:

populateDropdown(
  '#fruitDropdown', 
  fruitData, 
  'Choose a Fruit', 
  'name', 
  'id', 
  ['color']
);

This function will dynamically generate options with text as fruit names, values as their IDs, and an additional color attribute for each option. Your HTML might look something like this:

<select id="fruitDropdown"> 
  <option value=''>Choose a Fruit</option> 
  <option value='1' color='red'>Apple</option> 
  <option value='2' color='yellow'>Banana</option> 
  <option value='3' color='red'>Cherry</option> 
</select>

Why You Need This Function

Efficiency: Streamlines dropdown creation, reducing code redundancy.
Reliability: Minimizes errors by automatically generating options.
Flexibility: Easily adapts to different data structures and requirements.
Maintenance: Simplifies updates and future-proofing of your code.

By using populateDropdown, you're not just writing cleaner code—you're also ensuring your dropdowns are dynamic, adaptable, and easy to manage. This function can be your secret weapon for handling dropdown menus with ease and confidence.

I hope this gives you a clear picture of why this function is beneficial and how to use it effectively.

Exception Handling In Django & Python Using Decorators

Mansuur Abdullahi — Tue, 19 Dec 2023 08:31:28 +0000

When developing in Django, effective exception handling is crucial for maintaining a robust and resilient application. Here's a concise guide on how to enhance your error management using decorators

Model Definition

# Importing necessary modules from Django
from django.db import models

# Defining a Django model for Users
class Users(models.Model):
    pass  # Placeholder, as the Users model does not have any fields defined

# Defining a Django model for ErrorLogs
class ErrorLogs(models.Model):
    # Defining a foreign key relationship with the Users model
    user = models.ForeignKey(
        Users, on_delete=models.SET_NULL, related_name='user_in_error_logs', null=True, blank=True
    )
    # Storing the expected error message
    expected_error = models.CharField(max_length=500)
    # Storing the field-specific error message
    field_error = models.CharField(max_length=500)
    # Storing the trace back information for debugging
    trace_back = models.TextField(max_length=500)
    # Storing the line number where the error occurred
    line_number = models.IntegerField()
    # Storing the date and time when the error was recorded (auto-generated)
    date_recorded = models.DateTimeField(auto_now_add=True)
    # Storing the browser information where the error occurred
    browser = models.CharField(max_length=500)
    # Storing the IP address from where the error was reported
    ip_address = models.CharField(max_length=500)
    # Storing the operating system information where the error occurred
    os = models.TextField(max_length=500)

    # Meta class to specify additional options for the model
    class Meta:
        # Specifying the database table name for the model
        db_table = 'errorlogs'

Handling Exceptions

# Importing necessary modules and packages
from django.http import JsonResponse
from django.shortcuts import render
from functools import wraps
import httpagentparser, traceback, sys

# Importing the ErrorLogs model from the 'app' Django application
from app.models import ErrorLogs

# Importing custom packages
from customHandlers.generator import Messages


class Messages:
    def validation_message(message, input=None):
        return {
            'title': "Validation Error",
            'icon': "warning",
            'message': message,
            'isError': True,
            'input': input
        }

    def unauthenticated_message(message, input=None):
        return {
            'title': "Unauthenticated Error",
            'icon': "warning",
            'message': message,
            'isError': True,
            'input': input
        }

    def exception_message(message, input=None):
        return {
            'title': "Exception Error",
            'icon': "error",
            'message': message,
            'isError': True,
            'input': input
        }

    def success_message(message, input=None):
        return {
            'title': "Congratulations",
            'icon': "success",
            'message': message,
            'isError': False,
            'input': input
        }

    def unrecognized_message(message="You don't have permission to perform this action", input=None):
        return {
            'title': "Unrecognized",
            'icon': "warning",
            'message': message,
            'isError': True,
            'input': input
        }

def sendException(request, error):
    """
    Log and save information about an exception.

    :param request: HttpRequest object.
    :param error: Exception object.
    """
    user = request.user if request.user.is_authenticated else None

    ip = request.META.get('REMOTE_ADDR')
    get_client_agent = request.META['HTTP_USER_AGENT']

    # Parsing user agent information
    detect_os = httpagentparser.detect(get_client_agent)['os']['name']
    browser = httpagentparser.detect(get_client_agent)['browser']['name']

    trace_err = traceback.format_exc()
    expected_error = str(sys.exc_info()[0])
    field_error = str(sys.exc_info()[1])
    line_number = str(sys.exc_info()[-1].tb_lineno)

    # Creating an ErrorLogs instance and saving it to the database
    error_logs = ErrorLogs(
        user=user,
        ip_address=ip,
        browser=browser,
        expected_error=expected_error,
        field_error=field_error,
        trace_back=str(trace_err),
        line_number=line_number,
        os=detect_os,
    )
    error_logs.save()

def handle_exceptions():
    """
    Decorator function to handle exceptions in views.

    If an exception occurs, log the exception and return a JsonResponse with an error message.

    :return: Decorator function
    """
    def decorator(view_func):
        @wraps(view_func)
        def wrapper(request, *args, **kwargs):
            try:
                # Call the original view function
                return view_func(request, *args, **kwargs)
            except Exception as error:
                # Log the exception and return an error message
                sendException(request, error)
                return JsonResponse(Messages.exception_message('Oops! Something went wrong. Please try again later or contact support at support@example.com for assistance.'))

        return wrapper
    return decorator

Handling Exceptions

from django.shortcuts import render

from app.customHandlers import handle_exceptions

@handle_exceptions
def YourViewPage(request):
    return render(request , 'page.html' , {})

Exception handling made easy 💡 Dive into the details and level up your Django development

Learn with me a project management

Mansuur Abdullahi — Tue, 21 Nov 2023 11:23:39 +0000

Project Management

Project management is the practice of planning, organizing, and overseeing the successful completion of a project. It involves defining project goals, creating a project plan, managing resources, tracking progress, and ensuring that the project is delivered on time and within budget.

Project Management is the use of specific knowledge, skills, tools and techniques to deliver something of value to people.

Project is a temporary endeavor undertaken to create a unique product, service, or result. It is characterized by a defined beginning and end, specific objectives, and allocated resources.

**Endeavor** means “Try hard to do or achieve something.”

A program is a group of related projects managed in a coordinated way to achieve specific strategic objectives. It involves managing multiple projects that are interdependent and contribute to a common goal or outcome. Program management focuses on aligning projects with organizational goals, ensuring coordination and integration between projects, and optimizing resource allocation across the program.

A portfolio is a collection of projects, programs, and other work that are grouped together to achieve strategic objectives. It represents the entire set of projects and programs being undertaken by an organization. Portfolio management involves selecting and prioritizing projects and programs based on their alignment with organizational objectives, balancing resource allocation across the portfolio, and monitoring the overall performance and progress of the portfolio.

The differences between project, program and Portfolio

A project is an endeavor that is unique, temporary, completable and measurable.
A program is a collection of large, long-term, general and strategic projects
A portfolio is a collection of projects and programs that are ongoing and aligns with the organization’s strategic objectives.

General/Operational Management is concerned with ongoing, day-to-day operations within an organization. It involves managing the regular activities and processes that are necessary for the organization to function effectively and efficiently. Unlike projects, general/operational management does not have a defined end date and is focused on maintaining and improving the ongoing operations of the organization.

In summary, project management is focused on the successful completion of specific projects with defined objectives, while general/operational management is concerned with the ongoing management of an organization's regular operations.

A CEO (Chief executive officer) is the top-ranking employee in a company's structure. They set the overall direction of a company and make strategic decisions about the long-term success of the business.

A COO (Chief operations officer) is seen as the second top-ranking individual and is in charge of the day-to-day operations of the company.

Effects of a project management

Increase the success rate
Mitigate risks
Reduce costs
Understand roles and responsibilities
Collaborate
Utilize resources

The benefits of project management include:

Increase the success rate of projects.
Mitigate risks by identifying and addressing potential issues early on.
Reduce costs by effectively managing resources and optimizing project processes.
Understand roles and responsibilities of team members, leading to better coordination and collaboration.
Collaborate effectively with stakeholders, ensuring their involvement and satisfaction.
Utilize resources efficiently, maximizing productivity and minimizing waste.

Mitigate means “Reduce”

Project requirements

Team agreement
Project Goals “The entire should agree to the project goals”
Develop requirements

Type of constraints of project management

Cost refers to the budget allocated to the project.
Scope defines the boundaries of the project.
Quality refers to the standard of deliverables and the degree to which the project meets specified requirements.
Risk
Resources
Time starting and ending date or Deadline date

Standard means “an ideal or set of criteria that you use to judge things against”

How to send email in Django

Mansuur Abdullahi — Mon, 16 Oct 2023 12:54:59 +0000

To send an email in Django, we need to simple steps

Step 1:

Open settings.py and put the code below somewhere in your file

# Email sending configuration
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'your-smtp-server.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = "email_sender@gmail.com"
EMAIL_HOST_PASSWORD = "email_password"

Step 2:

Once you done those configurations, now you we can perform sending email

// Import those packages
from django.core.mail import send_mail
from django.conf import settings
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
import os
import smtplib
import ssl


// function that handles sending your email
def SendEmail(email_subject, email_message, email_reciever):
    sender_email = settings.EMAIL_HOST_USER  # Set the sender's email address
    receiver_email = email_reciever  # Set the recipient's email address
    password = settings.EMAIL_HOST_PASSWORD  # Set the password for the sender's email account

    message = MIMEMultipart("alternative")  # Create a MIME multipart message
    message["Subject"] = email_subject  # Set the email subject
    message["From"] = sender_email  # Set the sender of the email
    message["To"] = receiver_email  # Set the recipient of the email

    # Create the plain-text and HTML version of the email message
    text = email_message

    # Turn the plain-text version into a plain MIMEText object
    part1 = MIMEText(text, "plain")

    # Add the plain-text part to the MIMEMultipart message
    # The email client will try to render the last part first
    message.attach(part1)

    try:
        # Create a secure connection with the email server and send the email
        context = ssl.create_default_context()
        with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
            server.login(sender_email, password)  # Log in to the email server
            server.sendmail(
                sender_email, receiver_email, message.as_string()
            )  # Send the email
    except Exception as error:
        print('Exception Occurred', error)  # Print any exceptions that occur during the process

Step 3:

This is how we can use it

subject = "Hello from Assistant"
message = "This is a test email sent using the SendEmail function."
receiver = "example@example.com"

SendEmail(subject, message, receiver)

This is how we can send an email using Django