Forem: derekzyl

# How I Fixed Our Auth Bottleneck: From Some Seconds to Instant

derekzyl — Thu, 09 Oct 2025 22:25:00 +0000

Last week, our cart operations were taking 18+ seconds. Not minutes—seconds. Each time a user added something to their cart, they'd wait nearly 20 seconds staring at a loading spinner. Meanwhile, our public pages? Lightning fast.

Something was very, very wrong.

Finding the Problem

The weird part was the inconsistency. Public endpoints responded in milliseconds. But anything requiring authentication? Painful. I pulled up the network inspector and there it was—18.72 seconds spent "waiting for server response."

Not network latency. Not a slow database query. The auth middleware itself was the bottleneck.

Here's the thing—I'd already spent weeks optimizing every route. Added indexes, optimized queries, used .lean() for read operations, implemented proper pagination. The cart service? Optimized. The wishlist endpoints? Optimized. Product queries? All good.

But none of that mattered because the auth middleware was running before every single route, killing performance before my optimized code even got a chance to run.

Here's what was happening on every single authenticated request:

const verifyCallback = async (err, user, info) => {
  // ... auth checks ...

  const roles = await ROLES.find();  // Hit the database
  const mapRoles = {};

  for (const role of roles) {
    // Another database hit for EACH role
    const permissions = await convertPermissionIdsToNames(role.permissions);
    mapRoles[role.name] = permissions;
  }

  // ... permission checking ...
};

Every. Single. Request.

For a system where roles and permissions rarely change (maybe once a month?), we were hammering the database constantly. Classic N+1 query problem, running on every auth check.

The Fix: Three Layers of Caching

I needed speed without breaking things. The solution was a three-tier cache:

Tier 1: Local Memory (~0.1ms)

Keep permissions in memory for 10 minutes. Fastest possible access.

Tier 2: Redis (~1-5ms)

Shared across all server instances, lasts 24 hours. Fast enough and handles scaling.

Tier 3: Database (~100-500ms)

Only when both caches miss, which is rare after the first request.

Here's how it flows:

const buildRolePermissionsCache = async () => {
  // Try local memory first
  let permissions = getRolePermissionsFromLocalCache();
  if (permissions) return permissions;

  // Try Redis next
  permissions = await getRolePermissionsFromRedis();
  if (permissions) {
    setRolePermissionsToLocalCache(permissions);
    return permissions;
  }

  // Fine, hit the database
  permissions = await buildRolePermissionsFromDatabase();

  // Cache it everywhere for next time
  await setRolePermissionsToRedis(permissions);
  setRolePermissionsToLocalCache(permissions);

  return permissions;
};

The local cache implementation is dead simple:

let localRolePermissionsCache = null;
let localCacheTimestamp = 0;
const LOCAL_CACHE_DURATION = 10 * 60 * 1000; // 10 minutes

const getRolePermissionsFromLocalCache = () => {
  const now = Date.now();

  if (localRolePermissionsCache && 
      (now - localCacheTimestamp) < LOCAL_CACHE_DURATION) {
    return localRolePermissionsCache;
  }

  return null;
};

Nothing fancy. Just a variable, a timestamp, and a TTL check.

Fixing the Database Queries Too

While I was in there, I also optimized how we fetch from the database when we do need to:

// Before: Sequential queries
const roles = await ROLES.find();
for (const role of roles) {
  const permissions = await getPermissions(role.permissions);
  // ...
}

// After: Parallel queries with a lookup map
const [roles, permissions] = await Promise.all([
  ROLES.find().lean(),
  PERMISSIONS.find().lean()
]);

const permissionMap = new Map();
permissions.forEach(perm => {
  permissionMap.set(perm._id.toString(), perm.name);
});

// Now O(1) lookups instead of O(n) database queries

The .lean() calls help too—they skip Mongoose's document hydration, which we don't need for read-only operations.

Other Wins Along the Way

While debugging, I found another issue: we were calculating shipping fees on every cart operation. That meant address lookups, shipping API calls, all for something the user doesn't see until checkout.

Quick fix:

// Before
const defaultAddress = await addressService.getUserDefaultAddress(userId);
if (defaultAddress) {
  shippingFee = await shippingService.getShippingFee(defaultAddress.id);
}

// After
shippingFee = 0; // Calculate at checkout instead

Saved another few hundred milliseconds per request.

I also added some database indexes that were missing:

cartItemSchema.index({ cartId: 1, productId: 1 }, { unique: true });
cartSchema.index({ userId: 1 });
wishlistSchema.index({ userId: 1 }, { unique: true });

These should have been there from day one, honestly.

The Results

First authenticated request: 100-500ms (cold cache, hits database)

Every request after that: ~0.1ms (local cache hit)

Cart operations went from 18 seconds to under half a second. Wishlist operations saw similar improvements. The entire app feels snappier.

Best part? The cache stays warm across requests, so most users never hit the slow path. And when roles/permissions do change (rarely), I just call:

await clearRolePermissionsCache();

Both caches get wiped, next request rebuilds them, life goes on.

What I Learned

Profile before optimizing. I almost started optimizing database queries before realizing auth was the real problem. The network inspector saved me days of wasted effort.

Cache aggressively when data is stable. Roles and permissions change maybe once a month. There's no reason to query them thousands of times per hour.

Multiple cache tiers aren't overkill. Local memory for speed, Redis for scaling, database as fallback. Each serves a purpose.

Don't over-engineer early. I added monitoring and stats later, once the basic caching worked. Getting it working first, then making it observable, was the right order.

Indices matter. Seriously, if you're doing Model.find({ userId }) frequently, just add the damn index.

The Code

Everything's in production now. The local cache is stupid simple—just a variable and a timestamp. Redis handles the cross-instance sharing. The database is the fallback that rarely gets hit.

If you're dealing with similar auth slowdowns, the pattern is pretty straightforward: identify what rarely changes, cache it aggressively, and only invalidate when it actually changes.

And always, always profile first. I wasted an afternoon optimizing database queries that weren't the problem. The network inspector pointed straight at auth middleware within five minutes.

P.S. If you're warming up the cache on server startup, do it after MongoDB connects but before accepting requests. Learned that one the hard way.

mongoose.connect(mongoUrl).then(async () => {
  await warmUpAuthCache(); // Do this first
  server.listen(port);      // Then start accepting traffic
});

The Advantages of Learning Typed Languages for Beginners

derekzyl — Thu, 28 Sep 2023 03:49:57 +0000

Introduction

Programming is an essential skill in today's tech-driven world, and one of the first decisions aspiring programmers face is whether to start with a typed or loosely typed programming language. Typed languages, where variables have specific data types, offer several advantages for beginners. In this article, we will explore the benefits of learning typed languages over loosely typed ones for newcomers to the world of programming.

Error Detection and Prevention

Typed languages, like Java or C++, require you to specify the data type of a variable when you declare it. This enforced typing helps catch errors at compile-time rather than runtime. As a beginner, this means you'll receive immediate feedback about type-related issues, making it easier to identify and correct errors early in the development process.

Improved Code Readability

Typed languages promote better code readability. When you declare variables with explicit data types, it becomes easier for both you and other developers to understand the purpose and expected values of those variables. This clarity can lead to more maintainable and collaborative coding projects.

Stronger Debugging Tools

Typed languages often come with robust integrated development environments (IDEs) and debugging tools. These tools leverage type information to provide intelligent code suggestions, auto-completion, and real-time error highlighting. For beginners, these features can be incredibly helpful in speeding up the learning process.

Reduced Ambiguity

In loosely typed languages like JavaScript or Python, variable types can change dynamically, leading to unexpected behavior if not managed carefully. Typed languages, on the other hand, reduce ambiguity by enforcing strict type rules, helping beginners avoid subtle bugs caused by type mismatches.

Enhanced Learning Experience

Learning typed languages can provide a structured and systematic approach to programming. As beginners, you'll gain a deeper understanding of data types, variable scope, and type-related concepts, setting a strong foundation for more advanced programming tasks.

Industry Relevance

Many industries and software development roles require knowledge of typed languages. Learning a typed language as a beginner can open up more job opportunities and career paths in fields such as software engineering, data analysis, and game development.

Smooth Transition

Once you've mastered a typed language, transitioning to loosely typed languages becomes more manageable. You'll already have a strong grasp of fundamental programming concepts, making it easier to adapt to different language paradigms.

Conclusion

While loosely typed languages have their merits and are often praised for their simplicity, learning a typed language as a beginner can offer numerous advantages. From early error detection to improved code readability and enhanced debugging tools, the structured nature of typed languages can accelerate the learning process and prepare you for a wider range of programming challenges. Whether you choose Java, C++, or another typed language, the skills you acquire will be valuable assets in your journey as a programmer.

Navigating the Toxic Waters of Depression: Staying Afloat and Finding Hope

derekzyl — Wed, 30 Aug 2023 20:10:23 +0000

Introduction

Depression, often described as a silent storm, has the power to engulf even the most vibrant souls in its deep and murky waters. The toxicity of depression goes beyond its emotional toll; it permeates every aspect of a person's life, casting a shadow that can be suffocating. However, it's essential to remember that even in the darkest of times, there are ways to stay afloat and find hope amidst the waves of despair.

Understanding the Toxicity of Depression

Depression is not merely a feeling of sadness; it's a complex and multifaceted mental health condition that affects thoughts, emotions, behaviors, and even physical well-being. Its toxicity lies in the way it distorts perceptions, saps energy, and fosters self-doubt. The negative thoughts and self-criticism that accompany depression can create a cycle of despair, leading to a heightened sense of isolation and hopelessness.

Moreover, the toxic nature of depression often spills over into relationships. Friends and family members may struggle to comprehend the internal battles a person with depression faces, leading to frustration and miscommunication. This can intensify the feeling of being alone in the struggle, reinforcing the notion that there's no way out.

Staying Afloat in the Depths of Depression

While depression's grip might feel overwhelming, there are ways to combat its toxicity and keep your head above water:

Reach Out for Support: Remember that you're not alone in this battle. Reach out to friends, family, or mental health professionals who can provide understanding and guidance. Their support can help you navigate the challenging times.
Seek Professional Help: A mental health professional can offer invaluable tools and strategies to manage depression. Therapy, medication, or a combination of both might be necessary to address the underlying issues.
Practice Self-Compassion: Challenge the toxic self-talk by treating yourself with the same kindness you'd offer to a friend. Understand that depression distorts your perception, and your worth isn't defined by it.
Set Realistic Goals: Break down tasks into manageable steps to avoid feeling overwhelmed. Celebrate even the smallest achievements, as they represent victories against the grip of depression.
Engage in Physical Activity: Exercise has been proven to release endorphins and improve mood. Even a short walk can make a significant difference in how you feel.
Mindfulness and Meditation: These practices can help you stay grounded in the present moment and reduce the overwhelming nature of negative thoughts.
Creative Outlets: Expressing yourself through art, writing, or any creative outlet can provide a healthy way to process emotions and channel them into something positive.
Healthy Routine: Establish a routine that includes regular sleep patterns, a balanced diet, and activities that bring you joy.

Finding Hope in the Darkness

It's important to acknowledge that finding hope while battling depression can be incredibly challenging, but it's not impossible. Hope often emerges from the journey itself—the moments of strength you discover within yourself, the support you receive, and the gradual progress you make.

Remember that seeking help isn't a sign of weakness; it's a testament to your courage and determination to overcome the toxicity of depression. By reaching out for support, practicing self-compassion, and engaging in positive activities, you can slowly chip away at the darkness and uncover the glimmers of hope that lie beneath.

Conclusion

Depression's toxicity can be all-encompassing, but it's crucial to understand that it doesn't define who you are. You are not your depression. With the right strategies and support, you can navigate these turbulent waters and find your way to a place of healing and hope. Every step you take towards staying afloat is a step towards reclaiming your life from the clutches of darkness.

TypeScript and Go: Syntax Comparison and Contrast

derekzyl — Wed, 09 Aug 2023 21:02:12 +0000

TypeScript and Go are two modern programming languages that have gained popularity for their simplicity, efficiency, and strong type systems. While they serve different purposes and have distinct features, comparing and contrasting their syntax can provide valuable insights into their strengths and use cases. In this article, we'll explore the syntax of TypeScript and Go, highlighting their similarities and differences.

Type Annotations vs. Type Inference

One of the key differences between TypeScript and Go is how they handle type annotations. TypeScript uses static typing with explicit type annotations, allowing developers to specify the types of variables, function parameters, and return values.

// TypeScript
function greet(name: string): string {
    return `Hello, ${name}!`;
}

In contrast, Go employs type inference, where the compiler deduces the variable types based on the assigned values.

// Go
func greet(name string) string {
    return "Hello, " + name + "!"
}

Null and Undefined

TypeScript distinguishes between null and undefined, reflecting the semantics of JavaScript.

// TypeScript
let value: string | null = null;

Go, on the other hand, only has the nil value to represent the absence of a value.

// Go
var value string

Control Flow

Both languages support familiar control flow statements like if, for, and switch. However, TypeScript's syntax is influenced by JavaScript, while Go follows a more C-like syntax.

// TypeScript
if (condition) {
    // ...
} else if (anotherCondition) {
    // ...
} else {
    // ...
}

// Go
if condition {
    // ...
} else if anotherCondition {
    // ...
} else {
    // ...
}

Functions

Functions in both languages are first-class citizens, but there are syntax differences.

// TypeScript
function add(a: number, b: number): number {
    return a + b;
}

// Go
func add(a, b int) int {
    return a + b
}

Error Handling

TypeScript uses try, catch, and throw for error handling, similar to JavaScript.

// TypeScript
try {
    // ...
} catch (error) {
    // ...
}

Go employs explicit error handling with returned error values.

// Go
result, err := someFunction()
if err != nil {
    // ...
}

Conclusion

While TypeScript and Go have distinct syntax styles influenced by their respective programming paradigms, both languages prioritize simplicity, readability, and expressiveness. TypeScript's focus on strong typing and its close relationship with JavaScript make it an excellent choice for frontend and full-stack web development. Go's emphasis on performance, concurrency, and simplicity makes it ideal for backend development and system programming.

By understanding the syntax similarities and differences between TypeScript and Go, developers can leverage the strengths of each language to build robust and efficient applications tailored to their specific requirements.

Development Journey Pitfalls

derekzyl — Wed, 19 Jul 2023 20:25:43 +0000

Introduction

Embarking on a web development journey can be an exciting and rewarding experience. As you dive into the world of coding, design, and user experience, it's important to be aware of the potential pitfalls that lie ahead. Understanding these common challenges can help you navigate your path more efficiently and avoid unnecessary frustrations. In this article, we will explore some of the pitfalls you may encounter during your web development journey and provide tips to overcome them.

Lack of Planning

One of the biggest mistakes aspiring web developers make is diving into a project without proper planning. Skipping this crucial step can lead to disorganized code, inefficient workflows, and a lack of clarity in your goals. Before starting any web development project, take the time to plan your website's structure, design, and functionality. Create wireframes, flowcharts, and establish a roadmap to guide your development process. Proper planning will save you time and effort in the long run.

Inadequate Knowledge

Web development is a vast field that requires a solid understanding of various technologies and frameworks. It's easy to get overwhelmed by the sheer amount of information available. Many beginners fall into the trap of trying to learn everything at once, leading to confusion and frustration. Instead, focus on mastering the fundamentals of HTML, CSS, and JavaScript before delving into more complex frameworks. Break your learning into manageable chunks and gradually build upon your knowledge base.

Poor Time Management

Web development projects can often take longer than anticipated, especially if you're working on multiple tasks simultaneously. Poor time management can result in missed deadlines, compromised quality, and increased stress levels. To avoid this pitfall, set realistic goals and create a schedule that allocates time for each task. Prioritize your tasks based on their importance and deadline. Additionally, don't forget to take breaks and maintain a healthy work-life balance.

Ignoring Cross-Browser Compatibility

Different web browsers interpret code and display websites in slightly different ways. Neglecting cross-browser compatibility can lead to a website that looks and functions well in one browser but breaks in another. To prevent this, test your website across multiple browsers (such as Chrome, Firefox, Safari, and Edge) to ensure consistent performance. Utilize tools and techniques to identify and fix compatibility issues, such as using vendor prefixes and following web standards.

Limited User Testing

User experience (UX) is a crucial aspect of web development. Without proper user testing, you risk delivering a website that fails to meet the needs and expectations of your target audience. Don't solely rely on your own judgment when evaluating your website's usability. Encourage friends, colleagues, or potential users to test your site and provide feedback. Conduct usability tests, gather data, and iterate based on user insights. This iterative process will help you create a user-friendly and intuitive website.

Conclusion

Embarking on a web development journey can be challenging, but with awareness and preparation, you can overcome the common pitfalls that arise along the way. By embracing proper planning, continuous learning, effective time management, cross-browser compatibility, and user testing, you'll be well-equipped to navigate your path to becoming a proficient web developer. Remember, persistence, patience, and a willingness to learn from your mistakes will ultimately lead you to success in the ever-evolving world of web development.

React vs svelte vs angular vs vanilla js vs vue

derekzyl — Wed, 15 Feb 2023 20:32:50 +0000

React, Svelte, Vue, VanillaJS, and Angular are all popular front-end JavaScript frameworks and libraries used for building dynamic and interactive web applications. Here's a brief overview of each one with a 'hello world' example:

React: Developed by Facebook, React is a widely adopted JavaScript library for building user interfaces. It's a component-based library that allows you to easily manage and update the state of your UI, making it a popular choice for large-scale, complex applications.

import React from 'react';

function App() {
  return (
    <div>
      <h1>Hello World!</h1>
    </div>
  );
}

export default App;

Svelte: Svelte is a new and emerging framework that is gaining popularity in the JavaScript community. It is a compiler-based framework that compiles the code at build time, which allows for smaller bundle sizes and faster performance. Svelte is also known for its simplicity, ease of use, and the ability to write less code to achieve the same functionality compared to other frameworks.

  let name = 'World';
</script>

<h1>Hello {name}!</h1>

Vue: Vue is a progressive JavaScript framework that is designed to be easy to use and flexible. It's known for its ease of integration with existing projects and the ability to scale up or down depending on the size of the project. Vue also provides a wide range of features out-of-the-box, including a state management system and component-based architecture.

<template>
  <div>
    <h1>Hello {{ name }}!</h1>
  </div>
</template>

<script>
export default {
  name: 'App',
  data() {
    return {
      name: 'World'
    }
  }
}
</script>

VanillaJS: VanillaJS, also known as plain JavaScript, is the native JavaScript language without the use of any libraries or frameworks. While it requires more coding than the other frameworks, VanillaJS is a great option for small projects, and it can also be used alongside other frameworks.

<!DOCTYPE html>
<html>
  <head>
    <title>Hello World</title>
  </head>
  <body>
    <h1 id="myHeading">Hello World!</h1>
    <script>
      document.getElementById('myHeading').textContent = 'Hello World!';
    </script>
  </body>
</html>

Angular: Developed by Google, Angular is a comprehensive framework that provides a full set of features for building complex web applications. It's known for its strong opinionated structure, dependency injection system, and advanced features like two-way data binding and powerful directives.

import { Component } from '@angular/core';
@Component({
  selector: 'app-root',
  template: '<h1>Hello {{ name }}!</h1>',
})
export class AppComponent {
  name = 'World';
}

In conclusion, the choice between these frameworks ultimately depends on the project's specific requirements, developer preferences, and the team's expertise. All these frameworks have their strengths and weaknesses, and it's essential to consider them while choosing a framework for a particular project.

A Developers Sad Story

derekzyl — Wed, 21 Dec 2022 21:25:12 +0000

Introduction

everything all started like a pick of interest as i wondered how these apps and websites were being developed, it all seemed like magic and there was no how i could get a hold of learning how to write codes. The first developer i met Alex was typically astounding as he could literally develop websites and he ha done several jobs. This got me excited which was clearly short lived because i got to realize he was using wordpress and Jomla for his web development; and i was sure it wasn't what i needed. I then picked some online books and PDF and kick start the journey. At first they were looking all abstract as i didn't where to even start from. I dangled into some on the surface idea for a while and had to drop the idea of learning after a while of not getting ahold of what i needed.

Body

The little i learned made me look like a tech savvy as i knew how to talk tech and these gave a lot of folks and foes the impression that i was a developer. I had severally picked interest and started again but got discouraged because i needed to work to get food on the table. It was hell at that period cause i wanted to learn at the same time i was responsible for I and someone else. What broke the camels back was my laptop got bad because of my roommate in the halls of residence in school mal-handled the pc. I couldn't afford a PC for over a year cause my earnings wasn't sufficient to save to get a new pc.I attempted using my phone to learn but it was still hell as no one was available to guide me I then one way or the other managed to get at least a pc that was working fine. Immediately i started learning graphics design with it (Adobe illustrator, Adobe PhotoShop, and Adobe XD) these three i got deep into and i started getting small jobs on logo designs and flyers.

I then resumed learning programming and javascript was still abstract as i did not understand the concept of how javascript communicated with the DOM; I immediately stumbled into React as a friend asked me if i knew any thing about it. React was awesome it was straight forward i didn't need to talk to the DOM directly. I the started watching series of tutorial videos many wasn't making sense and most times i just rewrite what i learnt i realized i wasn't getting it fully; i then stumbled upon Django and it was still awesome as everything was straight forward. i got some jobs for clients and these projects worked well.

conclusion

I knew i was still lacking skills and video tutorials weren't working at all cause for three months again i was learning frameworks(Django, React). I then met a friend that changed my life forever he recommended some things i do and i added some twist also that might help some persons out there:

please you need to learn the programming language before you move to the framework
you need to read official documentations
if you can avoid tutorial videos especially project videos but you can use tutorial videos to learn a language or documentation
join active communities
do hackathons, leetcodes etc
preference books over videos
use github every time
start making noise even when you have learnt a bite of tech it will create awareness to your employers so that when you are ready a spacemight be available for you
make your little experience make a louder noise on twitter, linkedin, github, and others
know this i the beginning "tech is hard" but there persons that know it don't got two heads
use tutorial videos to learn project flows and you don't need to code along having this in mind that you are familiar with all or most of the tools the project will implement

django referral app and allauth

derekzyl — Fri, 24 Sep 2021 21:40:48 +0000

with current tech of referral being a strategy to boost businesses both offline and online I've chosen to write some codes on how to create referral links with Django-allauth and django sessions.
inspiration of the referral was gotten from a youtube video of pyplane .

import uuid

def generate_ref_code():
    code =str(uuid.uuid4()).replace('-', '')[:12]
    return code

models

from django.db import models

# Create your models here.
from core.models import TheMain
from referral.utils import generate_ref_code
from user.models import User


class Referral(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    referral_balance = models.IntegerField(default=0)
    code = models.CharField(max_length=12, blank=True)
    referred_by = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True, related_name="ref_by")
    updated = models.DateTimeField(auto_now=True)
    created = models.DateTimeField(auto_now_add=True)
    approve= models.BooleanField(default=False)

    def __str__(self):
        return f'{self.user.username}- {self.code}'

    def get_reffered(self):
        qs = Referral.objects.all()
        my_refs = []
        for reffered in qs:
            if reffered.referred_by == self.user:
                my_refs.append(reffered)
        return my_refs



    def save(self, *args, **kwargs):
        if self.code == '':
            code = generate_ref_code()
            self.code = code
        super().save(*args, **kwargs)

the user referral id is automatically generated with UUID

the extended all-auth form view I guess I don't need to tell you about djangoallauth.

class mySignUp(SignupForm):
    first_name = forms.CharField(max_length=50, widget=forms.TextInput(attrs={
        'placeholder': 'First name'
    }))
    last_name = forms.CharField(max_length=50, widget=forms.TextInput(attrs={
        'placeholder': 'Last name'
    }))
    country = CountryField(blank_label='select country').formfield(widget=CountrySelectWidget(attrs={
        'class': 'custom-select d-block w-100'
    }))
    phone = forms.IntegerField(required=True, widget=forms.TextInput(attrs={
        'placeholder': 'Phone number'
    }))

    # def save(self,  request):
    #     user = super(mySignUp, self).save(request)
    #
    #     user.first_name = self.cleaned_data['first_name']
    #     user.last_name = self.cleaned_data['last_name']
    #     user.country = self.cleaned_data['country']
    #     user.phone = self.cleaned_data['phone']
    #     user.save()
    #     print(f'this is the user {user}')
    #     return user

    def save(self, request):
        referral_id = request.session.get('ref_profile')
        print(f'this is login{referral_id}')
        if referral_id is not None:
            recommended_by_profile = Referral.objects.get(id=referral_id)
            user = super(mySignUp, self).save(request)

            user.first_name = self.cleaned_data['first_name']
            user.last_name = self.cleaned_data['last_name']
            user.country = self.cleaned_data['country']
            user.phone = self.cleaned_data['phone']
            user.save()

            registered_user = User.objects.get(id=user.id)
            registered_profile = Referral.objects.get(user=registered_user)
            registered_profile.referred_by = recommended_by_profile.user
            registered_profile.save()
            print(f'this is the user {user}')
            print(f'this is the the {user.id}')
            # here after saving the registration I pass the ref id param to the user profile then I save the user 
            profile

            return user
        else:

            user = super(mySignUp, self).save(request)

            user.first_name = self.cleaned_data['first_name']
            user.last_name = self.cleaned_data['last_name']
            user.country = self.cleaned_data['country']
            user.phone = self.cleaned_data['phone']
            user.save()
            print(f'this is the user {user}')
            return user

def referred(request, *args, **kwargs):
    code = str(kwargs.get('ref_code'))
    print(f'coded code {code}')
    try:
        referral = Referral.objects.get(code=code)
        request.session['ref_profile'] = referral.id
        print('id', referral.id)
    except:
        pass
    print(request.session.get_expiry_age())
    return render(request, 'homepage/index.html', {})



# now in my views I fetch the referred users






from allauth.account.views import SignupView
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.shortcuts import render, get_object_or_404

# Create your views here.
from core.models import TheMain, Invest, TheRef
from referral.models import Referral


@login_required
def referral_page(request, *args, **kwargs):
    global invest_user, invest_name, invest_amount, invest_timer, main, that, ma, new_invest, new_main
    referral = get_object_or_404(Referral, user=request.user)
    my_ref = referral.get_reffered()

contact me if you need more explanation to this

reference
https://www.youtube.com/watch?v=QZfflGvRQrc
by pyplane

My Intern Journey At Zuri HNG

derekzyl — Tue, 17 Aug 2021 13:10:09 +0000

This article is about my first tech stack internship. I've been quite curious about how to make industry-standard in coding, collaborating with individuals, and making a target come through with a said given time well all these always plays perfectly well in my simulation but there are too many variables that are not accounted for when it comes to just think things in the head.
Then a friend sent me a link to register for an internship programme at ZURI. Well, currently it is quite fun meeting quite some developers and an admin @naza that is quite cool and fun though. I would recommend you visit https://zuri.team to see what these guys do out there. If you want to dive into an internship right away, I strongly recommend https://interns.zuri.team. I know what you'll be thinking currently that this article might just be for persons that are already into programming well you could start your tech journey at https://training.zuri.team.
At the commencement of my intern journey I've written out some goals I'll want to achieve at the end of the internship these are:

profound knowledge on how the tech firms/companies operate
work with individuals to achieve a task or goal, etc
well equipped for the tech space with necessary information
cover lapses in my mobile development tech stack well I still got to name what ill love to achieve in the coming weeks for the internship
get a better relationship with working and partnering with developers
know how to work with teams
become a god or maybe a Demi-god in mobile app development. ie Zeus mode

I'll be dropping some links to some tutorial videos in various tech stacks ill employ you to check them out; you know what they say the journey of a thousand miles starts with a step.
let us start with:

UI/UX: It's majorly for prototyping and designs to follow this tutorial to proceed and get to know more about it-https://www.youtube.com/watch?v=jk1T0CdLxwU
GIT: Git is a free and open-source distributed version control system designed to handle everything from small to very large projects with speed and efficiency (source- https://git.com) well if you want to know more about git follow this tutorial link- https://www.youtube.com/watch?v=8JJ101D3knE
HTML: HTML is the standard markup language for creating Web pages (source- https://www.w3schools.com/html/html_intro.asp). now the tutorial if you like reading books I will recommend https://html.com/ and videos https://www.youtube.com/watch?v=qz0aGYrrlhU
flutter: Flutter is an open-source framework to create high quality, high-performance mobile applications across mobile operating systems - Android and iOS. It provides a simple, powerful, efficient and easy to understand SDK to write mobile applications in Google's language, Dart. This tutorial walks through the basics of Flutter framework, installation of Flutter SDK, setting up Android Studio to develop Flutter based application, the architecture of Flutter framework and developing all types of mobile applications using Flutter framework (source- https://www.tutorialspoint.com/flutter/index.htm) beginner tutorial videos to flutter https://www.youtube.com/watch?v=1ukSR1GRtMU
Dart: A programming language optimized for building user interfaces with features such as sound null safety, the spread operator for expanding collections, and collection if for customizing UI for each platform( source- https://dart.dev/) follow this link to start asap with dart https://www.youtube.com/watch?v=Ej_Pcr4uC2Q