luticate2-api/Luticate2.Utils/Dbo/Result/LuResult.cs

using System;
using Luticate2.Utils.Controllers;

namespace Luticate2.Utils.Dbo.Result
{
    public class LuResult<T>
    {
        public LuStatus Status { get; set; }

        public bool Success => Status == LuStatus.Success;

        public string PublicDetails { get; set; }

        public string PrivateDetails { get; set; }

        public string StackTrace { get; set; }

        public Exception Exception { get; set; }

        public T Data { get; set; }

        protected LuResult()
        {
        }

        public static LuResult<T> Ok(T data)
        {
            return new LuResult<T>
            {
                StackTrace = new Exception().StackTrace,
                Data = data,
                Status = LuStatus.Success
            };
        }

        public static LuResult<T> Error(LuStatus status, string privateDetails, string publicDetails = null)
        {
            return new LuResult<T>
            {
                PublicDetails = publicDetails == "" ? privateDetails : publicDetails,
                PrivateDetails = privateDetails,
                StackTrace = new Exception().StackTrace,
                Status = status
            };
        }

        public static LuResult<T> Error(LuStatus status, Exception e, string publicDetails = null)
        {
            return new LuResult<T>
            {
                PublicDetails = publicDetails,
                PrivateDetails = e.ToString(),
                StackTrace = new Exception().StackTrace,
                Exception = e,
                Status = status
            };
        }

        public static LuResult<T> Error<T2>(LuResult<T2> other)
        {
            return new LuResult<T>
            {
                Status = other.Status,
                PublicDetails = other.PublicDetails,
                PrivateDetails = other.PrivateDetails,
                StackTrace = other.StackTrace,
                Exception = other.Exception
            };
        }

        public LuResult<T2> To<T2>()
        {
            return LuResult<T2>.Error(this);
        }

        public LuResult<T2> To<T2>(Func<T, T2> convert)
        {
            return new LuResult<T2>
            {
                Data = Success ? convert(Data) : default(T2),
                Status = Status,
                PublicDetails = PublicDetails,
                PrivateDetails = PrivateDetails,
                StackTrace = StackTrace,
                Exception = Exception
            };
        }

        public static implicit operator bool(LuResult<T> res)
        {
            return res.Success;
        }

        public void Throw()
        {
            throw new LuResultException(To<object>());
        }

        public LuResult<T> ThrowIfNotSuccess()
        {
            if (!this)
            {
                Throw();
            }
            return this;
        }
    }
}