initial commit

Infrastructure/Hims.Infrastructure.Services/TpaService.cs

+using Hims.Domain.Repositories.UnitOfWork;
+using Hims.Domain.Services;
+using Hims.Shared.UserModels;
+using Hims.Shared.UserModels.Filters;
+using System;
+using Hims.Domain.Entities;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Dapper;
+using Hims.Shared.UserModels.BedManagement.Floor;
+using Hims.Shared.Library;
+using System.Collections;
+using Hims.Shared.EntityModels;
+
+namespace Hims.Infrastructure.Services
+{
+
+    /// <inheritdoc />
+    public class TpaService : ITpaService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IWardService" />
+        public TpaService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+
+        /// <inheritdoc/>
+        public async Task<int> AddTpa(TpaModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""TpaId"") FROM ""Tpa"" WHERE  Lower(""Name"") = '{model.Name.ToLower()}'");
+            if (checkIf > 0)
+            {
+                return -2;
+            }
+            var tpa = new Tpa();
+            tpa.Name = model.Name;
+            tpa.CreatedBy = model.CreatedBy;
+            tpa.CreatedDate = DateTime.Now;
+            tpa.Active = true;
+
+             var result = await this.unitOfWork.Tpa.InsertAsync(tpa);
+            if (result >= 1)
+            {
+                return result;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        /// <inheritdoc/>
+        public async Task<int> ChangeStatus(TpaModel model)
+        {
+            var OldTpa = await this.unitOfWork.Tpa.FindAsync(l => l.TpaId == model.TpaId);
+            OldTpa.Active = (bool)!model.Active;
+            Tpa tpa = new Tpa();
+            tpa.TpaId = (int)model.TpaId;
+            tpa.Name = model.Name;
+            tpa.Active = (bool) !model.Active;
+            tpa.ModifiedBy = model.ModifiedBy;
+            tpa.ModifiedDate = DateTime.Now;
+
+            var result = await this.unitOfWork.Tpa.UpdateAsync(tpa);
+
+            if (result >= 1)
+            {
+                return result;
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        /// <inheritdoc/>
+        public Task<IEnumerable<TpaModel>> GetAllTpa(TpaModel model)
+        {
+            string where = "where 1=1 ";
+
+            if (!string.IsNullOrEmpty(model.Name))
+            {
+                where += $@" and lower(t.""Name"") ilike '%{model.Name.ToLower()}%' ";
+            }
+            
+            if (model.Active != null)
+            {
+                where += $@" and t.""Active"" = {model.Active}";
+            }
+            var Query = $@"	 select count(*) over () as ""TotalItems"", t.""TpaId"",t.""Name"",t.""Active"",A.""FullName"" as ""CreatedByName"",
+			   t.""CreatedDate"", B.""FullName"" as ""ModifiedByName"",t.""CreatedBy"",t.""ModifiedBy"" , t.""ModifiedDate""
+			   from  ""Tpa"" t
+			   join ""Account"" A  on A.""AccountId"" = t.""CreatedBy""
+			   left join ""Account"" B on B.""AccountId"" = t.""ModifiedBy"" {where}";
+
+            if (model.PageSize != null && model.PageIndex != null)
+            {
+                model.PageIndex = model.PageIndex > 0 ? model.PageIndex - 1 : model.PageIndex;
+                Query += $@" limit {model.PageSize} offset {model.PageIndex * model.PageSize}";
+            }
+            return this.unitOfWork.Current.QueryAsync<TpaModel>(Query);
+        }
+
+        /// <inheritdoc/>
+        public async Task<int> UpdateTpa(TpaModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""TpaId"") FROM ""Tpa"" WHERE  Lower(""Name"") = '{model.Name.ToLower()}'");
+            if (checkIf > 0)
+            {
+                return -2;
+            }
+
+            Tpa tpa = new Tpa();
+            tpa.TpaId = (int)model.TpaId;
+            tpa.Name = model.Name;
+            tpa.Active = (bool)model.Active;
+            tpa.ModifiedBy = model.ModifiedBy;
+            tpa.ModifiedDate = DateTime.Now;
+
+            var result = await this.unitOfWork.Tpa.UpdateAsync(tpa);
+
+            if (result >= 1)
+            {
+                return result;
+            }
+            else
+            {
+                return -1;
+            }
+
+        }
+    }
+}

Infrastructure/Hims.Infrastructure.Services/UnitTypeService.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Shared.UserModels.UnitType;
+
+    /// <inheritdoc />
+    public class UnitTypeService : IUnitTypeService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IUnitTypeService" />
+        public UnitTypeService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<ViewModel>> FetchAsync(FilterModel model)
+        {
+            var where = " WHERE 1 = 1 ";
+            if (!string.IsNullOrEmpty(model.Name))
+            {
+                where += $@" AND TRIM(UPPER(""Name"")) = '{model.Name.Trim().ToUpper()}'";
+            }
+
+            //if (model.Active != null)
+            //{
+            //    where += $@" AND ""Active"" IS {((bool)model.Active ? "TRUE" : "FALSE")}";
+            //}
+
+            var query = $@"SELECT COUNT(*) OVER () AS ""TotalItems"", * FROM ""UnitType"" {where} Order by ""UnitTypeId"" DESC";
+
+            if (model.PageIndex <= 0)
+            {
+                return this.unitOfWork.Current.QueryAsync<ViewModel>(query);
+            }
+
+            model.PageIndex -= 1;
+            query += " LIMIT " + model.PageSize + " offset " + (model.PageIndex * model.PageSize);
+            return this.unitOfWork.Current.QueryAsync<ViewModel>(query);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> AddAsync(InsertModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UnitTypeId"") FROM ""UnitType"" WHERE TRIM(UPPER(""Name"")) = '{model.Name.ToUpper().Trim()}'");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+
+            var unitType = new UnitType
+            {
+                Name = model.Name,
+                Min = model.Min,
+                Max = model.Max,
+                CreatedBy = model.CreatedBy,
+                CreatedDate = DateTime.Now,
+            };
+
+            return await this.unitOfWork.UnitType.InsertAsync(unitType);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> UpdateAsync(UpdateModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UnitTypeId"") FROM ""UnitType"" WHERE TRIM(UPPER(""Name"")) = '{model.Name.ToUpper().Trim()}' AND ""UnitTypeId"" <> {model.UnitTypeId}");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+
+            var unitType = await this.unitOfWork.UnitType.FindAsync(m => m.UnitTypeId == model.UnitTypeId);
+            unitType.Name = model.Name;
+            unitType.ModifiedBy = model.ModifiedBy;
+            unitType.ModifiedDate = DateTime.Now;
+            return await this.unitOfWork.UnitType.UpdateAsync(unitType);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> DeleteAsync(DeleteModel id)
+        {
+            var response = await this.unitOfWork.UnitType.DeleteAsync(x => x.UnitTypeId == id.UnitTypeId);
+            return response ? 1 : -1;
+        }
+
+        public async Task<string> FindNameByUnitTypeId(int id)
+        {
+            var query = $@"SELECT ""Name"" FROM ""UnitType"" WHERE ""UnitTypeId"" = {id}";
+            var response = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<string>(query);
+            return response;
+        }
+
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/UserExcelHistoryService.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Threading.Tasks;
+    using System.Collections.Generic;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Shared.EntityModels;
+    using Dapper;
+    using Hims.Shared.UserModels.UserExcel;
+
+    /// <inheritdoc />
+    public class UserExcelHistoryService : IUserExcelHistoryService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IExcelUploadHistoryService" />
+        public UserExcelHistoryService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public async Task<IEnumerable<ExcelUploadHistoryModel>> FetchAllAsync(ExcelUploadHistoryModel model)
+        {
+            var where = "where 1=1 ";
+
+            if (!string.IsNullOrEmpty(model.TypeOf))
+            {
+                where += $@" and EUH.""TypeOf"" ='{model.TypeOf}'";
+            }
+
+            var query = $@" Select count(EUH.*) over() as ""TotalItems"",EUH.*, A.""FullName"" as ""UploadedByName"", l.""Name"" as ""LocationName"" from ""ExcelUploadHistory"" EUH 
+                            join ""Account"" A on A.""AccountId"" = EUH.""UploadedBy""
+                            left join ""Location"" l on l.""LocationId"" = EUH.""LocationId""
+                            {where}
+                            order by ""CreatedDate"" desc";
+
+            if (model.PageIndex != null && model.PageSize != null)
+            {
+                model.PageIndex = model.PageIndex > 0 ? model.PageIndex - 1 : model.PageIndex;
+                query += $@" limit {model.PageSize} offset {model.PageSize * model.PageIndex}";
+            }
+
+            return await this.unitOfWork.Current.QueryAsync<ExcelUploadHistoryModel>(query);
+        }
+
+        /// <inheritdoc />
+        public async Task<UserExcelHistoryModel> GetSingleExcelHistory(int userExcelHistoryId)
+        {
+            var data = await this.unitOfWork.UserExcelHistory.FindAsync(m => m.UserExcelHistoryId == userExcelHistoryId);
+            return new UserExcelHistoryModel
+            {
+
+                CreatedDate = data.CreatedDate,
+                UserExcelHistoryId = data.UserExcelHistoryId,
+
+                SheetName = data.SheetName,
+                //SheetType = data.SheetType,
+
+                UploadedBy = data.UploadedBy
+            };
+        }
+
+        public async Task<int> ModifyExcelUploadAsync(UserExcelHistoryModel model)
+        {
+            var upload = new UserExcelHistory
+            {
+                CreatedDate = DateTime.UtcNow.AddMinutes(330),
+                SheetName = model.SheetName,
+                UploadedBy = model.UploadedBy,
+                LocationId = model.LocationId,
+                AddedUsers = model.AddedUsers,
+            };
+            if(model.UserExcelHistoryId == 0)
+            {
+                return await this.unitOfWork.UserExcelHistory.InsertAsync(upload);
+            }
+            else
+            {
+                var previousRecord = await this.unitOfWork.UserExcelHistory.FindAsync(m => m.UserExcelHistoryId == model.UserExcelHistoryId);
+                var completeUserList = previousRecord.AddedUsers + "," + upload.AddedUsers;
+                previousRecord.AddedUsers = completeUserList;
+                await this.unitOfWork.UserExcelHistory.UpdateAsync(previousRecord);
+                return previousRecord.UserExcelHistoryId;
+            }
+        }
+
+        public async Task<IEnumerable<UserExcelHistoryModel>> FetchAllAsync(UserExcelHistoryModel model)
+        {
+            var where = "where 1=1 ";
+
+            var query = $@" Select count(UEH.*) over() as ""TotalItems"",UEH.*, A.""FullName"" as ""UploadedByName"", l.""Name"" as ""LocationName"" from ""UserExcelHistory"" UEH 
+                            join ""Account"" A on A.""AccountId"" = UEH.""UploadedBy""
+                            left join ""Location"" l on l.""LocationId"" = UEH.""LocationId""
+                            {where}
+                            order by ""CreatedDate"" desc";
+
+            if (model.PageIndex != null && model.PageSize != null)
+            {
+                model.PageIndex = model.PageIndex > 0 ? model.PageIndex - 1 : model.PageIndex;
+                query += $@" limit {model.PageSize} offset {model.PageSize * model.PageIndex}";
+            }
+
+            return await this.unitOfWork.Current.QueryAsync<UserExcelHistoryModel>(query);
+        }
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/ValidatorServices.cs

+using Hims.Shared.Library.Enums;
+
+namespace Hims.Infrastructure.Services
+{
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+
+    /// <inheritdoc />
+    public class ValidatorServices : IValidatorService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IValidatorService" />
+        public ValidatorServices(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public async Task<int> ValidateEmailAsync(string query, string type, int referenceId)
+        {
+            var accountCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"select count(""AccountId"") from ""Account"" where LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) and ""ReferenceId"" <> '{referenceId}' AND ""Email"" != ''");
+            switch (type)
+            {
+                case "Patient":
+                    return await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""PatientId"") FROM ""Patient"" WHERE LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) AND ""PatientId"" <> '{referenceId}' AND ""Email"" != '' ");
+                case "User":
+                    var userResponse = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UserId"") FROM ""User"" WHERE LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) AND ""UserId"" <> '{referenceId}'");
+                    return accountCount + userResponse;
+                case "Provider":
+                    var providersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""ProviderId"") FROM ""Provider"" WHERE LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) AND ""ProviderId"" <> '{referenceId}' AND ""Email"" != ''");
+                    var usersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UserId"") FROM ""User"" WHERE LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) AND ""UserId"" <> '{referenceId}' AND ""RoleId"" IN ({(int)Roles.Nurse},{(int)Roles.Receptionist})");
+                    return providersCount + usersCount + accountCount;
+                default:
+                    return 0;
+            }
+        }
+
+        /// <inheritdoc />
+        public async Task<int> ValidateMobileAsync(string query, int countryId, string type, int referenceId)
+        {
+            var accountCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"select count(""AccountId"") from ""Account"" where ""Mobile"" = '{query}' AND ""CountryId"" = '{countryId}' and ""Mobile"" != '' and ""ReferenceId"" <> '{referenceId}' ");
+            switch (type)
+            {
+                case "Patient":
+                    return await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""PatientId"") FROM ""Patient"" WHERE ""Mobile"" = '{query}' AND ""CountryId"" = '{countryId}' AND ""PatientId"" <> '{referenceId}'");
+                case "User":
+                    var userCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UserId"") FROM ""User"" WHERE ""Mobile"" = '{query}' AND ""CountryId"" = '{countryId}' AND ""UserId"" <> '{referenceId}'");
+                    return userCount + accountCount;
+                case "Provider":
+                    var providersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""ProviderId"") FROM ""Provider"" WHERE ""Mobile"" = '{query}' AND ""CountryId"" = '{countryId}' AND ""ProviderId"" <> '{referenceId}' AND ""Mobile"" != ''");
+                    var usersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UserId"") FROM ""User"" WHERE ""Mobile"" = '{query}' AND ""CountryId"" = '{countryId}' AND ""UserId"" <> '{referenceId}' AND ""RoleId"" IN ({(int)Roles.Nurse},{(int)Roles.Receptionist}) ");
+                    return providersCount + usersCount + accountCount;
+                default:
+                    return 0;
+            }
+        }
+
+        /// <inheritdoc />
+        public Task<int> ValidateNpiAsync(string query, int providerId) =>
+            this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>(
+                $@"SELECT COUNT(""ProviderId"") FROM ""Provider"" WHERE ""NPI"" = '{query}' AND ""ProviderId"" <> '{providerId}'");
+
+        /// <inheritdoc />
+        public Task<int> ValidatePharmacyProductAsync(string query, int? pharmacyProductId)
+        {
+            var where = string.Empty;
+            if(pharmacyProductId != null)
+            {
+                where += $@" and ""PharmacyProductId"" <> {pharmacyProductId}";
+            }
+            var querys = $@"SELECT count(""PharmacyProductId"") FROM ""PharmacyProduct"" where LOWER(TRIM(""ProductName"")) = LOWER(TRIM('{query}')) {where}";
+            return this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>(querys);
+        }
+
+        public async Task<int> ValidateUserNameAsync(string query, string type, int referenceId)
+        {
+            var accountCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"select count(""AccountId"") from ""Account"" where LOWER(TRIM(""UserName"")) = LOWER(TRIM('{query}')) and ""ReferenceId"" <> '{referenceId}' AND ""UserName"" != ''");
+            switch (type)
+            {
+                case "Patient":
+                    return await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""PatientId"") FROM ""Patient"" WHERE LOWER(TRIM(""UserName"")) = LOWER(TRIM('{query}')) AND ""PatientId"" <> '{referenceId}' AND ""UserName"" != '' ");
+                case "User":
+                    var userResponse = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(ad.""ReferenceId"") FROM ""Account"" ad LEFT JOIN ""User"" usr on usr.""UserId"" = ad.""ReferenceId"" WHERE LOWER(TRIM(ad.""Email"")) = LOWER(TRIM('{query}')) AND usr.""UserId"" <> '{referenceId}' ");
+                    return accountCount + userResponse;
+                case "Provider":
+                    ///var providersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""ProviderId"") FROM ""Provider"" WHERE LOWER(TRIM(""Email"")) = LOWER(TRIM('{query}')) AND ""ProviderId"" <> '{referenceId}' AND ""UserName"" != ''");
+                    var providersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(ad.""ReferenceId"") FROM ""Account"" ad LEFT JOIN ""User"" usr on usr.""UserId"" = ad.""ReferenceId"" WHERE LOWER(TRIM(ad.""Email"")) = LOWER(TRIM('{query}')) AND usr.""UserId"" <> '{referenceId}' ");
+                    ///var usersCount = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""UserId"") FROM ""User"" WHERE LOWER(TRIM(""UserName"")) = LOWER(TRIM('{query}')) AND ""UserId"" <> '{referenceId}' AND ""RoleId"" IN ({(int)Roles.Nurse},{(int)Roles.Receptionist})");
+                    var usersCount = 0;
+                    return providersCount + usersCount + accountCount;
+                default:
+                    return 0;
+            }
+        }
+    }
+}

Infrastructure/Hims.Infrastructure.Services/VideoCallHistoryServices.cs

+namespace Hims.Infrastructure.Services
+{
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+
+    using Dapper;
+
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+
+    using Hims.Shared.EntityModels;
+    using Hims.Shared.UserModels;
+
+    /// <inheritdoc />
+    public class VideoCallHistoryServices : IVideoCallHistoryService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VideoCallHistoryServices"/> class.
+        /// </summary>
+        /// <param name="unitOfWork">
+        /// The unit of work.
+        /// </param>
+        public VideoCallHistoryServices(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <summary>
+        /// The fetch async.
+        /// </summary>
+        /// <param name="appointmentId">
+        /// The appointment id.
+        /// </param>
+        /// <returns>
+        /// The <see cref="Task"/>.
+        /// </returns>
+        public async Task<IEnumerable<VideoCallHistoryModel>> FetchAsync(int appointmentId)
+        {
+            var where = $@"WHERE 1 = 1";
+
+            if (appointmentId > 0)
+            {
+                where = $@"WHERE a.""AppointmentId"" = {appointmentId}";
+            }
+
+            var query = $@"SELECT
+	                                v.*,
+	                                a.""AppointmentDate"",
+	                                a.""AppointmentTime"",
+	                                p.""FullName"" AS ""DoctorFullName"",
+	                                pa.""FullName"" AS ""PatientFullName"",
+                                    d.""Status"",
+                                    d.""Reason""
+                                FROM
+	                                ""VideoCallHistory"" v
+	                                LEFT JOIN ""Appointment"" A ON A.""AppointmentId"" = v.""AppointmentId""
+	                                LEFT JOIN ""Provider"" P ON P.""ProviderId"" = A.""ProviderId""
+	                                LEFT JOIN ""Patient"" pa ON pa.""PatientId"" = A.""PatientId""
+                                    LEFT JOIN ""DoctorDeviceDetails"" d on d.""AppointmentId"" = v.""AppointmentId""
+	                                
+	                                {where} ORDER BY v.""VideoCallHistoryId"" desc LIMIT 10";
+            var records = await this.unitOfWork.Current.QueryAsync<VideoCallHistoryModel>(query);
+            return records;
+        }
+
+        /// <summary>
+        /// The fetch async.
+        /// </summary>
+        /// <param name="appointmentId">
+        /// The appointment id.
+        /// </param>
+        /// <param name="doctorDeviceDetailsId">
+        /// The doctor device details id.
+        /// </param>
+        /// <returns>
+        /// The <see cref="Task"/>.
+        /// </returns>
+        public async Task<VideoCallHistoryInfo> FetchAsync(int appointmentId, int doctorDeviceDetailsId)
+        {
+            var where = $@"WHERE v.""AppointmentId"" = {appointmentId} AND v.""DoctorDeviceDetailsId"" = {doctorDeviceDetailsId}";
+
+            var query = $@"SELECT
+	                                v.*
+                                FROM
+	                                ""VideoCallHistory"" v
+	                                
+	                                {where} LIMIT 1";
+            var record = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<VideoCallHistoryModel>(query);
+
+            var history = new VideoCallHistoryInfo();
+            query = $@"SELECT * FROM ""DoctorDeviceDetails"" WHERE ""DoctorDeviceDetailsId"" = {doctorDeviceDetailsId}";
+            history.Doctor = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<DoctorDeviceDetailsModel>(query);
+
+            if (record.PatientDeviceDetailsId > 0)
+            {
+                query = $@"SELECT * FROM ""PatientDeviceDetails"" WHERE ""PatientDeviceDetailsId"" = {record.PatientDeviceDetailsId}";
+                history.Patient = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<PatientDeviceDetailsModel>(query);
+            }
+
+            return history;
+        }
+
+        /// <summary>
+        /// The insert async.
+        /// </summary>
+        /// <param name="appointmentId">
+        /// The appointment id.
+        /// </param>
+        /// <returns>
+        /// The <see cref="Task"/>.
+        /// </returns>
+        public async Task<int> InsertAsync(int appointmentId)
+        {
+            var query = $@"SELECT ""DoctorDeviceDetailsId""
+                                FROM
+	                            ""DoctorDeviceDetails"" WHERE ""AppointmentId"" = {appointmentId} ORDER BY ""DoctorDeviceDetailsId"" desc LIMIT 1";
+            var doctorDeviceDetailsId = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int?>(query);
+
+            query = $@"SELECT ""PatientId""
+                                FROM
+	                            ""Appointment"" WHERE ""AppointmentId"" = {appointmentId} LIMIT 1";
+            var patientId = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int?>(query);
+
+            query = $@"SELECT ""PatientDeviceDetailsId""
+                                FROM
+	                            ""PatientDeviceDetails"" WHERE ""PatientId"" = {patientId} ORDER BY ""PatientDeviceDetailsId"" desc LIMIT 1";
+            var patientDeviceDetailsId = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int?>(query);
+
+            var data = new VideoCallHistory
+            {
+                AppointmentId = appointmentId,
+                DoctorDeviceDetailsId = doctorDeviceDetailsId ?? 0,
+                PatientDeviceDetailsId = patientDeviceDetailsId ?? 0
+            };
+
+            var response = await this.unitOfWork.VideoCallHistories.InsertAsync(data);
+            return response;
+        }
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/VisitTypeService.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Shared.EntityModels;
+    using Shared.UserModels.Filters;
+
+    /// <inheritdoc />
+    public class VisitTypeService : IVisitTypeService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IVisitTypeService" />
+        public VisitTypeService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<VisitTypeModel>> FetchAsync(VisitTypeFilterModel model)
+        {
+            var where = " WHERE 1 = 1 ";
+            if (!string.IsNullOrEmpty(model.VisitorName))
+            {
+                where += $@" AND TRIM(UPPER(""VisitorName"")) = '{model.VisitorName.Trim().ToUpper()}'";
+            }
+
+            if (model.Active != null)
+            {
+                where += $@" AND ""Active"" IS {((bool)model.Active ? "TRUE" : "FALSE")}";
+            }
+            var query = $@"select count(VT.""VisitTypeId"") over() as ""TotalItems"", VT.""VisitTypeId"", VT.""VisitorName"", VT.""VisitTypeFor"", VT.""Active"", VT.""CreatedBy"", VT.""CreatedDate"",
+		                        VT.""ModifiedBy"", VT.""ModifiedDate"", VT.""RowColor"",
+		                        C.""FullName"" as ""CreatedByName"", CR.""RoleName"" as ""CreatedByRole"",M.""FullName"" as ""ModifiedByName"", MR.""RoleName"" as ""ModifiedByRole""
+                             FROM ""VisitType"" VT
+                             left join ""Account"" C on C.""AccountId"" = VT.""CreatedBy""
+                             left join ""Role"" CR on CR.""RoleId"" = C.""RoleId""
+                             left join ""Account"" M on M.""AccountId"" = VT.""ModifiedBy""
+                             left join ""Role"" MR on MR.""RoleId"" = M.""RoleId""
+                                {where}
+                             order by VT.""CreatedDate"" desc";
+
+            
+
+            //if (model.PageIndex <= 0)
+            //{
+            //    return this.unitOfWork.Current.QueryAsync<VisitTypeModel>(query);
+            //}
+
+            //model.PageIndex -= 1;
+            //query += " LIMIT " + model.PageSize + " offset " + (model.PageIndex * model.PageSize);
+            return this.unitOfWork.Current.QueryAsync<VisitTypeModel>(query);
+        }
+     
+
+        /// <inheritdoc />
+        public async Task<int> AddAsync(VisitTypeModel model)
+        {
+            try
+            {
+                var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""VisitTypeId"") FROM ""VisitType"" WHERE TRIM(UPPER(""VisitorName"")) = '{model.VisitorName.ToUpper().Trim()}'");
+                if (checkIf > 0)
+                {
+                    return -1;
+                }
+
+                var visitType = new VisitType
+                {
+                    Active = true,    
+                    VisitorName = model.VisitorName,
+                    VisitTypeFor = model.VisitTypeFor,
+                    CreatedBy = model.CreatedBy,
+                    CreatedDate = DateTime.Now,
+                    RowColor=model.RowColor
+
+                };
+
+                return await this.unitOfWork.Visitors.InsertAsync(visitType);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message.ToString());
+            }
+
+            return 0;
+        }       
+
+        /// <inheritdoc />
+        public async Task<int> UpdateAsync(VisitTypeModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""VisitTypeId"") FROM ""VisitType"" WHERE TRIM(UPPER(""VisitorName"")) = '{model.VisitorName.ToUpper().Trim()}' AND ""VisitTypeId"" <> {model.VisitTypeId}");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+
+            var visitType = await this.unitOfWork.Visitors.FindAsync(m => m.VisitTypeId == model.VisitTypeId);
+            visitType.VisitorName = model.VisitorName;
+            visitType.VisitTypeFor = model.VisitTypeFor;
+            visitType.Active = true;
+            visitType.ModifiedBy = model.ModifiedBy;
+            visitType.ModifiedDate = DateTime.Now;
+            visitType.RowColor = model.RowColor;
+            return await this.unitOfWork.Visitors.UpdateAsync(visitType);
+        }
+
+        /// <inheritdoc />
+        public Task<int> DeleteAsync(int visitTypeId)
+        {
+            var query = $@"DELETE FROM ""VisitType"" WHERE ""VisitTypeId""= {visitTypeId}";
+            return this.unitOfWork.Current.ExecuteAsync(query);
+        }
+
+        public async Task<string> FindNameByVisitorId(int visitTypeId)
+        {
+            var query = $@"SELECT ""VisitorName"" FROM ""VisitType"" WHERE ""VisitTypeId"" = {visitTypeId}";
+            var response = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<string>(query);
+            return response;
+        }
+
+        /// <inheritdoc />
+        public async Task<int> ModifyStatusAsync(VisitTypeModel model)
+        {
+            var query = $@"UPDATE ""VisitType""
+	                           SET ""ModifiedBy""={model.CreatedBy}, ""ModifiedDate""=now(), ""Active""= {model.Active}
+	                           WHERE ""VisitTypeId""= {model.VisitTypeId}";
+            return await this.unitOfWork.Current.ExecuteAsync(query);
+        }
+
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/VitalTypeService.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Hims.Shared.Library;
+    using Shared.EntityModels;
+    using Shared.UserModels.VitalType;
+    using Resource = Hims.Shared.UserModels.UnitType;
+
+    /// <inheritdoc />
+    public class VitalTypeService : IVitalTypeService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IVitalTypeService" />
+        public VitalTypeService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<ViewModel>> FetchAsync(FilterModel model)
+        {
+            var where = " WHERE 1 = 1 ";
+            if (!string.IsNullOrEmpty(model.Name))
+            {
+                where += $@" AND TRIM(UPPER(""Name"")) = '{model.Name.Trim().ToUpper()}'";
+            }
+
+            //if (model.Active != null)
+            //{
+            //    where += $@" AND ""Active"" IS {((bool)model.Active ? "TRUE" : "FALSE")}";
+            //}
+
+            var query = $@"SELECT COUNT(*) OVER () AS ""TotalItems"", * FROM ""VitalType"" {where} Order by ""VitalTypeId"" DESC";
+
+            if (model.PageIndex <= 0)
+            {
+                return this.unitOfWork.Current.QueryAsync<ViewModel>(query);
+            }
+
+            model.PageIndex -= 1;
+            query += " LIMIT " + model.PageSize + " offset " + (model.PageIndex * model.PageSize);
+            return this.unitOfWork.Current.QueryAsync<ViewModel>(query);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> AddAsync(InsertModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""VitalTypeId"") FROM ""VitalType"" WHERE TRIM(UPPER(""Name"")) = '{model.Name.ToUpper().Trim()}'");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+
+            var vitalType = new VitalType
+            {
+
+                Name = model.Name,
+                UnitType = model.UnitType,
+                Min = model.Min,
+                Max = model.Max,
+                CreatedBy = model.CreatedBy,
+                CreatedDate = DateTime.Now,
+
+            };
+
+            return await this.unitOfWork.VitalType.InsertAsync(vitalType);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> UpdateAsync(UpdateModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""VitalTypeId"") FROM ""VitalType"" WHERE TRIM(UPPER(""Name"")) = '{model.Name.ToUpper().Trim()}' AND ""VitalTypeId"" <> {model.VitalTypeId}");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+
+            var vitalType = await this.unitOfWork.VitalType.FindAsync(m => m.VitalTypeId == model.VitalTypeId);
+            vitalType.Name = model.Name;
+            vitalType.UnitType = model.UnitType;
+            vitalType.Min = model.Min;
+            vitalType.Max = model.Max;
+            vitalType.ModifiedBy = model.ModifiedBy;
+            vitalType.ModifiedDate = DateTime.Now;
+            return await this.unitOfWork.VitalType.UpdateAsync(vitalType);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> DeleteAsync(DeleteModel id)
+        {
+            var response = await this.unitOfWork.VitalType.DeleteAsync(x => x.VitalTypeId == id.VitalTypeId);
+            return response ? 1 : -1;
+        }
+
+        public async Task<string> FindNameByVitalTypeId(int id)
+        {
+            var query = $@"SELECT ""Name"" FROM ""VitalType"" WHERE ""VitalTypeId"" = {id}";
+            var response = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<string>(query);
+            return response;
+        }
+
+        public async Task<IEnumerable<Resource.ViewModel>> FetchUnitTypeAsync()
+        {
+            var query = $@"SELECT
+	                        ""UnitTypeId"" AS ""Id"",
+	                        ""Name"" AS ""Name"" 
+                        FROM
+	                        ""UnitType"" ";
+            var records = await this.unitOfWork.Current.QueryAsync<Resource.ViewModel>(query);
+            return records;
+        }
+
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/WalletServices.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Shared.EntityModels;
+    using Shared.UserModels.Filters;
+
+    /// <inheritdoc />
+    public class WalletServices : IWalletService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WalletServices"/> class.
+        /// </summary>
+        /// <param name="unitOfWork">
+        /// The unit of work.
+        /// </param>
+        public WalletServices(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<WalletModel>> FetchAsync(WalletFilterModel model)
+        {
+            var query = $@"WITH CTS AS(SELECT ""PatientId"", ""WalletId"", COALESCE(""CreditedAmount"", 0) AS ""CreditedAmount"", COALESCE(""DebitedAmount"", 0) AS ""DebitedAmount"", ""CreditedFor"", ""CreatedDate"" FROM ""Wallet"" )
+                        ,TOTAL AS (SELECT ""PatientId"",COALESCE(SUM(""CreditedAmount""),0) AS ""TotalCredits"",COALESCE(SUM(""DebitedAmount""),0) AS ""TotalDebits""
+                        FROM ""Wallet"" GROUP By ""PatientId"")
+                        SELECT a.*,b.""TotalCredits"",b.""TotalDebits"" FROM CTS a
+                        JOIN TOTAL b ON a.""PatientId""=b.""PatientId"" 
+                        WHERE a.""PatientId"" = {model.PatientId} ORDER BY ""WalletId"" DESC ";
+
+            if (model.PageIndex <= 0)
+            {
+                return this.unitOfWork.Current.QueryAsync<WalletModel>(query);
+            }
+
+            model.PageIndex -= 1;
+            query += " LIMIT " + model.PageSize + " offset " + (model.PageIndex * model.PageSize);
+            return this.unitOfWork.Current.QueryAsync<WalletModel>(query);
+        }
+
+        /// <inheritdoc />
+        public Task<WalletModel> FindAsync(int patientId)
+        {
+            var query = $@"SELECT ""PatientId"",COALESCE(SUM(""CreditedAmount""),0) AS ""TotalCredits"",COALESCE(SUM(""DebitedAmount""),0) AS ""TotalDebits""
+                        FROM ""Wallet"" WHERE ""PatientId"" = {patientId} GROUP By ""PatientId""";
+
+            return this.unitOfWork.Current.QueryFirstOrDefaultAsync<WalletModel>(query);
+        }
+
+        /// <inheritdoc />
+        public Task AddAsync(WalletModel model)
+        {
+            var wallet = new Wallet
+            {
+                CreatedDate = DateTime.UtcNow,
+                PatientId = model.PatientId,
+                CreditedAmount = model.CreditedAmount,
+                DebitedAmount = model.DebitedAmount,
+                CreditedFor = model.CreditedFor
+            };
+
+            return this.unitOfWork.Wallet.InsertAsync(wallet);
+        }
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/WardService.cs

+namespace Hims.Infrastructure.Services
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Dapper;
+    using Domain.Entities;
+    using Domain.Repositories.UnitOfWork;
+    using Domain.Services;
+    using Hims.Shared.Library;
+    using Shared.EntityModels;
+    using Shared.UserModels.Filters;
+
+    /// <inheritdoc />
+    public class WardService : IWardService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IWardService" />
+        public WardService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc />
+        public Task<IEnumerable<WardModel>> FetchAsync(WardFilterModel model)
+        {
+            var where = " WHERE 1 = 1 ";
+            
+            if (model.FloorId > 0)
+            {
+                where += $@" AND F.""FloorId"" = {model.FloorId}";
+            }
+            if (model.LocationId > 0)
+            {
+                where += $@" AND F.""LocationId"" = {model.LocationId}";
+            }
+            if (model.WardId > 0)
+            {
+                where += $@" AND W.""WardId"" = {model.WardId}";
+            }
+
+            if (!string.IsNullOrEmpty(model.FloorName))
+            {
+                where += $@" and F.""FloorName"" ilike '%{model.FloorName}%' ";
+            }
+
+            if (!string.IsNullOrEmpty(model.WardName))
+            {
+                where += $@" and W.""WardName"" ilike '%{model.WardName}%' ";
+            }
+            //if (model.LocationId > 0)
+            //{
+            //    where += $@" AND F.""LocationId""  = {model.LocationId}";
+            //}
+           
+            var query = $@"SELECT COUNT(*) OVER () AS ""TotalItems"",W.""Active"",
+                        W.""WardId"",  W.""WardName"" ,CA.""FullName"" AS ""CreatedByName"" , MA.""FullName"" AS ""ModifiedByName"" , W.""CreatedDate"", W.""ModifiedDate"",
+                         F.""FloorName"", F.""FloorId"",L.""Name"" as ""LocationName"" ,L.""LocationId""
+                       FROM ""Ward"" W
+                       JOIN ""Floor"" F on F.""FloorId""=W.""FloorId""
+                       Join ""Location"" L on L.""LocationId""=F.""LocationId""
+                       Left Join ""Account"" CA ON CA.""AccountId"" = W.""CreatedBy""         
+                       Left Join ""Account"" MA ON MA.""AccountId"" = W.""ModifiedBy""
+                                {where} Order by ""WardId"" DESC";
+            if (model.PageIndex <= 0)
+            {
+                return this.unitOfWork.Current.QueryAsync<WardModel>(query);
+            }
+
+            model.PageIndex -= 1;
+             query += $@" limit {model.PageSize} offset {model.PageSize * model.PageIndex}";
+            return this.unitOfWork.Current.QueryAsync<WardModel>(query);
+        }
+
+        /// <inheritdoc />
+        public Task<IEnumerable<Resource>> FetchWardAsync(WardFilterModel model)
+        {
+            var where = " WHERE 1 = 1 ";
+            if (model.FloorId > 0)
+            {
+                where += $@" AND F.""FloorId"" = {model.FloorId}";
+            }
+            if (model.LocationId > 0)
+            {
+               where += $@" and F.""LocationId"" = {model.LocationId}";
+            }
+            var query = $@"SELECT COUNT(*) OVER () AS ""TotalItems"",W.""Active"",
+                        W.""WardId"" AS ""Id"",W.""WardName"" AS ""Value"" ,F.""FloorName"" AS ""OptionalText1"", L.""Name"" AS ""OptionalText""
+                                FROM ""Ward"" W
+                                JOIN ""Floor"" F on F.""FloorId""=W.""FloorId""
+                                 Join ""Location"" L on F.""LocationId"" = L.""LocationId""
+                                {where} and  W.""Active"" = true Order by ""WardId"" DESC";          
+            return this.unitOfWork.Current.QueryAsync<Resource>(query);
+        }
+
+
+        /// <inheritdoc />
+        public async Task<int> AddAsync(WardModel model)
+        {
+            
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""WardId"")  FROM ""Ward"" WHERE TRIM(UPPER(""WardName"")) = '{model.WardName.ToUpper().Trim()}' and ""FloorId"" ={model.FloorId}");
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+            var ward = new Ward
+            {
+                Active = true,
+                WardName = model.WardName,
+                CreatedBy = model.CreatedBy,
+                CreatedDate = DateTime.Now,
+                FloorId = model.FloorId,
+            };
+            return await this.unitOfWork.Wards.InsertAsync(ward);
+        }
+       
+        /// <inheritdoc />
+        public async Task<int> UpdateAsync(WardModel model)
+        {
+            var checkIf = await this.unitOfWork.Current.QueryFirstOrDefaultAsync<int>($@"SELECT COUNT(""WardId"")  FROM ""Ward"" WHERE TRIM(UPPER(""WardName"")) = '{model.WardName.ToUpper().Trim()}' and ""FloorId"" ={model.FloorId}");
+            var ward = await this.unitOfWork.Wards.FindAsync(m => m.WardId == model.WardId);
+            ward.WardName = model.WardName;
+            ward.Active = model.Active;
+            ward.ModifiedBy = model.ModifiedBy;
+            ward.ModifiedDate = DateTime.Now;
+            ward.FloorId = model.FloorId;
+
+            if (model.updateStatus==true)
+                return await this.unitOfWork.Wards.UpdateAsync(ward);
+            if (checkIf > 0)
+            {
+                return -1;
+            }
+            
+
+
+            
+            return await this.unitOfWork.Wards.UpdateAsync(ward);
+        }
+
+        /// <inheritdoc />
+        public async Task<int> DeleteAsync(int wardId)
+        {
+            var query1 = $@"select count(""BedId"") from ""Admission"" where ""IsDischarged"" is false and ""Active"" is true and ""BedId"" in (select b.""BedId"" from ""Bed"" b join ""Room"" r on r.""RoomId"" = b.""RoomId"" where r.""WardId"" = {wardId}) ";
+            var response1 = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int>(query1);
+            if (response1 > 0)
+            {
+                return -2;
+            }
+            var query = $@"DELETE FROM ""Ward"" WHERE ""WardId""= {wardId}";
+            return await this.unitOfWork.Current.ExecuteAsync(query);
+        }
+
+        public async Task<string> FindNameByWardId(int wardId)
+        {
+            var query = $@"SELECT ""WardName"" FROM ""Ward"" WHERE ""WardId"" = {wardId}";
+            var response = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<string>(query);
+            return response;
+        }
+
+        /// <summary>
+        /// Changes the status asynchronous.
+        /// </summary>
+        /// <param name="model">The model.</param>
+        /// <returns></returns>
+        public async Task<int> ChangeStatusAsync(WardModel model)
+        {
+            var query = $@"select count(""BedId"") from ""Admission"" where ""IsDischarged"" is false and ""Active"" is true and ""BedId"" in (select b.""BedId"" from ""Bed"" b join ""Room"" r on r.""RoomId"" = b.""RoomId"" where r.""WardId"" = {model.WardId}) ";
+            var response = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int>(query);
+            if (response > 0)
+            {
+                return -2;
+            }
+            var ward = await this.unitOfWork.Wards.FindAsync(m => m.WardId == model.WardId);
+            if (ward == null)
+            {
+                return -1;
+            }
+            ward.Active = model.Active;
+            ward.ModifiedBy = model.ModifiedBy;
+            ward.ModifiedDate = DateTime.Now;
+            return await this.unitOfWork.Wards.UpdateAsync(ward);
+        }
+
+    }
+}
\ No newline at end of file

Infrastructure/Hims.Infrastructure.Services/WhatsAppTicketsService.cs

+using Dapper;
+using Hims.Domain.Entities;
+using Hims.Domain.Repositories.UnitOfWork;
+using Hims.Domain.Services;
+using Hims.Shared.UserModels;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Hims.Infrastructure.Services
+{
+    public class WhatsAppTicketsService : IWhatsAppTicketsService
+    {
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+
+        /// <inheritdoc cref="IWardService" />
+        public WhatsAppTicketsService(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        /// <inheritdoc/>
+        public async Task<int> ChangeStatus(WhatsAppTicketsModel model)
+        {
+            var OldWhatsAppTicket = await this.unitOfWork.WhatsAppTickets.FindAsync(l => l.TicketId == model.TicketId);
+            if (OldWhatsAppTicket == null)
+            {
+                return -3;
+            }
+            OldWhatsAppTicket.Solved = (bool)!model.Solved;
+            OldWhatsAppTicket.ModifiedBy = model.ModifiedBy;
+            OldWhatsAppTicket.ModifiedDate = DateTime.Now;
+            return  await this.unitOfWork.WhatsAppTickets.UpdateAsync(OldWhatsAppTicket);
+
+            
+        }
+
+        /// <inheritdoc/>
+        public Task<IEnumerable<WhatsAppTicketsModel>> GetAllWhatsAppTickets(WhatsAppTicketsModel model)
+        {
+            string where = "where 1=1 ";
+
+            if (!string.IsNullOrEmpty(model.Name))
+            {
+                where += $@" and lower(wt.""Name"") ilike '%{model.Name.ToLower()}%' ";
+            }
+
+            if (model.Solved != null)
+            {
+                where += $@" and wt.""Solved"" = {model.Solved}";
+            }
+            if(model.Mobile != null)
+            {
+                where += $@" and wt.""Mobile"" ilike '%{model.Mobile}%' ";
+            }
+
+            var Query = $@"select count(*) over () as ""TotalItems"", wt.""TicketId"",wt.""TicketNo"",wt.""Mobile"",wt.""Name"",
+			   wt.""Regarding"", wt.""Solved"",wt.""CreatedDate"" , wt.""ModifiedBy"", B.""FullName"" as ""ModifiedByName"" , wt.""ModifiedDate"" From ""WhatsAppTickets"" wt
+                 left join ""Account"" B on B.""AccountId"" = wt.""ModifiedBy""  {where}  Order by wt.""TicketId"" desc";
+
+            if (model.PageSize != null && model.PageIndex != null)
+            {
+                model.PageIndex = model.PageIndex > 0 ? model.PageIndex - 1 : model.PageIndex;
+                Query += $@" limit {model.PageSize} offset {model.PageIndex * model.PageSize}";
+            }
+            return this.unitOfWork.Current.QueryAsync<WhatsAppTicketsModel>(Query);
+        }
+    }
+}

Infrastructure/Hims.Infrastructure.Services/WorkingHourServices.cs

+
+
+namespace Hims.Infrastructure.Services
+{
+    using Dapper;
+    using Hims.Domain.Entities;
+    using Hims.Domain.Repositories.UnitOfWork;
+    using Hims.Domain.Services;
+    using Hims.Shared.UserModels;
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Threading.Tasks;
+    public class WorkingHourServices : IWorkingHourService
+    {
+        /// <summary>
+        /// The unit of work.
+        /// </summary>
+        private readonly IUnitOfWork unitOfWork;
+        /// <inheritdoc cref="IWorkingHourService" />
+        public WorkingHourServices(IUnitOfWork unitOfWork) => this.unitOfWork = unitOfWork;
+
+        public async Task<IEnumerable<WorkingHourModel>> FetchAllAsyn(WorkingHourModel model)
+        {
+            var where = "where 1=1";
+            var query = $@"select WH.""WorkingHourId"", WH.""StartTime"", WH.""StartDate"", WH.""EndDate"", WH.""EndTime"", WH.""Active"",WH.""CreatedBy"", WH.""CreatedDate"",
+		                        WH.""ModifiedBy"", WH.""ModifiedDate"",
+								 ac.""FullName"" as ""CreatedByName"", CR.""RoleName"" as ""CreatedByRole"",
+								 M.""FullName"" as ""ModifiedByName"", MR.""RoleName"" as ""ModifiedByRole""
+                                from ""WorkingHour"" WH
+                                JOIN ""Account"" ac on ac.""AccountId""=WH.""CreatedBy""
+								join ""Role"" CR on CR.""RoleId"" = ac.""RoleId""
+								 left join ""Account"" M on M.""AccountId"" = WH.""ModifiedBy""
+                             left join ""Role"" MR on MR.""RoleId"" = M.""RoleId""
+                                              { where}
+                                 order by WH.""CreatedDate"" desc";               
+            return await this.unitOfWork.Current.QueryAsync<WorkingHourModel>(query);
+        }
+
+        public async Task<int> InsertAsync(WorkingHourModel model)
+        {
+
+           
+       
+                var checkIf = await this.unitOfWork.Current.QuerySingleOrDefaultAsync<int>($@"select count(*) from ""WorkingHour"" where  ""StartDate"" ilike'{model.StartDate}' and ""EndDate"" ilike '{model.EndDate}' and ""StartTime""  ilike '{model.StartTime}' and ""EndTime"" ilike '{model.EndTime}'");
+                if (checkIf > 0)
+                {
+                    return -1;
+                }
+
+                var workingHour = new WorkingHour
+                {
+                    StartDate = model.StartDate,
+                    StartTime = model.StartTime,
+                    EndDate = model.EndDate,
+                    EndTime = model.EndTime,
+                    CreatedBy = model.CreatedBy,
+                    Active = true,
+                    CreatedDate = DateTime.Now,
+                };
+                return await this.unitOfWork.WorkingHour.InsertAsync(workingHour);
+            
+           
+        }
+        public async Task<int> ActivateOrDeactivateTest(WorkingHourModel model)
+        {
+            var query = $@"UPDATE ""WorkingHour""
+	                           SET ""ModifiedBy""={model.CreatedBy}, ""ModifiedDate""=now(), ""Active""= {model.Active}
+	                           WHERE ""WorkingHourId""= {model.WorkingHourId}";
+            return await this.unitOfWork.Current.ExecuteAsync(query);
+        }
+        /// <inheritdoc/>
+        public async Task<int> UpdateAsync(WorkingHourModel model)
+        {
+                var record = await this.unitOfWork.WorkingHour.FindAsync(m => m.WorkingHourId == model.WorkingHourId);
+                if (record == null)
+                {
+                    return -2;
+                }
+                record.ModifiedBy = model.CreatedBy;
+                record.ModifiedDate = DateTime.Now;
+                record.StartDate = model.StartDate;
+                record.StartTime = model.StartTime;
+                record.EndDate = model.EndDate;
+                record.EndTime = model.EndTime;
+
+            return await this.unitOfWork.WorkingHour.UpdateAsync(record);
+            
+        }
+
+    }
+}

Logs/README.md

+# virtual-steth-portal
+
+Virtual Steth Logs
\ No newline at end of file

Presentation/Hims.Admin/.eslintrc.json

+{
+  "root": true,
+  "ignorePatterns": [
+    "projects/**/*"
+  ],
+  "overrides": [
+    {
+      "files": [
+        "*.ts"
+      ],
+      "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:@angular-eslint/recommended",
+        "plugin:@angular-eslint/template/process-inline-templates"
+      ],
+      "rules": {
+        "@typescript-eslint/no-explicit-any": "off",
+        "@angular-eslint/component-class-suffix": "off"
+      }
+    },
+    {
+      "files": [
+        "*.html"
+      ],
+      "extends": [
+        "plugin:@angular-eslint/template/recommended",
+        "plugin:@angular-eslint/template/accessibility"
+      ],
+      "rules": {
+        "@angular-eslint/template/label-has-associated-control": "off"
+      }
+    }
+  ]
+}
\ No newline at end of file

Presentation/Hims.Admin/Controllers/HomeController.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Hims.Admin.Controllers
+{
+    public class HomeController : Controller
+    {
+        public IActionResult Index()
+        {
+            return View();
+        }
+    }
+}

Presentation/Hims.Admin/Controllers/IdentityController.cs

+namespace Hims.Admin.Controllers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Security.Claims;
+    using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Authentication;
+    using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Mvc;
+    using Newtonsoft.Json;
+    using Shared.Library;
+    using Utilities;
+
+    /// <inheritdoc />
+    [Route("api/identity")]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    [AllowAnonymous]
+    public class IdentityController : BaseController
+    {
+        /// <summary>
+        /// The sign in user.
+        /// </summary>
+        /// <param name="userIdentity">
+        /// The user identity model.
+        /// </param>
+        /// <returns>
+        /// The http response. <see cref="ActionResult"/>.
+        /// </returns>
+        [ProducesResponseType(200)]
+        [ProducesResponseType(500)]
+        [HttpPost]
+        [Route("sign-in")]
+        public async Task<ActionResult> SignInAsync([FromBody] UserAccount userIdentity)
+        {
+            try
+            {
+                var claims = new List<Claim> { new Claim("UserAccount", JsonConvert.SerializeObject(userIdentity)) };
+                var claimsIdentity = new ClaimsIdentity(claims, "login");
+                var principal = new ClaimsPrincipal(claimsIdentity);
+                await this.HttpContext.SignInAsync(principal);
+                return this.Success();
+            }
+            catch (Exception exception)
+            {
+                return this.ServerError(exception);
+            }
+        }
+
+        /// <summary>
+        /// The get user identity.
+        /// </summary>
+        /// <returns>
+        /// The http response. <see cref="ActionResult"/>.
+        /// </returns>
+        [ProducesResponseType(200)]
+        [ProducesResponseType(500)]
+        [HttpPost]
+        [Route("get")]
+        public ActionResult GetIdentity()
+        {
+            try
+            {
+                if (!this.User.Identity.IsAuthenticated)
+                {
+                    return this.Success();
+                }
+
+                var user = this.User;
+                if (!(user.Identity is ClaimsIdentity identity))
+                {
+                    return this.Success();
+                }
+
+                var userAccount = identity.Claims.SingleOrDefault(x => x.Type == "UserAccount")?.Value ?? string.Empty;
+                var userIdentity = JsonConvert.DeserializeObject<UserAccount>(userAccount);
+                return this.Success(userIdentity);
+            }
+            catch (Exception exception)
+            {
+                return this.ServerError(exception);
+            }
+        }
+
+        /// <summary>
+        /// The get user identity status.
+        /// </summary>
+        /// <returns>
+        /// The http response. <see cref="ActionResult"/>.
+        /// </returns>
+        [ProducesResponseType(200)]
+        [ProducesResponseType(500)]
+        [HttpPost]
+        [Route("status")]
+        public ActionResult GetStatus()
+        {
+            try
+            {
+                if (!this.User.Identity.IsAuthenticated)
+                {
+                    return this.Success(0);
+                }
+
+                var user = this.User;
+                if (!(user.Identity is ClaimsIdentity identity))
+                {
+                    return this.Success(0);
+                }
+
+                var userAccount = identity.Claims.SingleOrDefault(x => x.Type == "UserAccount")?.Value ?? string.Empty;
+                var userIdentity = JsonConvert.DeserializeObject<UserAccount>(userAccount);
+                return this.Success(userIdentity.RoleId);
+            }
+            catch (Exception exception)
+            {
+                return this.ServerError(exception);
+            }
+        }
+
+        /// <summary>
+        /// The update user identity.
+        /// </summary>
+        /// <param name="authToken">
+        /// The auth token model.
+        /// </param>
+        /// <returns>
+        /// The http response. <see cref="ActionResult"/>.
+        /// </returns>
+        [ProducesResponseType(200)]
+        [ProducesResponseType(500)]
+        [HttpPost]
+        [Route("update")]
+        public async Task<ActionResult> UpdateIdentityAsync([FromBody] AuthToken authToken)
+        {
+            try
+            {
+                var user = this.User;
+                if (!(user.Identity is ClaimsIdentity identity))
+                {
+                    return this.ServerError();
+                }
+
+                var userAccount = identity.Claims.SingleOrDefault(x => x.Type == "UserAccount")?.Value ?? string.Empty;
+                var userIdentity = JsonConvert.DeserializeObject<UserAccount>(userAccount);
+                userIdentity.Token = authToken.Token;
+                userIdentity.ReferenceToken = authToken.ReferenceToken;
+                userIdentity.Expires = authToken.Expires;
+                userIdentity.AllowVideoCall = authToken.AllowVideoCall;
+
+                var claim = identity.Claims.ToList().SingleOrDefault(x => x.Type == "UserAccount");
+                identity.RemoveClaim(claim);
+                identity.AddClaim(new Claim("UserAccount", JsonConvert.SerializeObject(userIdentity)));
+                await this.HttpContext.SignInAsync(user);
+                return this.Success();
+            }
+            catch (Exception exception)
+            {
+                return this.ServerError(exception);
+            }
+        }
+
+        /// <summary>
+        /// The sign out user.
+        /// </summary>
+        /// <returns>
+        /// The http response. <see cref="ActionResult"/>.
+        /// </returns>
+        [ProducesResponseType(200)]
+        [ProducesResponseType(500)]
+        [HttpPost]
+        [Route("sign-out")]
+        public async Task<ActionResult> SignOutAsync()
+        {
+            try
+            {
+                await this.HttpContext.SignOutAsync();
+                return this.Success();
+            }
+            catch (Exception exception)
+            {
+                return this.ServerError(exception);
+            }
+        }
+    }
+}
\ No newline at end of file

Presentation/Hims.Admin/Extensions/AntiForgeryTokenExtension.cs

+namespace Hims.Admin.Extensions
+{
+    using Microsoft.AspNetCore.Builder;
+    using Middleware;
+
+    /// <summary>
+    /// The anti forgery token extension.
+    /// </summary>
+    public static class AntiForgeryTokenExtension
+    {
+        /// <summary>
+        /// The use anti forgery token.
+        /// </summary>
+        /// <param name="builder">
+        /// The builder.
+        /// </param>
+        /// <returns>
+        /// The <see cref="IApplicationBuilder"/>.
+        /// </returns>
+        public static IApplicationBuilder UseAntiForgeryToken(this IApplicationBuilder builder) => builder.UseMiddleware<AntiForgeryTokenMiddleware>();
+    }
+}

Presentation/Hims.Admin/appsettings.json

+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "AllowedHosts": "*",
+  "CookieName": "Hims.Admin"
+}

Presentation/Hims.Admin/tsconfig.app.json

+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./wwwroot",
+  },
+  "files": [
+    "src/main.ts"
+  ],
+  "include": [
+    "src/**/*.d.ts",
+    "**/*.d.ts"
+  ]
+}
\ No newline at end of file