added luresult helper

Luticate2.Auth/Business/LuPermissionsBusiness.cs

         public LuResult<bool> GetPermissionEffectiveValue(string permissionName, string srcEntityType, object srcEntity,
             string dstEntityType, object dstEntity)
         {
+//            throw new Exception($"{permissionName} {srcEntityType} {srcEntity} {dstEntityType} {dstEntity}");
             return LuResult<bool>.Ok(true);
         }
     }

Luticate2.Auth/Business/LuUsersBusiness.cs

             return LuResult<UsersToken>.Ok(new UsersToken());//TODO
         }
 
+        public LuResult<bool> IsTokenValid(UsersToken token)
+        {
+            return LuResult<bool>.Ok(true);
+        }
+
         public LuResult<UsersDbo> GetSingleById(string id)
         {
             return LuResult<UsersDbo>.Ok(new UsersDbo

Luticate2.Auth/Controllers/LuAuthExtensions.cs

 
         public static void SetLuLoggedUser(this HttpContext context, UsersDbo user)
         {
-            throw new Exception($"{user.Id} {user.Username}");
             context.GetLuItems()[LuticateItemsLoggedUser] = user;
         }
     }

Luticate2.Auth/Interfaces/Users/ILuUsersBusiness.cs

 
         LuResult<UsersToken> UnRegisterToken(string token);
 
+        LuResult<bool> IsTokenValid(UsersToken token);
+
         LuResult<UsersDbo> GetSingleById(string id);
     }
 }

Luticate2.Auth/Middlewares/LuLoggedUserMiddleware.cs

                 var tokenRes = _luUsersBusiness.GetToken(token);
                 if (tokenRes.Status == LuStatus.NotFound)
                 {
-                    throw new LuResultException(LuResult<object>.Error(LuStatus.LoginError, $"{token}", "Invalid session"));
+                    LuResult<object>.Error(LuStatus.LoginError, $"token: {token}", "Invalid session").Throw();
                 }
-                if (!tokenRes)
+                tokenRes.ThrowIfNotSuccess();
+                var tokenValidityRes = _luUsersBusiness.IsTokenValid(tokenRes.Data).ThrowIfNotSuccess();
+                if (!tokenValidityRes.Data)
                 {
-                    throw new LuResultException(tokenRes.To<object>());
+                    LuResult<object>.Error(LuStatus.LoginError, $"token: {token}", "Invalid session").Throw();
                 }
                 userId = tokenRes.Data.UserId;
             }
 
-            var userRes = _luUsersBusiness.GetSingleById(userId);
-            if (!userRes)
-            {
-                throw new LuResultException(userRes.To<object>());
-            }
+            var userRes = _luUsersBusiness.GetSingleById(userId).ThrowIfNotSuccess();
 
             context.HttpContext.SetLuLoggedUser(userRes.Data);
         }

Luticate2.Auth/Middlewares/LuPermissionMiddleware.cs

                     var srcEntity = srcAccessor?.GetEntity(context, attribute.Id);
                     var dstEntity = dstAccessor?.GetEntity(context, attribute.Id);
                     var permissionValue = _luPermissionsBusiness.GetPermissionEffectiveValue(attribute.PermissionName,
-                        attribute.SrcEntityType, srcEntity, attribute.DstEntityType, dstEntity);
-                    if (!permissionValue)
-                    {
-                        throw new LuResultException(permissionValue.To<object>());
-                    }
+                        attribute.SrcEntityType, srcEntity, attribute.DstEntityType, dstEntity).ThrowIfNotSuccess();
                     if (!permissionValue.Data)
                     {
                         var user = _serviceProvider.GetService<ILuLoggedUserAccessor>().GetLoggedUser();
-                        throw new LuResultException(LuResult<object>.Error(LuStatus.PermissionError,
-                            $"user: {user?.Id} {user?.Username}", "Permission denied"));
+                        LuResult<object>.Error(LuStatus.PermissionError,$"user: {user?.Id} {user?.Username}",
+                            "Permission denied").Throw();
                     }
                 }
             }

Luticate2.Utils/Controllers/LuController.cs

                     version = LuUtilsOptionsDbo.Version
                 };
             }
-            throw new LuResultException(result.To<object>());
+            result.Throw();
+            return null;
         }
 
         protected virtual LuApiWrapperDbo<LuBoxedValueDbo<T>> HandleBoxed<T>(LuResult<T> result)

Luticate2.Utils/Controllers/LuFsFilesCrudController.cs

             {
                 return StatusCode(404);
             }
-            if (!get)
-            {
-                throw new LuResultException(get.To<object>());
-            }
+            get.ThrowIfNotSuccess();
             string type;
             var contentTypeProvider = new FileExtensionContentTypeProvider();
             if (!contentTypeProvider.TryGetContentType(id, out type))

Luticate2.Utils/Dbo/PaginatedRequest/LuPaginatedRequestBinder.cs

 using System.Threading.Tasks;
-using Luticate2.Utils.Controllers;
 using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
             var pageValue = bindingContext.ValueProvider.GetValue("page");
             var perPageValue = bindingContext.ValueProvider.GetValue("perPage");
 
-            var filter = LuFilterBinder.FromString(filterValue.FirstValue);
-            if (!filter)
-            {
-                throw new LuResultException(filter.To<object>());
-            }
+            var filter = LuFilterBinder.FromString(filterValue.FirstValue).ThrowIfNotSuccess();
 
-            var orderBy = LuOrderByBinder.FromString(orderByValue.FirstValue);
-            if (!orderBy)
-            {
-                throw new LuResultException(orderBy.To<object>());
-            }
+            var orderBy = LuOrderByBinder.FromString(orderByValue.FirstValue).ThrowIfNotSuccess();
 
             var dbo = new LuPaginatedRequestDbo
             {

Luticate2.Utils/Dbo/Result/LuResult.cs

 using System;
+using Luticate2.Utils.Controllers;
 
 namespace Luticate2.Utils.Dbo.Result
 {
         {
             return res.Success;
         }
+
+        public void Throw()
+        {
+            throw new LuResultException(To<object>());
+        }
+
+        public LuResult<T> ThrowIfNotSuccess()
+        {
+            if (!this)
+            {
+                Throw();
+            }
+            return this;
+        }
     }
 }

Luticate2.Utils/Middlewares/LuModelStateFilter.cs

                         errors += error;
                     }
                 }
-                throw new LuResultException(LuResult<object>.Error(LuStatus.InputError, "Validation error:" + errors, ""));
+                LuResult<object>.Error(LuStatus.InputError, "Validation error:" + errors, "").Throw();
             }
         }