DEV Community: Njeri Muriithi

Predicting Employee Salary Using Linear Regression

Njeri Muriithi — Thu, 15 Jan 2026 08:40:18 +0000

In this project ,I am predicting an employee's salary based on their years of experience using linear regression model.Linear regression is a statistical method used to model the relationship between a dependent variable and an independent variable.
In this case:

X(Independent Variable) represents Years Of Experience
Y(Dependent Variable) represents the salary

Libraries Used

The following Python libraries are used in this project:

pandas for handling data frames
seaborn and matplotlib for visualization
Scikit-learn (sklearn) provides a collection of tools for data preprocessing, model training and evaluation

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.feature_selection import f_regression
%matplotlib inline

Data Preparation

Read the excel file that contains the data set.

Then define the X and Y variables .

The X variable is stored in a DataFrame format.

X=df[['YearsExperience']]#Should be in dataframe or 2d array
y=df['Salary']

Splitting the Data set

The dataset is split into training and testing sets ,both X and Y are split accordingly.
In this project 25% data(test size = 0.25) is used for testing the rest to train the model.

##Train Test Split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=42)

Model validation

To evaluate whether there is a valid relationship exists between years of experience and salary F-regression is used to calculate the:

F-value(622.5):Measures how well the independent variable explains the dependent variable.
p-value helps(0.0):Determines the statistical significance of the relationship.

Since the p-value is less than 0.05 we reject the null hypothesis which states that there is no relationship between salary and years of experience. This confirms that a strong relationship exists between the two variables.

In general, a higher F-value and a smaller p-value indicate a stronger and more significant relationship

Prediction

The Linear Regression model is trained by fitting it to the training dataset using model.fit().

model= LinearRegression()
model.fit(X_train,y_train)

The Linear Regression model follows the formula:

Y=b0+b1X
Where:
Y = Dependent Variable (Salary)
b₀ = Intercept (Predicted salary when years of experience = 0)
b₁ = Slope (Rate of change in salary per year of experience)
X = Independent Variable (Years of Experience)

From the trained model, we can obtain:

The intercept() The predicted salary for an employee with 0 yrs of experience

model.intercept_

The slope (coefficient) Represents the change in salary for each additional year of experience

model.coef_

The trained model is then used to predict salaries on the test dataset using model.predict(X_test).

Model Evaluation

The model’s performance is evaluated using the R-squared (R²) metric.
The R² score measures how much of the variation in salary is explained by years of experience.
In this case the R² score is 0.93 (93%) indicating that years of experience explain most of the variation in salary showing a strong model fit.

Plot the Model

To visualize the relationship and the regression line:

Conclusion

This project demonstrates that Linear Regression can effectively model the relationship between years of experience and salary.

Thank you for reading!❤️.

Let's Build: CQRS and MediatR Pattern using ASP.Net WEB API

Njeri Muriithi — Mon, 24 Feb 2025 18:44:07 +0000

Introduction

In this article, we will be implementing the MediatR and CQRS (Command Query Responsibility Segregation) pattern in our ASP.NET Web API project

CQRS stands for Command Query Responsibility segregation:

This is a design pattern that separates read(Query) and Write(Command) operations in a system to improve performance and scalability.
The command side handles create, update and delete requests and the query side handles the Get request.

The MediatR:

Acts as a bridge between command and query operations, helping with coordination. It facilitates communication between components by introducing a central handler. Instead of components interacting directly, they send requests to the mediatR, which routes them to the appropriate handler.

The main goal of the MediatR pattern is to reduce dependencies between objects by restricting direct communication. This improves maintainability and scalability.

When a command or query is sent, the mediatR directs the request to the corresponding handler, which then processes either a command (write operation) or a query (read operation).

Query Operations
Get Transaction By Name
Command Operation

Applying CQRS and MediatR in Our Project(Iwallet Api)

From our previous project, where we built an iWallet using ASP.NET Web API_ https://dev.to/njeri_muriithi/lets-build-with-aspnet-web-api-iwallet-4k2g_ we will now refactor it to utilize the CQRS pattern with the MediatR pattern.
Getting Started:

Install MediatR from the NuGet package in Microsoft Visual Studio or by using the .NET CLI in Visual Studio Code:

dotnet add package MediatR

builder.Services.AddMediatR(cfg=>cfg.RegisterServicesFromAssemblies(typeof(Program).Assembly));

Query Operations:

This includes all the read operations

Step1:Create a new folder for Queries
Create a folder named “Queries”, where the read operations are defined.

GetAllTransactionsQuery

Create a class GetAllTransactionsQuery that inherit from the IRequest<Out TResponse>
The generic type Tresponse represents the expected response can be of any type in this case <IEnumerable<DailyExpense>>

using MediatR;
using Wallet_API.Models;
namespace Wallet_API.Queries
{
 public class GetAllTransactionsQuery:IRequest<IEnumerable<DailyExpense>>
    {
    }
}

Step1.2:Create Handler for the Query
Create a folder named "Handlers", where the implementation logic for queries and commands will be written.

Create class _GetAllTransactionHandler _that implements the IRequestHandler<in TRequest, TResponse>

TRequest -> GetAllTransactionsQuery
TResponse-> IEnumerable

Inject the Iwallet interface used to fetch the transactions and the Imapper for DTO Transformations
Then implement the IRequestHandler Interface handle method to call the GetTransactions method implemented by the Iwallet interface and return the list of expenses

namespace Wallet_API.Handlers
{
public class GetAllTransactionHandler : IRequestHandler<GetAllTransactionsQuery, IEnumerable<DailyExpense>>
    {
        protected readonly IWallet _wallet;
        protected readonly IMapper _mapper;
        public GetAllTransactionHandler(IWallet wallet,IMapper mapper)                                          
        {
           _wallet = wallet; 
            _mapper = mapper; 
        }
public async Task<IEnumerable<DailyExpense>>Handle
(GetAllTransactionsQuery request, CancellationToken cancellationToken)
         {
            var expenses = await _wallet.GetTransactions();
            return expenses;
        }                                       
    }
}

Step 1.3: Define the HTTP GET Endpoint in the Controller

Define the HTTP Get EndPoint in the controller.
Instantiate the query option (GetAllTransactionsQuery).
Use _mediatR.Send(query) to send the request

MediatR dispatches the request to the corresponding handler (GetAllTransactionHandler). The handler in this case _GetAllTransactionHandler _ then processes the request and returns a response

Note: MediatR has two methods:

_mediatR.Send() → Sends a request and may return a response and is one sender to only one handler.
_mediatR.Publish()-> publish has no return type and is One sender to many handlers.

Modify your controller to include MediatR as a dependency. Inject IMediator in the constructor to use it for handling requests.

public class DailyTransactionsController : ControllerBase
 {

   private readonly IMediator _mediatR ;
  public DailyTransactionsController(IMediator mediator)
 {

     _mediatR = mediator;
 }
  [HttpGet]
public async Task<ActionResult<IEnumerable<DailyExpenseDto>>> GetTransactions()
  {    
      var query = new GetAllTransactionsQuery();
      var result = await _mediatR.Send(query);   
      return Ok(result);
  }
}

Step2:Get Transaction By Name

This section implements the functionality of getting the transaction by name.

On the Queries folder Create a new class GetTransactionNameNameQuery and Inherit from the IRequest<DailyExpense>.
The query requires the _TransactionName _as a parameter
Create a constructor to accept and initialize the TransactionName.

namespace Wallet_API.Queries
{
    public class GetTransactionByNameQuery:IRequest<DailyExpense>
    {
        public string TransactionName {  get;}

        public GetTransactionByNameQuery(string transactionName)                                        

        {
            TransactionName = transactionName;
        }   
    }

}

Step 2.1:Get Transaction By Name Handler

Create the _GetTransactionByNameHandler _class in the handler folder.
Implement IRequestHandler<GetTransactionByNameQuery, DailyExpense>.
Inject dependencies (IWallet and IMapper).
Call _wallet.GetExpenseByName(request.TransactionName). the TransactionName parameter comes from the GetTransactionByNameQuery request.
Return _null _if no transaction is found.

namespace Wallet_API.Handlers
{
    public class GetTransactionByNameHandler : IRequestHandler<GetTransactionByNameQuery, DailyExpense>
    {
        protected readonly IWallet _wallet;
        protected readonly IMapper _mapper;
        public GetTransactionByNameHandler(IWallet wallet,
                                          IMapper mapper)
        {
            _wallet = wallet;
            _mapper = mapper;
        }
  public  async Task <DailyExpense>Handle(GetTransactionByNameQuery request,CancellationToken cancellationToken)
       {
    var Expenses  await_wallet.GetExpenseByName(request.TransactionName);
            return  Expenses == null ? null: Expenses;          

        }
    }
}

Step 2.2: Define the HTTP GET by Name Endpoint in the Controller

Define the [HttpGet("TransactionByName/{TransactionName}")] route.
The route expects a string TransactionName.
Instantiate GetTransactionByNameQuery with the provided TransactionName.
Use _mediatR.Send(query) to dispatch the request. When the request is sent via MediatR, it carries the TransactionName, which is then used inside the handler to fetch the relevant data
If no result is found, return NotFound(). Otherwise, return Ok(result).

 [HttpGet("Transaction By Name/{TransactionName}")]
 public async Task<ActionResult<DailyExpense>> GetTransactionByName(string TransactionName)
 {     
    var query = new GetTransactionByNameQuery(TransactionName);
     var results = await _mediatR.Send(query);   

     return results ==null? NotFound() : results;
 }

Command Operation:

Step 3.1: Create a Folder for Commands
Create a folder named "Commands", where the write operations will be defined.

Create Transaction Request
This section implements the functionality to add a new transaction.
Create a class CreateTransactionRequest that inherits from IRequest<TResponse>.
The generic type TResponse represents the expected response, which can be of any type. In this case, it will be DailyExpense.
Define the incoming request, which is a DailyExpenseDto, then create a constructor.

namespace Wallet_API.Commands
{
    public class CreateTransactionRequest:IRequest<DailyExpense>
    {
      public DailyExpenseDto ExpenseDto { get; }

        public CreateTransactionRequest(DailyExpenseDto expenseDto)
        {
            ExpenseDto = expenseDto;
        }   
    }
}

Step 3.2: Create a Handler for the Command

Create a new handler CreateTransactionHandler that implements IRequestHandler<CreateTransactionRequest, DailyExpense>.
Like previous handlers, inject the required dependencies: IWallet and IMapper.
Implement the Handle method to add a new transaction.
Use AutoMapper to map DailyExpenseDto to DailyExpense.
Call the AddTransaction method to save the transaction.
Return the newly created transaction.

namespace Wallet_API.Handlers
{
    public class GetNewTransactionHandler : IRequestHandler<CreateTransactionRequest, DailyExpense>
    {
        protected readonly IWallet _wallet;
        protected readonly IMapper _mapper;
        public GetNewTransactionHandler(IWallet wallet, IMapper mapper)
        {
            _wallet = wallet;
            _mapper = mapper;
        }
        public async Task<DailyExpense> Handle(CreateTransactionRequest 
      request, CancellationToken cancellationToken)
        {         
            var expense = _mapper.Map<DailyExpense>(request.ExpenseDto);     
           await _wallet.AddTransaction(expense);
           return _mapper.Map<DailyExpense>(expense);
        }
    }
}

Step 3.3: Define the HTTP POST Endpoint in the Controller

Define the [HttpPost] endpoint.
The route expects a DailyExpenseDto object.
Instantiate _CreateTransactionRequest _with the provided expenseDto.
Use _MediatR.Send() to send the command, which will be handled by CreateTransactionHandler.
Return the result.

public async Task<ActionResult<DailyExpenseDto>> AddTransaction([FromBody] DailyExpenseDto dailyExpenseDto)
{
   var command = new CreateTransactionRequest(dailyExpenseDto);
     var createdTransaction = await _mediatR.Send(command); 
    return Ok(createdTransaction);

}

This format also works for both HTTP DELETE and UPDATE operations.
DELETE _would use a command like DeleteTransactionRequest, which takes an TransactionName.
UPDATE _would use UpdateTransactionRequest, which takes an updated DailyExpenseDto.

Conclusion

The CQRS and MediatR design patterns are great for scaling, especially in complex projects, as they enhance maintainability.

Thank you for reading ❤️ Stay awesome! 🚀

How To Debug SQL Procedures and Queries in Microsoft Visual Studio

Njeri Muriithi — Mon, 02 Sep 2024 15:08:23 +0000

Stored procedures and functions can be long and tedious to debug.
This article will guide you on how to debug stored procedures or run basic queries using Microsoft Visual Studio Code.

Open Microsoft Visual Studio Code → Click Continue without code.

2. Connection to database

Click on the View tab and select SQL Server Object Explorer from the dropdown.
In the SQL Server Object Explorer, connect to the SQL Server by adding the necessary SQL Server login credentials, and select the desired database for debugging.

3 Debugging Stored Procedure

1.View Code

To View the stored procedure, expand the **Programmability **node, right-click on the desired stored procedure, and select View Code.

The stored procedure on Microsoft Visual Studio:

The stored procedure on Microsoft SQL Server Management Studio:

2. Execute Procedure

TO execute the stored procedure right-click on the desired stored procedure, and select Execute Procedure

3.Debug procedure

To debug a stored procedure, right-click on the desired stored procedure and select Debug Procedure.
This allows you to navigate through the code, step into or step over the procedure, and add breakpoints as needed.

4.Update procedure.

If you need to add more parameters or modify an existing stored procedure, you can easily test, debug, and then update the procedure in SQL Server.
For example: let's remove the MpesaID and PhoneNumber fields from the stored procedure.

Update the stored procedure in the SQL by clicking update _then _Update Database on the popup and the stored procedure in the Microsoft SQL Server Management Studio receives the changes.

The two fields have now been removed in the SQL as shown below⬇️:

Running SQL Queries

Click on the desired database -> right-click, and select New Query from the dropdown.
This opens a new window where you can write your queries.
Right-click and select Execute or Execute with debugger to run the query.
For example: let's get the total Mpesa balance from the mpesaAccounts table where userId is 1:
👇

Conclusion

Debugging stored procedures/functions and writing basic or complex queries has been made easier by connecting SQL Server to Microsoft Visual Studio.

Thank you for reading!❤️.

C# LINQ and LINQ Methods

Njeri Muriithi — Wed, 24 Jul 2024 09:13:57 +0000

Language-Integrated Query (LINQ)
is the name for a set of technologies based on the integration of query capabilities directly into the C# language.

The LINQ provides a clear and consistent way to query objects , relational databases and XML.

LINQ Methods
- Any

There are two ways of expressing LINQ:

Query Syntax: is similar to structured query language(SQL) for databases.

It begins with From keyword and ends with Select or Group By clause.

2.Method /fluent syntax: Comprises of extension methods and lamba expressions . The extension Methods are included in the Enumerable and Queryable classes.

The query syntax is converted to method syntax at compile time.

Note :

LINQ does not directly modify data it provides a way to query and transform data such as filtering, sorting, and ordering.

This article will focus on using method syntax.

LINQ Methods

There are several LINQ Methods:

1.Any()

This type determines whether the defined collection contains any of the elements defined and returns a boolean. True if any of the elements pass the test otherwise false.

Example 1:list of Names.

using System;
using System.Collections.Generic;
using System.Linq;

public class LinQ
{
    public static void Main()
    {
        IList<string> Names = new List<string> { "John", "James", "Kevin", "Joan" };

        var isNameContainsJohn = Names.Any(name => name == "John");
        var isNames  = Names.Any();
        Console.WriteLine($" Name contains John -> {isNameContainsJohn}");
        Console.WriteLine($"Does Names Contain any Elements -> {isNames}");
    }
}

Output: 
 > Name contains John -> True
 > Does Names Contain any Elements -> True

Example 2: List of Numbers

using System;
using System.Collections.Generic;
using System.Linq;

public class LinQ
{
    public static void Main()
    {


        IList<int> Numbers = new List<int>{1,2,4,5,6,7};
        var isAnyNumberGreaterThan10 = Numbers.Any(Num => Num>10);
        Console.WriteLine($"Is Any NumberGreaterThan10 -> {isAnyNumberGreaterThan10}");



    }
}

OutPut:
>Is Any NumberGreaterThan10 -> False

Your feedback on how I can make this article even better/more helpful is most appreciated!

Thank you for reading❤️️

Lets Build: With ASP.Net Web API - IWallet

Njeri Muriithi — Mon, 15 May 2023 09:42:28 +0000

Introduction

In today’s world managing personal finances is essential.
Most of us have experienced the consequences of poor financial management, whether overspending, neglecting savings, or struggling to keep track of daily expenditures.
As someone who has personally struggled with this issue for far too long.
I decided to take develop IWallet a C# Web API project dedicated to helping me gain control over my finances and foster healthier spending habits.

As a part of the ongoing C# Web API series, this article will guide you through creating essential components such as models, interfaces, Entity Framework integration, building controllers, and testing the API.

1.Chapter 1

Adding Model
- Enums

2.Chapter 2

Entity Framework
- Configuration of the database

3.Chapter 3

Migrations

4.Chapter 4

Data Transfer Object(DTOs)
- AutoMapping

5.Chapter 5
- API Validation

6.Chapter 6

IWallet Interface
- Implementation of the Interface
  - Configuration of Services

7.Chapter 7

The Controller
- HTTPGet
- GetTransactionByName
- HTTPPut
- HTTPDelete
- HTTPPost

8.Chapter 8

Testing with PostMan
Conclusion

Prerequisite

Microsoft visual studio 2022
SQL
Net SDK 6.0
PostMan

Getting Started

Create an ASP.Net Web API Project in Microsoft visual studio 2022 follow the following steps:

Create a new project on Microsoft Visual studio 2022 →Search and Select ASP.NET Core Web API →Click Next →Add your Project Name –Click Next→Configure the .Net FrameWork → Click create

A New Project is created with the following a test project of weather forecast.Clear the Weather forecast Example .

Add Model
The Model Class acts as representation of the data structure.

Add a new class DailyExpense with the following properties:

using WalletAPI.Entities;
using static WalletAPI.Enums.TransactionEnums;

namespace WalletAPI.Models
{
    public class DailyExpense :BaseEntity
    {

        public string TransactionName { get; set; } = default!;

        public string VendorName { get; set; } = default!;

        public int TransactionCost { get; set; } = default!;

        public int TransactionCostCharges { get; set; } = default!;

        public ModeOfPayments ModeOfPayment { get; set; } = default!;
        public DateTime DateOfTransaction { get; set; } = DateTime.Now;

        public Categories Category { get; set; } = default!;     

        public int TotalAmount
        {
            get
            {
                return TransactionCostCharges + TransactionCost;
            }
            set { }
        }

    }
}

TransactionName --> Represents the Name of Transaction Made Example:Shopping,Rent
VendorName-->Represents the Name of the Vendor where the Transaction is being made Example:Name of Shop, etc.
TransactionCost -->Amount spent.
TransactionCostCharges --> Costs Involved during the Transaction
ModeOfPayment -->How did you pay via Cash,Bank,MobilePayment etc
DateOfTransaction --> Date payment was made.
Category --> Category of the Transaction.
TotalAmount --> The total amount spent on the Transaction (TransactionCostCharges +TransactionCost)

The DailyExpense class inherits the Id from the BaseEntity class.

 using WalletAPI.Entities;
 public class DailyExpense :BaseEntity

Lets Create the `BaseEntity` class:

Create a new Folder Entities.
Add The Base Entity class.

using Microsoft.EntityFrameworkCore.Metadata.Internal;
using System.ComponentModel.DataAnnotations.Schema;
using System.ComponentModel.DataAnnotations;

namespace WalletAPI.Entities
{
    public class BaseEntity
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        [Column(TypeName = "int")]
        [Display(Name = "Id")]
        [Required]

        public int Id { get; set; }
    }
}

Enums

In the model class created above DailyExpense the properties:
public Categories Category { get; set; } = default!; public ModeOfPayments ModeOfPayment { get; set; } = default!; are represented as Enums.
That is why we have using static WalletAPI.Enums.TransactionEnums in the model class.
`Enums

also known as Enumeration is a way of Grouping Related Constants and they are declared using the enum keyword.`

Let's create a new class that incorporates the use of enums:

Create a new folder Enums.
Add class TransactionEnums.

namespace WalletAPI.Enums
{
    public class TransactionEnums
    {
        public enum Categories
        {
            None = 0,
            Transport = 1,
            Food,
            Other
        }
        public enum ModeOfPayments
        {
            None = 0,
            Mpesa = 1,
            Bank,
            Cash
        }
    }
}

Entity Framework

In this project we will use Entity Framework core to map the Entities Created in the Model Folder DailyExpense.cs to the SQL Server database.

`Microsoft Entity Framework (EF) -->

is an object-relational mapper that enables .NET developers to work with relational data using domain-specific objects.It uses Code First Approach which means developers can define the application data model using C# and EF Core will automatically generate a database schema.`

https://learn.microsoft.com/en-us/aspnet/entity-framework

Install the Microsoft.EntityFrameworkCore library from the Nugget Package manager or from dotnet cli.
Create a new folder DatabaseContext.
Add a new Class DailyExpenseContext.cs

using Microsoft.EntityFrameworkCore;
using WalletAPI.Models;

namespace WalletAPI.DatabaseContext
{
    public class DailyExpenseContext : DbContext
    {
        public DailyExpenseContext(DbContextOptions options) : base(options)
        {
        }

        public DbSet<DailyExpense> DailyExpesnses { get; set; }
    }
}

The DailyExpenseContext inherits from DbContext base class which is a class in the Microsoft.EntityFrameworkCore library.

        public DailyExpenseContext(DbContextOptions options) : base(options)
        {
        }

The constructor takes an instance of DbContextOptions as its parameter which is used to configure the database connection.

public DbSet<DailyExpense> DailyExpenses { get; set; }

The Entity Framework library includes DbSetclass to represent the model Entity created DailyExpense.
Therefore the name of the corresponding database table will be DailyExpenses.

Configuration of the database

Create a new database in Msql.
Configure the database created using connection strings configuration in the appsettings.json.
Add Connection string :

DefaultConnection: that defines the value of the connection string.

Configuration of the DatabaseContext in Program.cs

builder.Services.AddDbContext<DailyExpenseContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

The builder.Configuration.GetConnectionString("DefaultConnection") retrieves the connection string value from the configuration file (appsettings.json) using the key "DefaultConnection".
The retrieved connection string is then passed to the UseSqlServer method to configure the DbContext to use SQL Server with that connection string.

Migrations

Migration in EntityFrameworkCore is the process of updating the database schema to match the latest changes made to the model class.
Install the following NuGet Packages to use Migration.

Microsoft.EntityFrameworkCore.Tools
Microsoft.EntityFrameworkCore.Design The Migration involves the following steps.

Open the Package manager console.
Add Migration command

FirstMigration is the migration Name and its upto to specify the name that you want.
The Migration Command will add three files to your project Under the Migrations Folder.
Update the Database.

Other Migration Commands.

Rollback a migration -->Update-Database -TargetMigration:"{migration_name}"
To remove a migration -->Remove-Migration
To view the migration history--> Get-Migrations

Data Transfer Object(DTOs)

A DTO is an object that defines how the data will be sent over the network.Learn More on DTOs Here--https://learn.microsoft.com/en-us/aspnet/web-api/overview/data/using-web-api-with-entity-framework/part-5

Create New Folder DTO's
Add a New Class DailyExpenseDto


using System.ComponentModel.DataAnnotations.Schema;
using static WalletAPI.Enums.TransactionEnums;

namespace WalletAPI.DTO_S
{
    public class DailyExpenseDto
    {
        public string TransactionName { get; set; } = default!;

        public string VendorName { get; set; } = default!;

        public int TransactionCost { get; set; } = default!;

        public int TransactionCostCharges { get; set; } = default!;

        public ModeOfPayments ModeOfPayment { get; set; } = default!;


        public Categories Category { get; set; } = default!;            


        public DateTime DateOfTransaction { get; set; } = DateTime.Now;


    }
}

AutoMapping

AutoMapper -->

AutoMapper is an object-object mapper. Object-object mapping works by transforming an input object of one type into an output object of a different type. Learn More -->https://docs.automapper.org/en/stable/Getting-started.html

Install the AutoMapper NuGet package using the NuGet package manager or from the dotnet CLI
Create a New Folder AutomapperProfile
Add A new Class AutoMapperProfiles

using AutoMapper;
using WalletAPI.DTO_S;
using WalletAPI.Models;

namespace WalletAPI.AutomapperProfile
{
    public class AutoMapperProfiles :Profile
    {
        public AutoMapperProfiles()
        {
            CreateMap<DailyExpense, DailyExpenseDto>().ReverseMap();
        }
    }
}

The code above Maps between the DailyExpenseModel and DailyExpenseDto.
The AutoMapperProfiles inherits from the Profile class provided by the Automapper.
Inside the AutomapperProfiles constructor the CreateMap() Method specifies the source type (DailyExpense), while the second argument specifies the destination type (DailyExpenseDto)
The ReverseMap() method is also called on the mapping, which creates a reverse mapping from DailyExpenseDto to DailyExpense.

API Validation

Validation

is the verification and assurance that an API operates accurately and meets the desired behavior. In this project, we will utilize Fluent Validation as a means to enhance the security of the API.
For more detailed information and insights on this topic, I recommend referring to the accompanying article that I have written.

Fluent Validation in Asp.net Web API

Lets Create the Validator.

Install FluentValidation Nuget Package.
Create a new folder Validations.
Add the class DailyExpenseValidator.


using static WalletAPI.Enums.TransactionEnums;
using FluentValidation;
using WalletAPI.DTO_S;

namespace WalletAPI.Validations
{
    public class DailyExpenseValidator :AbstractValidator<DailyExpenseDto>
    {
        public DailyExpenseValidator()
        {
            RuleFor(exp => exp.TransactionName).NotEmpty().MinimumLength(2).MaximumLength(50);
            RuleFor(exp => exp.TransactionCost).NotEmpty().GreaterThan(0);
            RuleFor(exp => exp.VendorName).NotEmpty().MinimumLength(2).MaximumLength(30);
            RuleFor(exp => exp.Category).IsInEnum().NotEqual(Categories.None).NotEmpty();
            RuleFor(exp => exp.ModeOfPayment).IsInEnum().NotEqual(ModeOfPayments.None).NotEmpty();

        }
    }
}

IWallet Interface

An Interface

defines a contract for the behavior of a class. It defines set of methods, properties, or Events that a class that subscribes to it must implement.
The Interface class is Identified by the I keyword.
Learn more on Interfaces-->(https://learn.microsoft.com/e
n-us/dotnet/csharp/language-reference/keywords/interface)

Create a New Folder Services
Add A new Interface Class IWallet

using WalletAPI.Models;

namespace WalletAPI.Services
{
    public interface IWallet
    {
        Task<IEnumerable<DailyExpense>> GetTransactions();
        Task<DailyExpense> GetExpenseByName(string 
         TransactionName);
           Task<DailyExpense> AddTransaction(DailyExpense 
        dailyExpense);
        Task<DailyExpense> UpdateTransaction(DailyExpense 
       dailyExpense);
        Task DeleteTransaction(string TransactionName);

    }
}

This Iwallet interface declares several methods related to managing daily expense transactions.

Implement IWallet Interface.

Create a new class DailyExpenseService

using FluentValidation;
using Microsoft.EntityFrameworkCore;
using WalletAPI.DatabaseContext;
using WalletAPI.DTO_S;
using WalletAPI.Models;
using WalletAPI.Validations;

namespace WalletAPI.Services
{
    public class DailyExpenseService:IWallet
    {
        private DailyExpenseContext DailyContext;
        public IFileService FileService { get; }

        public DailyExpenseService(DailyExpenseContext dailyContext,
                                   IFileService fileService
)
        {
            DailyContext = dailyContext;
            FileService = fileService;

        }

        public async Task<DailyExpense> AddTransaction(DailyExpense dailyExpense)
        {
            var _transaction = await DailyContext.DailyExpesnses.AddAsync(dailyExpense);
            await DailyContext.SaveChangesAsync();
            return _transaction.Entity;
        }

        public async Task DeleteTransaction(string TransactionName)
        {
            var deletedTransaction = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(T => T.TransactionName == TransactionName);
            if (deletedTransaction != null)
            {
                DailyContext.DailyExpesnses.Remove(deletedTransaction);
                await DailyContext.SaveChangesAsync();
            }
        }

        public async Task<DailyExpense> GetExpenseByName(string TransactionName)
        {
            var ExpenseEntity = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(N => N.TransactionName == TransactionName);
            return ExpenseEntity;
        }

        public async Task<DailyExpense> GetTransaction(int Id)
        {
            return await DailyContext.DailyExpesnses.FirstOrDefaultAsync(T => T.Id == Id);
        }

        public async Task<IEnumerable<DailyExpense>> GetTransactions()
        {
            var items = DailyContext.DailyExpesnses.ToList();
            return items;
        }

        public async Task<DailyExpense> UpdateTransaction(DailyExpense dailyExpense)
        {
            var updatedExpense = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(T => T.TransactionName == dailyExpense.TransactionName);
            if (updatedExpense != null)
            {
              updatedExpense.TransactionName = dailyExpense.TransactionName;
                updatedExpense.TransactionCost = dailyExpense.TransactionCost;
                updatedExpense.VendorName = dailyExpense.VendorName;
                updatedExpense.TransactionCostCharges = dailyExpense.TransactionCostCharges;
                updatedExpense.Category = dailyExpense.Category;
               updatedExpense.ModeOfPayment = dailyExpense.ModeOfPayment;
                await DailyContext.SaveChangesAsync();
                return updatedExpense;
            }

            return null;
        }
    }
}

This Class provides the implementation of the methods declared in the Iwallet interface

AddTransaction

      public async Task<DailyExpense> AddTransaction(DailyExpense dailyExpense)
        {
            var _transaction = await DailyContext.DailyExpesnses.AddAsync(dailyExpense);
            await DailyContext.SaveChangesAsync();
            return _transaction.Entity;
        }

This method adds a DailyExpense object to the DailyContext (database context) and saves the changes asynchronously. It returns the added DailyExpense object.

DeleteTransaction

  public async void DeleteTransaction(string TransactionName)
        {
            var deletedTransaction = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(T => T.TransactionName == TransactionName);
            if (deletedTransaction != null)
            {
                DailyContext.DailyExpesnses.Remove(deletedTransaction);
                await DailyContext.SaveChangesAsync();
            }
        }

This method deletes a transaction from the DailyContext based on the provided TransactionName.
It removes the transaction from the context and saves the changes asynchronously.

GetExpenseByName

    public async Task<DailyExpense> GetExpenseByName(string TransactionName)
        {
            var ExpenseEntity = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(N => N.TransactionName == TransactionName);
            return ExpenseEntity;
        }

This method retrieves a DailyExpense object from the DailyContext based on the provided TransactionName.

GetTransactions

 public async Task<IEnumerable<DailyExpense>> GetTransactions()
        {
            var items = DailyContext.DailyExpesnses.ToList();
            return items;
        }

This method returns a collection of DailyExpense objects representing all the transactions.

UpdateTransaction

public async Task<DailyExpense> UpdateTransaction(DailyExpense dailyExpense)
        {
            var updatedExpense = await DailyContext.DailyExpesnses.FirstOrDefaultAsync(T => T.TransactionName == dailyExpense.TransactionName);
            if (updatedExpense != null)
            {             
                updatedExpense.TransactionName = dailyExpense.TransactionName;
                updatedExpense.TransactionCost = dailyExpense.TransactionCost;
                updatedExpense.VendorName = dailyExpense.VendorName;
                updatedExpense.TransactionCostCharges = dailyExpense.TransactionCostCharges;
                updatedExpense.Category = dailyExpense.Category;

                updatedExpense.ModeOfPayment = dailyExpense.ModeOfPayment;

                await DailyContext.SaveChangesAsync();
                return updatedExpense;
            }

            return null;
        }
    }

This method updates an existing DailyExpense object in the DailyContext based on the provided TransactionName.
It modifies the properties of the existing object with the values from the passed DailyExpense object and saves the changes asynchronously. The updated DailyExpense object is returned.

Configuration Of Services

Dependancy injection -->

A software design pattern, which is a technique for achieving Inversion of Control (IoC) between classes and their dependencies

By registering these services in the dependency injection container(Program.cs), they can be easily injected into the corresponding controller or other classes throughout the application

The Controller

A controller in ASP.NET is responsible for handling incoming HTTP requests, performing necessary operations, and returning the appropriate HTTP responses.

To add the controller in Microsoft Visual Studio 2022, follow these steps:

Right-click on the project in the Solution Explorer window.
Select "Add" -> "Controller" from the context menu. This will open the "Add Scaffold" dialog.
In the "Add Scaffold" dialog, select "API Controller with actions, using Entity Framework" option.
Click the "Add" button to proceed.
In the "Add Controller" dialog, select the appropriate Model class (e.g., DailyExpense) and the appropriate Data context class (e.g., DailyContext).
Click the "Add" button to generate the controller

using AutoMapper;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using static WalletAPI.DTO_S.ReceiptPhotoUpdateDto;
using WalletAPI.DTO_S;
using WalletAPI.Models;
using WalletAPI.Services;
using WalletAPI.Validations;
using FluentValidation;

namespace WalletAPI.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class DailyTransactionsController : ControllerBase
    {
        private readonly IWallet _wallet;
        private readonly IMapper mapper;
        private DailyExpenseValidator DailyExpvalidator { get; }

        public DailyTransactionsController(IWallet _wallet,
                                           IMapper mapper,
                                           DailyExpenseValidator _dailyExpvalidator)
        {
            this._wallet = _wallet;
            this.mapper = mapper;
            DailyExpvalidator = _dailyExpvalidator;
        }

        [HttpGet]

        public async Task<ActionResult<IEnumerable<DailyExpenseDto>>> GetTransactions()
        {
            var expenses = await _wallet.GetTransactions();

            var expenseDtos = mapper.Map<IEnumerable<DailyExpenseDto>>(expenses);
            return Ok(expenseDtos);


        }

        [HttpGet("Transaction By Name/{TransactionName}")]
        public async Task<ActionResult<DailyExpense>> GetTransactionByName(string TransactionName)
        {
            var ExpenseName = await _wallet.GetExpenseByName(TransactionName);
            if (ExpenseName == null) { return NotFound(); }
            return Ok(ExpenseName);
        }

        [HttpPost]
        public async Task<ActionResult<DailyExpenseDto>> AddNewTransaction(DailyExpenseDto dailyExpenseDto)
        {
            await DailyExpvalidator.ValidateAndThrowAsync(dailyExpenseDto);
            if (dailyExpenseDto == null) return BadRequest();
            var expenseDtos = mapper.Map<DailyExpense>(dailyExpenseDto);
            expenseDtos.TotalAmount = expenseDtos.TransactionCostCharges + expenseDtos.TransactionCost;


            var CreatedTransaction = await _wallet.AddTransaction(expenseDtos);

            return Ok(CreatedTransaction);
        }


        [HttpPut("{TransactionName}")]
        public async Task<ActionResult<DailyExpenseDto>> UpdateExistingTransaction(string TransactionName, DailyExpenseDto dailyExpenseDto)
        {

            await DailyExpvalidator.ValidateAndThrowAsync(dailyExpenseDto);
            if (TransactionName != dailyExpenseDto.TransactionName)
            {
                return BadRequest("Transaction Name does not match");
            }

            var expense = mapper.Map<DailyExpense>(dailyExpenseDto);

            var transactionToUpdate = await _wallet.GetExpenseByName(TransactionName);
            if (transactionToUpdate == null)
            {
                return NotFound("Transaction not found");
            }


            transactionToUpdate.TransactionName = expense.TransactionName;
            transactionToUpdate.VendorName = expense.VendorName;
            transactionToUpdate.TransactionCost = expense.TransactionCost;
            transactionToUpdate.TransactionCostCharges = expense.TransactionCostCharges;
            transactionToUpdate.ModeOfPayment = expense.ModeOfPayment;
            transactionToUpdate.Category = expense.Category;
            transactionToUpdate.DateOfTransaction = expense.DateOfTransaction;
            transactionToUpdate.isNecessaryTransaction = expense.isNecessaryTransaction;



            await _wallet.UpdateTransaction(transactionToUpdate);

            var updatedExpenseDto = mapper.Map<DailyExpenseDto>(expense);

            return Ok(updatedExpenseDto);
        }



        [HttpDelete("{TransactionName}")]
  public async Task<ActionResult<DailyExpenseDto>> DeleteExistingTransaction(string TransactionName)
        {
            string DeleteSucess = "Item Deleted Successfully";

            var transactionToDelete = await _wallet.GetExpenseByName(TransactionName);
            if (transactionToDelete == null) 
            { 
            return NotFound();
            }
             await _wallet.DeleteTransaction(TransactionName);
            return Content(DeleteSucess);
        }


    }
}

Let's break down the code:

The constructor of the DailyTransactionsController class receives several dependencies through dependency injection. These dependencies are:

IWallet _wallet: An interface representing the wallet service.
IMapper mapper: An interface for object-object mapping.
DailyExpenseValidator _dailyExpvalidator: An instance of the DailyExpenseValidator class used for validation.

HTTPGet

[HttpGet]

        public async Task<ActionResult<IEnumerable<DailyExpenseDto>>> GetTransactions()
        {
            var expenses = await _wallet.GetTransactions();

            var expenseDtos = mapper.Map<IEnumerable<DailyExpenseDto>>(expenses);
            return Ok(expenseDtos);


        }

This Method retrieves all the transactions by calling the _wallet.GetTransactions() method asynchronously.
The retrieved transactions are then mapped to DailyExpenseDto object using the mapper.Map method.Then the list of DailyExpenseDto object is returned as the response.

GetTransaction By Name.

     [HttpGet("Transaction By Name/{TransactionName}")]
        public async Task<ActionResult<DailyExpense>> GetTransactionByName(string TransactionName)
        {
            var ExpenseName = await _wallet.GetExpenseByName(TransactionName);
            if (ExpenseName == null) { return NotFound(); }
            return Ok(ExpenseName);
        }

It retrieves a specific transaction by its name, using the _wallet.GetExpenseByName method.
If the transaction is found, it is returned as the response, otherwise a NotFound response is returned.

HTTPPut


        [HttpPut("{TransactionName}")]
        public async Task<ActionResult<DailyExpenseDto>> UpdateExistingTransaction(string TransactionName, DailyExpenseDto dailyExpenseDto)
        {

            await DailyExpvalidator.ValidateAndThrowAsync(dailyExpenseDto);
            if (TransactionName != dailyExpenseDto.TransactionName)
            {
                return BadRequest("Transaction Name does not match");
            }

            var expense = mapper.Map<DailyExpense>(dailyExpenseDto);

            var transactionToUpdate = await _wallet.GetExpenseByName(TransactionName);
            if (transactionToUpdate == null)
            {
                return NotFound("Transaction not found");
            }


            transactionToUpdate.TransactionName = expense.TransactionName;
            transactionToUpdate.VendorName = expense.VendorName;
            transactionToUpdate.TransactionCost = expense.TransactionCost;
            transactionToUpdate.TransactionCostCharges = expense.TransactionCostCharges;
            transactionToUpdate.ModeOfPayment = expense.ModeOfPayment;
            transactionToUpdate.Category = expense.Category;
            transactionToUpdate.DateOfTransaction = expense.DateOfTransaction;
            transactionToUpdate.isNecessaryTransaction = expense.isNecessaryTransaction;
            await _wallet.UpdateTransaction(transactionToUpdate);

            var updatedExpenseDto = mapper.Map<DailyExpenseDto>(expense);

            return Ok(updatedExpenseDto);
        }

It updates an existing transaction with the specified name. First, the dailyExpenseDto object is validated using the DailyExpvalidator.
If the validation fails, an error response is returned. If the validation passes, the dailyExpenseDto object is mapped to a DailyExpense object.
The existing transaction is retrieved using the _wallet.GetExpenseByNamemethod. If the transaction is not found, a NotFound response is returned. Otherwise, the properties of the existing transaction are updated with the new values from the expense object. Finally, the updated transaction is returned as the response.

HTTPPost

    [HttpPost]
        public async Task<ActionResult<DailyExpenseDto>> AddNewTransaction(DailyExpenseDto dailyExpenseDto)
        {
            await DailyExpvalidator.ValidateAndThrowAsync(dailyExpenseDto);
            if (dailyExpenseDto == null) return BadRequest();
            var expenseDtos = mapper.Map<DailyExpense>(dailyExpenseDto);
            expenseDtos.TotalAmount = expenseDtos.TransactionCostCharges + expenseDtos.TransactionCost;
            var CreatedTransaction = await _wallet.AddTransaction(expenseDtos);
            return Ok(CreatedTransaction);
        }

It accepts a DailyExpenseDto object in the request body. First, the dailyExpenseDto object is validated using the DailyExpvalidator and FluentValidation library.
If the validation fails, an error response is returned.
If the validation passes, the dailyExpenseDto object is mapped to a DailyExpenseobject using the mapper.Map method.
The total amount of the expense is calculated by summing TransactionCostCharges and TransactionCost.
Then, the expense is added to the wallet using the _wallet.AddTransaction method. The created transaction is returned

HTTPDelete

  [HttpDelete("{TransactionName}")]

          public async Task<ActionResult<DailyExpenseDto>> DeleteExistingTransaction(string TransactionName)
        {
            string DeleteSucess = "Item Deleted Successfully";

            var transactionToDelete = await _wallet.GetExpenseByName(TransactionName);
            if (transactionToDelete == null) 
            { 
            return NotFound();
            }
             await _wallet.DeleteTransaction(TransactionName);
            return Content(DeleteSucess);
        }

This Methods deletes an existing transaction with the specified name. First, the transaction to delete is retrieved using the _wallet.GetExpenseByName method.
If the transaction is not found, a NotFound response is returned. If the transaction is Found the message Item Deleted Successfully is displayed.

Testing With PostMan

Note:
The 200 OK status code indicates that the request was successful, and the API was able to process it without any issues.

Learn More on Status Codes Here -->(https://learn.microsoft.com/en-us/rest/api/searchservice/http-status-codes)

Add New Transaction

We will create two transactions lunch and BreakFast.

Get all Transactions

HTTP Put

Lets change content of one of the transaction added.

Database Changes:

Delete the Transaction By Name

Lets delete the transaction that we named lunch.

Database:

Conclusion

While this article has focused on the initial stages of IWAllet's development, it serves as a catalyst for further exploration in the C# Web API series. Future articles will dive deeper into additional functionalities, such as authentication, data visualization, advanced analytics, and integration with external services.

Your feedback on how I can make this article even better/more helpful is most appreciated!

Thank you for reading❤️️

REST API

Njeri Muriithi — Mon, 01 May 2023 11:31:21 +0000

Introduction to API

API --> Application Programming Interface , is defined as a set of rules or protocols that are set to enable two software to communicate with each other.
There are several types of API’s example SOAP, XML-RPC or REST
This article will focus more on REST API.

Rest API stands for REpresentational State Transfer→ It is a set of functions (GET, POST,PUT or Delete) that enables clients to perform CRUD operations that include Create , Read, Update and Delete resources in the data server.

There are Six REST API design principles.

Uniform interface
Stateless
Client-server decoupling
Cacheable
Code on Demand
Layered System

Rest API HTTP Methods

GET → Request Data from a server.The response contains all details requested.
POST→Create new resources on the server.
PUT→Update a Resource in the specified URL.
DELETE→Delete a Resource in the Specified URL.

Fluent Validation in Asp.net Web API

Njeri Muriithi — Fri, 28 Apr 2023 09:27:19 +0000

Introduction

Fluent validation is a validation library for .Net applications that allows developers to implement validation rules.

This article we'll explore on how to use Fluent Validation with Asp.net Web Api to validate HTTP POST requests.

Install FluentValidation Nuget Package

Install the .Net library from the Nuget package manager or from the dotnet CLI.

Tools →Nuget Package Manager → Manage Nuget Packages For Solution
dotnet add package FluentValidation.AspNetCore

Create a Model Class

This model class acts as a representation of the data structure in the database.
Our model class --> Transaction.js

public class Transaction
    {
        public Guid Id { get; set; } = Guid.NewGuid();  
        public string TransactionName { get; set; }

        public string VendorName { get; set; } 

        public int TransactionCost { get; set; } 

        public int TransactionCostCharges { get; set; }
    }

The Validator Class

public class TransactionValidator:AbstractValidator<Transaction>
 {
     public TransactionValidator()
     {
       RuleFor(exp => exp.TransactionName).NotEmpty().MinimumLength(5).MaximumLength(20);
            RuleFor(exp => exp.TransactionName).Must(exp => !exp.Any(char.IsDigit)).WithMessage("Name should not Contain any Numbers");

     }
 }

Fluent Validation provides a base class AbstractValidator that provides a set of methods and properties that implements the validation rules that can be inherited and extended.

public class CreatedClass:AbstractValidator<T>

<T> is the model class created above that we are consuming.

Example 1:

RuleFor(exp => exp.TransactionName).NotEmpty().MinimumLength(5).MaximumLength(20);

RuleFor is one of the methods that implements validation rules for a particular property.
In this Example the RuleFor validates the TransactionName Property it should not be Empty, with a length between 5 and 20.

Example 2:

RuleFor(exp => exp.TransactionName).Must(exp => !exp.Any(char.IsDigit)).WithMessage("Name should not Contain any Numbers");

The TransactioName should not contain Numbers and the custom message --> WithMessage("Name should not Contain any Numbers") is shown.

_There are many Expressions you could choose from refer to the following fluent validation documentation _https://docs.fluentvalidation.net/en/latest/index.html

Configure the Validator Class

Register the TransactionValidator in the program.cs class to make it available for dependancy injection in other classes.

Dependancy injection -->

A software design pattern, which is a technique for achieving Inversion of Control (IoC) between classes and their dependencies

builder.Services.AddScoped<TransactionValidator>()

The Controller

Create a new Controller TransactionController.

public class TransactionController : ControllerBase
 {
        public Transactiondb Transactiondb { get; }
        public TransactionValidator Validations { get; }

        public TransactionController(Transactiondb transactiondb ,TransactionValidator T_validations)
        {
            Transactiondb = transactiondb;
            Validations = T_validations;
        }
}

The TransactionController Extends the ControllerBase class.
There two properties the Transactiondb class and the TransactionValidator class
In the constructor of TransactionController both Transactiondb and TransactionValidator are registered or injected.

_ Add the HttP Post method_

    [HttpPost]
 public async Task<IActionResult> AddNewTransaction([FromBody] Transaction transaction)
       {

            var validationResult = await Validations.ValidateAsync(transaction);
            if (!validationResult.IsValid) 
            {
                return   BadRequest(validationResult.Errors);
            }

            var newTransaction = new Transaction
            {
                Id = Guid.NewGuid(),
                TransactionName = transaction.TransactionName,
                TransactionCost = transaction.TransactionCost,
                VendorName = transaction.VendorName,    
                TransactionCostCharges= transaction.TransactionCostCharges, 
            };

            await Transactiondb.AddAsync(newTransaction);
            await Transactiondb.SaveChangesAsync();
           return Ok("Transaction added Successfully");;

       }

When the client adds a new transaction the validate asyncmethod from the TransactionValidator performs the validations created on the transaction added.

The validationResult holds the results.
If the validationResult is invalid method returns a BadRequest response with the error message in the response body.

If the validation is successfull the transaction is added to the database and an Okreponse to the client with message Transaction added Successfully.

Testing With Postman

Example 1:
Lets Clear the TransactionName

A 400 Bad request error Code is thrown with
Error Messages :Transaction Name' must not be empty and The length of 'Transaction Name' must be at least 5 characters. You entered 0 characters
shown.

Example 2:
Lets Add a TransactionName with Numbers.

Error Message :Name should not Contain any Numbers

Valid data:

The 200 OK status code meaning the Transaction has been added to the database.

Conclusion

Validation is very important in API development It helps to ensure that data is valid and secure .FluentValidation has made API validation easy to implement making it a very powerful validation tool.

My Journey On How I Landed A Software Developer Job.

Njeri Muriithi — Wed, 27 Jul 2022 06:08:17 +0000

When getting started with learning how to code, most probably your goal is to land a software developer job.

However, the first challenge you face as a beginner is choosing the right road map that you need to follow to get a job.

After finding the right road map, the second challenge you will face is landing a job as a beginner with no prior experience.

Another challenge you will face after landing a job is not feeling good enough to do what is expected of you.

I faced all these challenges but I am happy that I was able to overcome them.

In this article, you will learn how I landed a software developer job and how I was able to overcome the challenges I faced.

My Background

After completing my high school studies, I got the results that qualified me to join a university.

However, I didn't have good guidance on what courses to choose from during my university application process.

The only thing I was sure about was that I didn’t want to enroll in a course that involved chemistry and biology😊.

I got a placement to study ICT at one of the universities in Kenya, where during my studies, I didn’t take the program seriously. My main intention was to pass exams and graduate.

After graduation I ended up taking a different path, putting my software development journey on hold.

In 2021, a year after graduation, As I was working as a retail manager, I started feeling lost and empty without a sense of purpose in my life😒😒.

That is when I decided to pursue a career as a software developer. I started looking for boot camps to join, tech communities, and mentors to increase my knowledge and skills.

I joined communities such as Andela, Zindua Africa Koding, and kahawa. During these boot camps, I connected with amazing mentors and friends.

One of my biggest challenges during these boot camps was abandoning projects once they started getting complex which was a huge setback on my side.

One of my biggest goals this year was to venture into a career in the tech industry as a software developer.

I started applying for jobs as an intern or entry-level openings via LinkedIn with the few skills I had learned in the boot camps.

I was successful in one of my applications, I got a chance to sit on my first interview.

The experience of the interview was nerve-wracking and challenging.

However, as a beginner with no prior experience, the interview was based on confidence and my communication skills and I qualified for the job 😃😃.

My First Job.

After getting my first job, I experienced a few challenges in the first few months.

First I started doubting my ability to learn and understand concepts.

Due to this, I spent long hours in the office, getting to a point where I started working on non working days to make sure the projects were perfect.

The pressure I had put on myself took a toll on my mind and body, resulting in anxiety, procrastination, and lack of sleep especially if I was stuck on a project.

This challenges affected my productivity in the job and my well-being.

However, I was able to overcome the challenges by doing the following;

I started taking breaks as well as getting enough rest and sleep which helped me cope with my anxiety.

Asking for help from my team members helped me learn and make a progress in my projects.

I stopped comparing my self with other developers and decided to focus on building my confidence by learning and practicing more in programming.

FINAL THOUGHTS

Right now I am happy that I got to reach my goal of getting a job as a software developer.

I am still working on being better each day, what matters is being consistent and never giving up.

DEV Community: Njeri Muriithi

Predicting Employee Salary Using Linear Regression

Libraries Used

Data Preparation

Splitting the Data set

Model validation

Prediction

Model Evaluation

Plot the Model

Conclusion

Let's Build: CQRS and MediatR Pattern using ASP.Net WEB API

Introduction

Contents

Applying CQRS and MediatR in Our Project(Iwallet Api)

Query Operations:

Step2:Get Transaction By Name

Conclusion

How To Debug SQL Procedures and Queries in Microsoft Visual Studio

2. Connection to database

3 Debugging Stored Procedure

1.View Code

2. Execute Procedure

3.Debug procedure

4.Update procedure.

Running SQL Queries

Conclusion

C# LINQ and LINQ Methods

Contents

LINQ Methods

1.Any()

Lets Build: With ASP.Net Web API - IWallet

Introduction

Contents

Prerequisite

Getting Started

Lets Create the BaseEntity class:

Enums

Let's create a new class that incorporates the use of enums:

Entity Framework

Configuration of the database

Configuration of the DatabaseContext in Program.cs

Migrations

Other Migration Commands.

Data Transfer Object(DTOs)

AutoMapping

API Validation

Lets Create the Validator.

IWallet Interface

Implement IWallet Interface.

AddTransaction

DeleteTransaction

GetExpenseByName

GetTransactions

UpdateTransaction

Configuration Of Services

The Controller

Let's break down the code:

HTTPGet

GetTransaction By Name.

HTTPPut

HTTPPost

HTTPDelete

Testing With PostMan

Add New Transaction

Get all Transactions

HTTP Put

Delete the Transaction By Name

Conclusion

REST API

Introduction to API

Fluent Validation in Asp.net Web API

Introduction

Install FluentValidation Nuget Package

Create a Model Class

The Validator Class

Example 1:

Example 2:

Configure the Validator Class

The Controller

_ Add the HttP Post method_

Lets Create the `BaseEntity` class: