Training-VehicleService-May26/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Enums.h

#pragma once
#include <stdexcept>

namespace util
{
	enum class UserType
	{
		ADMIN,
		TECHNICIAN,
		CUSTOMER
	};

	enum class PaymentMode
	{
		ONLINE,
		OFFLINE
	};

	enum class PaymentStatus
	{
		PENDING,
		COMPLETED
	};

	enum class ServiceJobStatus
	{
        PENDING,
		STARTED,
		COMPLETED,
        CANCELLED
	};

    enum class State
    {
        ACTIVE,
        INACTIVE
    };

    inline std::string getUserTypeString(UserType type)
    {
        switch (type)
        {
        case UserType::ADMIN:
            return "ADMIN";
        case UserType::TECHNICIAN:
            return "TECHNICIAN";
        case UserType::CUSTOMER:
            return "CUSTOMER";
        }
        throw std::invalid_argument("Invalid UserType");
    }

    inline UserType getUserType(const std::string& value)
    {
        if (value == "ADMIN")
        {
            return UserType::ADMIN;
        }
        if (value == "TECHNICIAN")
        {
            return UserType::TECHNICIAN;
        }
        if (value == "CUSTOMER")
        {
            return UserType::CUSTOMER;
        }
        throw std::invalid_argument("Invalid UserType string");
    }

    inline std::string getPaymentModeString(PaymentMode mode)
    {
        switch (mode)
        {
        case PaymentMode::ONLINE:
            return "ONLINE";
        case PaymentMode::OFFLINE:
            return "OFFLINE";
        }
        throw std::invalid_argument("Invalid PaymentMode");
    }

    inline PaymentMode getPaymentMode(const std::string& value)
    {
        if (value == "ONLINE")
        {
            return PaymentMode::ONLINE;
        }
        if (value == "OFFLINE")
        {
            return PaymentMode::OFFLINE;
        }
        throw std::invalid_argument("Invalid PaymentMode string");
    }

    inline std::string getPaymentStatusString(PaymentStatus status)
    {
        switch (status)
        {
        case PaymentStatus::PENDING:
            return "PENDING";
        case PaymentStatus::COMPLETED:
            return "COMPLETED";
        }
        throw std::invalid_argument("Invalid PaymentStatus");
    }

    inline PaymentStatus getPaymentStatus(const std::string& value)
    {
        if (value == "PENDING")
        {
            return PaymentStatus::PENDING;
        }

        if (value == "COMPLETED")
        {
            return PaymentStatus::COMPLETED;
        }

        throw std::invalid_argument("Invalid PaymentStatus string");
    }

    inline std::string getServiceJobStatusString(ServiceJobStatus status)
    {
        switch (status)
        {
        case ServiceJobStatus::PENDING:
            return "PENDING";
        case ServiceJobStatus::STARTED:
            return "STARTED";
        case ServiceJobStatus::COMPLETED:
            return "COMPLETED";
        case ServiceJobStatus::CANCELLED:
            return "CANCELLED";
        }
        throw std::invalid_argument("Invalid ServiceJobStatus");
    }

    inline ServiceJobStatus getServiceJobStatus(const std::string& value)
    {
        if (value == "STARTED")
        {
            return ServiceJobStatus::STARTED;
        }
        if (value == "COMPLETED")
        {
            return ServiceJobStatus::COMPLETED;
        }
        if (value == "PENDING")
        {
            return ServiceJobStatus::PENDING;
        }
        if (value == "CANCELLED")
        {
            return ServiceJobStatus::CANCELLED;
        }
        throw std::invalid_argument("Invalid ServiceJobStatus string");
    }

    inline std::string getStateString(State status)
    {
        switch (status)
        {
        case State::ACTIVE:
            return "STARTED";
        case State::INACTIVE:
            return "COMPLETED";
        }
        throw std::invalid_argument("Invalid State");
    }

    inline State getState(const std::string& value)
    {
        if (value == "ACTIVE")
        {
            return State::ACTIVE;
        }
        if (value == "COMPLETED")
        {
            return State::INACTIVE;
        }
        throw std::invalid_argument("Invalid State string");
    }
}