...

Presentation/HushianWebApp/Service/AuthService.cs

@@ -0,0 +1,128 @@
+using BlazorBootstrap;
+using Common.Dtos.User;
+using Common.Models.Auth;
+using Common.Models.Auth.CompanySide;
+using Common.Models.Auth.UserSide;
+using Common.Models.Identity;
+using HushianWebApp.Services;
+using Microsoft.AspNetCore.Components;
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class AuthService
+    {
+        private readonly BaseController _baseController;
+        private readonly NavigationManager _NavigationManager;
+        private readonly ILocalStorageService _localStorage;
+        private readonly ToastService _ToastService;
+        public AuthService(BaseController baseController, NavigationManager navigationManager, ILocalStorageService localStorage, ToastService toastService)
+        {
+            _baseController = baseController;
+            _NavigationManager = navigationManager;
+            _localStorage = localStorage;
+            _ToastService = toastService;
+        }
+
+        public async Task<bool> IsOnline()
+        {
+            return await _baseController.IsOnline();
+        }
+        public async Task<string> login(AuthRequestFromCompanySide authRequest)
+        {
+            var response = await _baseController.PostLogin("v1/Auth/loginCompanySide", authRequest);
+            if (response.Item2.IsSuccessStatusCode)
+            {
+                var responsevalue = await response.Item2.Content.ReadFromJsonAsync<AuthResponse>();
+
+             
+                await _localStorage.RemoveItem("C/ID");
+                await _localStorage.SetItem("C/ID", responsevalue.Id);
+                await _localStorage.RemoveItem("C/CompanyId");
+                await _localStorage.SetItem("C/CompanyId", responsevalue.CompanyId.GetValueOrDefault());
+                await _localStorage.RemoveItem("C/Fullname");
+                await _localStorage.SetItem("C/Fullname", responsevalue.Fullname);
+                await _localStorage.RemoveItem("C/MobileOrUserName");
+                await _localStorage.SetItem("C/MobileOrUserName", responsevalue.MobileOrUserName);
+                await _localStorage.RemoveItem("C/Role");
+                await _localStorage.SetItem("C/Role", responsevalue.Role);
+                await _localStorage.RemoveItem("C/img");
+                await _localStorage.SetItem("C/img", responsevalue.img);
+                await _localStorage.RemoveItem("C/key");
+                await _localStorage.SetItem("C/key", responsevalue.Token);
+                
+                _NavigationManager.NavigateTo("/");
+            }
+            return response.Item1;
+
+
+        }
+        public async Task<int> login(AuthRequestFromUserSide model)
+        {
+            var response = await _baseController.Post($"v1/User/AuthenticationFromUser",model);
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<int>();
+            else if (response.StatusCode == System.Net.HttpStatusCode.BadRequest)
+            {
+                var Errors = await response.Content.ReadFromJsonAsync<List<string>>();
+                _ToastService.Notify(new ToastMessage(ToastType.Danger, Errors[0].Split(':').Length == 2 ? Errors[0].Split(':')[1] : Errors[0]));
+
+            }
+            else if (!response.IsSuccessStatusCode)
+            {
+
+                _NavigationManager.NavigateTo("Unhandled");
+            }
+
+            return 0;
+        }
+        public async Task<bool> Verificationlogin(int ID,string code)
+        {
+            var response = await _baseController.Put($"v1/Auth/UserLoginVerification/{ID}/{code}");
+
+            if (response.IsSuccessStatusCode)
+            {
+                var responsevalue = await response.Content.ReadFromJsonAsync<AuthResponse>();
+                await _localStorage.RemoveItem("U/ID");
+                await _localStorage.SetItem("U/ID", responsevalue.Id);
+                await _localStorage.RemoveItem("U/CompanyId");
+                await _localStorage.SetItem("U/CompanyId", responsevalue.CompanyId.GetValueOrDefault());
+                await _localStorage.RemoveItem("U/Fullname");
+                await _localStorage.SetItem("U/Fullname", responsevalue.Fullname);
+                await _localStorage.RemoveItem("U/MobileOrUserName");
+                await _localStorage.SetItem("U/MobileOrUserName", responsevalue.MobileOrUserName);
+                await _localStorage.RemoveItem("U/Role");
+                await _localStorage.SetItem("U/Role", responsevalue.Role);
+                await _localStorage.RemoveItem("U/img");
+                await _localStorage.SetItem("U/img", responsevalue.img);
+                await _localStorage.RemoveItem("U/key");
+                await _localStorage.SetItem("U/key", responsevalue.Token);
+
+                return true;
+            }
+          
+            return false;
+
+
+        }
+        public async Task Logout ()
+        {
+            await _localStorage.RemoveItem("C/ID");
+            await _localStorage.RemoveItem("C/CompanyId");
+            await _localStorage.RemoveItem("C/Fullname");
+            await _localStorage.RemoveItem("C/MobileOrUserName");
+            await _localStorage.RemoveItem("C/Role");
+            await _localStorage.RemoveItem("C/img");
+            await _localStorage.RemoveItem("C/key");
+
+            await _localStorage.RemoveItem("U/ID");
+            await _localStorage.RemoveItem("U/CompanyId");
+            await _localStorage.RemoveItem("U/Fullname");
+            await _localStorage.RemoveItem("U/MobileOrUserName");
+            await _localStorage.RemoveItem("U/Role");
+            await _localStorage.RemoveItem("U/img");
+            await _localStorage.RemoveItem("U/key");
+
+        }
+    }
+}

Presentation/HushianWebApp/Service/BaseController.cs

@@ -0,0 +1,155 @@
+using BlazorBootstrap;
+using HushianWebApp.Services;
+using Microsoft.AspNetCore.Components;
+using System.Net;
+using System.Net.Http.Json;
+using System.Text;
+using static System.Runtime.InteropServices.JavaScript.JSType;
+
+namespace HushianWebApp.Service
+{
+    public class BaseController
+    {
+        private readonly HttpClient _Http;
+        private readonly NavigationManager _NavigationManager;
+        private readonly ToastService _ToastService;
+        public BaseController(HttpClient http, NavigationManager navigationManager, ToastService toastService)
+        {
+            _Http = http;
+            _NavigationManager = navigationManager;
+            _ToastService = toastService;
+        }
+
+        public async Task<bool> IsOnline()
+        {
+            var result = await _Http.GetAsync("v1/Auth/IsOnline");
+            return result.IsSuccessStatusCode;
+        }
+        public async Task SetToken(string token)
+        {
+            _Http.DefaultRequestHeaders.Add("Authorization",
+                $"Bearer {token}");
+        }
+        public async Task RemoveToken()
+        {
+            if (_Http.DefaultRequestHeaders.Any(t => t.Key == "Authorization"))
+                _Http.DefaultRequestHeaders.Remove("Authorization");
+        }
+        public async Task<HttpResponseMessage> Get(string route)
+        {
+            var result = await _Http.GetAsync(route);
+            return await Check(result);
+
+        }
+        public async Task<HttpResponseMessage> Delete(string route)
+        {
+            var result = await _Http.DeleteAsync(route);
+            return await Check(result);
+        }
+        public async Task<HttpResponseMessage> Post(string route, object mode)
+        {
+            var result = await _Http.PostAsJsonAsync(route, mode);
+            return await Check(result);
+
+        }
+        public async Task<Tuple<string, HttpResponseMessage>> PostLogin(string route, object mode)
+        {
+            var result = await _Http.PostAsJsonAsync(route, mode);
+            if (result.IsSuccessStatusCode)
+            {
+                return Tuple.Create( "ok",result);
+            }
+            else if (result.StatusCode == System.Net.HttpStatusCode.BadRequest)
+            {
+                try
+                {
+                    var Errors = await result.Content.ReadFromJsonAsync<List<string>>();
+                    if (Errors.Count > 0)
+                    {
+                        _ToastService.Notify(new ToastMessage(ToastType.Danger, Errors[0]));
+                    }
+                    else _ToastService.Notify(new ToastMessage(ToastType.Danger, "خطا در اجرای عملیات"));
+
+                    return Tuple.Create(Errors[0], result);
+
+                }
+                catch (Exception)
+                {
+                    _ToastService.Notify(new ToastMessage(ToastType.Danger, "خطا در اجرای عملیات"));
+                    return Tuple.Create("error", result);
+                }
+            }
+            else if (!result.IsSuccessStatusCode)
+            {
+
+                _NavigationManager.NavigateTo("Unhandled");
+                return Tuple.Create("Unhandled", result);
+            }
+            return Tuple.Create("no", result);
+
+        }
+        public async Task<HttpResponseMessage> Post(string route,bool redirectToLogin=true)
+        {
+            var jsonString = "{\"appid\":1,\"platformid\":1,\"rating\":3}";
+            var httpContent = new StringContent(jsonString, Encoding.UTF8, "application/json");
+            var result = await _Http.PostAsync(route, httpContent);
+
+            return await Check(result, redirectToLogin);
+        }
+        public async Task<HttpResponseMessage> Put(string route, object mode)
+        {
+            var result = await _Http.PutAsJsonAsync(route, mode);
+            return await Check(result);
+        }
+        public async Task<HttpResponseMessage> Put(string route)
+        {
+            var jsonString = "{\"appid\":1,\"platformid\":1,\"rating\":3}";
+            var httpContent = new StringContent(jsonString, Encoding.UTF8, "application/json");
+            var result = await _Http.PutAsync(route, httpContent);
+            return await Check(result);
+        }
+        private async Task<HttpResponseMessage> Check(HttpResponseMessage result, bool redirectToLogin = true)
+        {
+            if (result.StatusCode == System.Net.HttpStatusCode.Unauthorized && redirectToLogin)
+                _NavigationManager.NavigateTo("Login");
+            else if (result.StatusCode == System.Net.HttpStatusCode.BadRequest)
+            {
+                try
+                {
+                    var Errors = await result.Content.ReadFromJsonAsync<List<string>>();
+                    if (Errors.Count > 0)
+                    {
+                        if (Errors[0] == "PhoneNumberNotConfirmed")
+                        {
+                            _ToastService.Notify(new ToastMessage(ToastType.Danger, "این کاربری احراز نشده اگر مالک آن هستید احراز کنید"));
+
+                        }
+                        else
+                        {
+
+                            _ToastService.Notify(new ToastMessage(ToastType.Danger, Errors[0].Split(':').Length==2 ? Errors[0].Split(':')[1] : Errors[0])); 
+                        }
+                    }
+                    else _ToastService.Notify(new ToastMessage(ToastType.Danger, "خطا در اجرای عملیات"));
+
+                }
+                catch (Exception)
+                {
+                    _ToastService.Notify(new ToastMessage(ToastType.Danger, "خطا در اجرای عملیات"));
+                }
+            }
+            else if (result.StatusCode == System.Net.HttpStatusCode.Forbidden)
+                _ToastService.Notify(new ToastMessage(ToastType.Danger, "به این بخش دسترسی ندارید"));
+            else if (result.StatusCode == System.Net.HttpStatusCode.NotFound)
+                _ToastService.Notify(new ToastMessage(ToastType.Danger, "یافت نشد"));
+            else if (!result.IsSuccessStatusCode)
+            {
+
+                _NavigationManager.NavigateTo("Unhandled");
+            }
+
+            return result;
+
+        }
+    }
+}

Presentation/HushianWebApp/Service/CaptchaService.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Text;
+
+namespace HushianWebApp.Service
+{
+    public static class CaptchaService
+    {
+        public static string GetCaptchaWord(int length)
+        {
+            var random = new Random(DateTime.Now.Millisecond);
+
+            //  const string chars = "ABCDEFGHJKLMNPQRSTUWYZabcdefghijkmnpqrstuwz23456789*#!$%=";
+            const string chars = "ABCDEFGHJKLMNPQRSTUWYZabcdefghijkmnpqrstuwz23456789";
+            string cw = new(Enumerable.Repeat(chars, length)
+                                      .Select(s => s[random.Next(s.Length)])
+                                      .ToArray());
+
+            return cw;
+        }
+        public static string GenerateCaptchaBase64(string text, int width = 120, int height = 40)
+        {
+            return "";
+        }
+    }
+}

Presentation/HushianWebApp/Service/CompanyService.cs

@@ -0,0 +1,63 @@
+using Common.Dtos.Company;
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class CompanyService
+    {
+        private readonly BaseController _baseController;
+        const string BaseRoute = "v1/Company/";
+        public CompanyService(BaseController baseController)
+        {
+            _baseController = baseController;
+        }
+
+        public async Task<int> RegisterCompany(RegisterCompanyDto request)
+        {
+            var response = await _baseController.Post($"{BaseRoute}NewCompany", request);
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<int>();
+            }
+            return 0;
+        }
+        public async Task<ReadANDUpdate_CompanyDto?> GetCompany(int CompanyID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetCompany/{CompanyID}");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<ReadANDUpdate_CompanyDto>();
+            }
+            return null;
+        }
+        public async Task<bool> UpdateCompany(ReadANDUpdate_CompanyDto dto)
+        {
+            var response = await _baseController.Put($"{BaseRoute}UpdateCompany",dto);
+            return response.IsSuccessStatusCode;
+        }
+        //public async Task<bool> AddContentInfo(string str)
+        //{
+        //    var response = await _baseController.Post($"{BaseRoute}AddContentInfo?ContentInfo={str}");
+        //    return response.IsSuccessStatusCode;
+        //}
+        //public async Task<bool> DeleteContentInfo(int ID)
+        //{
+        //    var response = await _baseController.Delete($"{BaseRoute}DeleteContentInfo/{ID}");
+        //    return response.IsSuccessStatusCode;
+        //}
+        //public async Task<bool> UpdateContentInfo(int ID, string str)
+        //{
+        //    var response = await _baseController.Put($"{BaseRoute}UpdateContentInfo/{ID}?ContentInfo={str}");
+        //    return response.IsSuccessStatusCode;
+        //}
+        //public async Task<List<ContentInfoDto>?> GetContentInfos()
+        //{
+        //    var response = await _baseController.Get($"{BaseRoute}GetContentInfos");
+        //    if (response.IsSuccessStatusCode)
+        //    {
+        //        return await response.Content.ReadFromJsonAsync<List<ContentInfoDto>?>();
+        //    }
+        //    return null;
+        //}
+    }
+}

Presentation/HushianWebApp/Service/ConversationService.cs

@@ -0,0 +1,93 @@
+using Hushian.Application.Dtos;
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class ConversationService
+    {
+        private readonly BaseController _baseController;
+        const string BaseRoute = "v1/Conversation/";
+
+        public ConversationService(BaseController baseController)
+        {
+            _baseController = baseController;
+        }
+
+        public async Task <List<ConversationDto>> MyConversationIsFinished()
+        {
+            var response = await _baseController.Get($"{BaseRoute}MyConversationIsFinished");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<List<ConversationDto>>();
+            
+            return new() ;
+        }
+        public async Task<List<ConversationDto>> MyConversationIsInProgress()
+        {
+            var response = await _baseController.Get($"{BaseRoute}MyConversationIsInProgress");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<List<ConversationDto>>();
+
+            return new();
+        }
+        public async Task<List<ConversationDto>> ConversationAwaitingOurResponse()
+        {
+            var response = await _baseController.Get($"{BaseRoute}ConversationAwaitingOurResponse");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<List<ConversationDto>>();
+
+            return new();
+        }
+        public async Task<bool> MarkAsReadConversationItemAsync(int ID)
+        {
+            var response = await _baseController.Put($"{BaseRoute}MarkAsReadConversationItem/{ID}");
+            return response.IsSuccessStatusCode;
+
+        }
+        public async Task<List<ConversationItemDto>> GetConversationItems(int ConversationID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}ConversationItems/{ConversationID}");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<List<ConversationItemDto>>();
+
+            return new();
+        }
+        public async Task ADDConversationItemFromCompanySide(int ConversationID,string text)
+        {
+            var response = await _baseController.Post($"{BaseRoute}ADDConversationItemFromCompanySide/{ConversationID}",new ADDConversationItemDto()
+            {
+                ConversationID = ConversationID,
+                text=text
+            });
+            /* if (response.IsSuccessStatusCode)
+                 return await response.Content.ReadFromJsonAsync<List<ConversationItemDto>>();
+
+            // return new();*/
+        }
+        public async Task<bool> ConversationIsFinish(int ConversationID)
+        {
+            var response = await _baseController.Put($"{BaseRoute}ConversationIsFinish/{ConversationID}");
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<bool> ConversationIsStart(int ConversationID)
+        {
+            var response = await _baseController.Put($"{BaseRoute}ConversationIsStart/{ConversationID}");
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<int> GetCountQueueCompany(int CompanyID,int GroupID=0)
+        {
+            var response = await _baseController.Get($"{BaseRoute}CountQueueCompany/{CompanyID}?GroupID={GroupID}");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<int>();
+
+            return -1;
+        }
+        public async Task<List<ConversationDto>> MyConversationUserSide(int CompanyID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}ConversationFromUserSide/{CompanyID}");
+            if (response.IsSuccessStatusCode)
+                return await response.Content.ReadFromJsonAsync<List<ConversationDto>>();
+
+            return new();
+        }
+    }
+}

Presentation/HushianWebApp/Service/GroupService.cs

@@ -0,0 +1,94 @@
+using Common.Dtos.Exper;
+using Common.Dtos.Group;
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class GroupService
+    {
+        private readonly BaseController _baseController;
+        const string BaseRoute = "v1/Group/";
+
+        public GroupService(BaseController baseController)
+        {
+            _baseController = baseController;
+        }
+       public async Task<bool> AddGroup(ADD_GroupDto Group)
+        {
+            var response = await _baseController.Post($"{BaseRoute}AddGroup",Group);
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool> UpdateGroup(Update_GroupDto Group)
+        {
+            var response = await _baseController.Put($"{BaseRoute}UpdateGroup", Group);
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<bool> JoinExperToGroup(int GroupID, string ExperID)
+        {
+            var response = await _baseController.Put($"{BaseRoute}JoinExperToGroup/{GroupID}/{ExperID}");
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<bool> UnJoinExperToGroup(int GroupID, string ExperID)
+        {
+            var response = await _baseController.Put($"{BaseRoute}UnJoinExperToGroup/{GroupID}/{ExperID}");
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<bool> DeleteGroupFromManager(int GroupID)
+        {
+            var response = await _baseController.Delete ($"{BaseRoute}DeleteGroup/{GroupID}");
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<List<Read_GroupDto>?> GetGroupsCompany()
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetGroupsCompany");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<List<GroupDto>>();
+            }
+            return null;
+        }
+        public async Task<List<Read_GroupDto>?> GetGroupsCompany(int CompanyID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetGroupsCompany?CompanyID={CompanyID}");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<List<Read_GroupDto>>();
+            }
+            return null;
+        }
+        public async Task<List<Read_GroupDto>?> GetGroupsFromExperID(string ExperID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetGroupsFromExperID?ExperID={ExperID}");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<List<Read_GroupDto>>();
+            }
+            return new();
+        }
+        public async Task<List<Read_ExperDto>> GetExpersFromGroupID(int GroupID)
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetExpersFromGroupID/{GroupID}");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<List<Read_ExperDto>>();
+            }
+            return new();
+        }
+        public async Task<bool> ChangeAvailableGroupFromManager(int GroupID, bool Available)
+        {
+            var response = await _baseController.Put($"{BaseRoute}ChangeAvailableGroupFromManager/{GroupID}?Available={Available}");
+            return response.IsSuccessStatusCode;
+        }
+
+        //public async Task<List<HushianUserDto>?> GetOnlineExpersFromGroupID(int GroupID)
+        //{
+        //    var response = await _baseController.Get($"{BaseRoute}GetOnlineExpersFromGroupID/{GroupID}");
+        //    if (response.IsSuccessStatusCode)
+        //    {
+        //        return await response.Content.ReadFromJsonAsync<List<HushianUserDto>>();
+        //    }
+        //    return null;
+        //}
+    }
+}

Presentation/HushianWebApp/Service/LocalStorageService.cs

@@ -0,0 +1,42 @@
+using Microsoft.JSInterop;
+using System.Text.Json;
+
+namespace HushianWebApp.Services
+{
+    public interface ILocalStorageService
+    {
+        Task<T> GetItem<T>(string key);
+        Task SetItem<T>(string key, T value);
+        Task RemoveItem(string key);
+    }
+
+    public class LocalStorageService : ILocalStorageService
+    {
+        private IJSRuntime _jsRuntime;
+
+        public LocalStorageService(IJSRuntime jsRuntime)
+        {
+            _jsRuntime = jsRuntime;
+        }
+
+        public async Task<T> GetItem<T>(string key)
+        {
+            var json = await _jsRuntime.InvokeAsync<string>("localStorage.getItem", key);
+
+            if (json == null)
+                return default;
+
+            return JsonSerializer.Deserialize<T>(json);
+        }
+
+        public async Task SetItem<T>(string key, T value)
+        {
+            await _jsRuntime.InvokeVoidAsync("localStorage.setItem", key, JsonSerializer.Serialize(value));
+        }
+
+        public async Task RemoveItem(string key)
+        {
+            await _jsRuntime.InvokeVoidAsync("localStorage.removeItem", key);
+        }
+    }
+}

Presentation/HushianWebApp/Service/UserService.cs

@@ -0,0 +1,108 @@
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class UserService
+    {
+        private readonly BaseController _baseController;
+        const string BaseRoute = "v1/User/";
+
+        public UserService(BaseController baseController)
+        {
+            _baseController = baseController;
+        }
+        public async Task<bool> AddExper(AddUserDto request)
+        {
+            var response = await _baseController.Post($"{BaseRoute}AddExper", request);
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<PagingDto<HushianUserDto>?> GetExpersCompany(int CompanyID, int PageIndex = 1, int PageSize = 10)
+        {
+            string route = $"{BaseRoute}GetExpersCompany?CompanyID={CompanyID}&PageIndex={PageIndex}&PageSize={PageSize}";
+
+            var response = await _baseController.Get(route);
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<PagingDto<HushianUserDto>>();
+            }
+            return null;
+        }
+        public async Task<List<HushianUserDto>?> GetOnlineExpersCompany(int CompanyID)
+        {
+            string route = $"{BaseRoute}GetOnlineExpersCompany?CompanyID={CompanyID}";
+
+            var response = await _baseController.Get(route);
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<List<HushianUserDto>>();
+            }
+            return null;
+        }
+        //--------------------------------------------------------------------------------------------------------------
+        public async Task<PagingDto<HushianUserDto>?> GetUsersCompanyFromManager(int PageIndex = 1, int PageSize = 10)
+        {
+            string route = $"{BaseRoute}GetUsersCompany?PageIndex={PageIndex}&PageSize={PageSize}";
+
+            var response = await _baseController.Get(route);
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<PagingDto<HushianUserDto>>();
+            }
+            return null;
+        }
+        public async Task<bool> EditUserYourself(EditUserFromUserDto request) //ویرایش کاربران توسط خود
+        {
+            var response = await _baseController.Put($"{BaseRoute}EditUserYourself", request);
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<HushianUserDto?> GetCurrentUser() //ویرایش کاربران توسط خود
+        {
+            var response = await _baseController.Get($"{BaseRoute}GetCurrentUser");
+            if (response.IsSuccessStatusCode)
+            {
+                return await response.Content.ReadFromJsonAsync<HushianUserDto>();
+            }
+            return null;
+        }
+        public async Task<bool> ExperEditingFromManager(EditUserFromUserDto request) //ویرایش کاربران توسط مدیرش
+        {
+            var response = await _baseController.Put($"{BaseRoute}ExperEditingFromManager", request);
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool> ChangePasswordYourself(ChangePasswordFromUserDto request) //تغییر کلمه عبور  کاربران توسط خود
+        {
+            var response = await _baseController.Put($"{BaseRoute}ChangePasswordYourself", request);
+            return response.IsSuccessStatusCode;
+        }
+        public async Task<bool> CheckAvailableExperInCompany(string? ExperID=null) 
+        {
+            string route = $"{BaseRoute}CheckAvailableExperInCompany";
+            if (!string.IsNullOrEmpty(ExperID))
+                route += $"?ExperID={ExperID}";
+            var response = await _baseController.Get(route);
+            return response.IsSuccessStatusCode;
+        }
+
+
+        public async Task<bool> ChangeAvailableExperFromManager(string ExperID,bool Available)
+        {
+            var response = await _baseController.Put($"{BaseRoute}ChangeAvailableExperFromManager/{ExperID}?Available={Available}");
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool>DeleteExperFromManager(string ExperID)
+        {
+            var response = await _baseController.Delete($"{BaseRoute}DeleteExperFromManager/{ExperID}");
+            return response.IsSuccessStatusCode;
+        }
+
+        public async Task<bool> FreeExper()
+        {
+            var response = await _baseController.Delete($"{BaseRoute}FreeExper");
+            return response.IsSuccessStatusCode;
+        }
+
+
+    }
+}

Presentation/HushianWebApp/Service/VerificationService.cs

@@ -0,0 +1,52 @@
+using Common.Dtos.User;
+using Common.Enums;
+using System.Net.Http.Json;
+
+namespace HushianWebApp.Service
+{
+    public class VerificationService
+    {
+        private readonly BaseController _baseController;
+
+        public VerificationService(BaseController baseController)
+        {
+            _baseController = baseController;
+        }
+
+        public async Task<int> FromUserName(string mobile, VerificationCodeType type)
+        {
+
+                string route = type switch
+                {
+                    VerificationCodeType.PhoneNumberConfirmed => "PhoneNumberConfirmedFromUserName",
+                    VerificationCodeType.ForgetPassword => "ForgetPasswordFromUserName",
+                    VerificationCodeType.ChangeMobile => throw new NotImplementedException(),
+                    VerificationCodeType.Login => throw new NotImplementedException(),
+                    _ => throw new NotImplementedException()
+                };
+                var response = await _baseController.Get($"v1/Verification/{route}/{mobile}");
+                if (response.IsSuccessStatusCode)
+                {
+                    return await response.Content.ReadFromJsonAsync<int>();
+                }
+                else
+                {
+                    return 0;
+                }
+           
+            
+        }
+        public async Task<bool> ConfirmedCode(ConfirmedCodeDto dto)
+        {
+            var response = await _baseController.Post($"v1/Verification/ConfirmedCode", dto);
+            return response.IsSuccessStatusCode;
+
+        }
+        public async Task<bool> ReSendCode(int ID)
+        {
+            var response = await _baseController.Get($"v1/Verification/ReSendCode/{ID}");
+            return response.IsSuccessStatusCode;
+
+        }
+    }
+}